Abstract

The issue of constructing complicated quaternionic holomorphic (-holomorphic) functions in the Cayley-Dickson doubling form is considered. The way of -holomorphic substitutions, allowing us to construct -holomorphic composite functions of any degree of difficulty, is presented. The new –representation form for -holomorphic functions is established as a consequence of the earlier proved commutative behavior of the quaternionic multiplication in the case of -holomorühic functions. The specific polar form of -holomorphic functions with a real-valued modulus and argument similar to complex one is obtained. The -holomorphic generalizations of the logarithmic and inverse trigonometric and hyperbolic functions are implemented. The obtained results reaffirm that any complicated -holomorphic function can be constructed from its complex holomorphic analog. The processing of -holomorphic functions of any degree of difficulty is provided through high-speed programmes in system Wolfram Mathematica^® represented in the Appendix.

1. Introduction

There are known difficulties in different theories of quaternionic analysis (see, e.g., references in ⁵) when constructing quaternionic holomorphic analogs of complex holomorphic functions. However, the so-called essentially adequate concept of quaternionic holomorphy overcomes successfully these difficulties ^{1, 5}.

It is now important to show that this concept enables us to construct not only simple quaternionic holomorphic functions, but also all complicated compositions of them that must be holomorphic as a result as well.

The main principles of this concept are shortly reviewed in the introduction to article ¹. We recall some notions of the essentially adequate concept needed in the sequel.

We denote an independent quaternionic variable by

(1.1)

where are independent real variables, the values

(1.2)

(1.3)

are complex constituents of the quaternion representation in the so-called Cayley-Dickson doubling form: ² and are quaternionic basis vectors of quaternion space

The quaternionic functions are, respectively, denoted by

(1.4)

where and are real-valued functions of real variables (the so-called -representation ³: an explicit dependence on only ).

In the Cayley-Dickson doubling form we use the notation

(1.5)

where

(1.6)

and by “” is denoted the quaternionic multiplication.

For simplicity, we will also denote (in -representation ³: an explicit dependence only on ) the functions and by and or simpler by and We can also denote the functions by ( –representation).

Upon the transition to the complex plane denoted by the Cayley-Dickson doubling form becomes the following complex expression with imaginary unit

The holomorphic functions in the essentially adequate concept of -holomorphy are defined as the quaternionic functions, whose quaternionic derivatives are independent of the so-called “way of their computation” ¹, i.e. independent not only of directions how approaches zero when defining a quaternionic derivative as a limit of a quaternionic difference quotient but also of the manner of quaternionic division of by on the left or on the right.

Strictly speaking, we have the following

Definition 1.1 A quaternionic function is said to be an essentially adequate quaternionic holomorphic function (- holomorphic or, briefly, -holomorphic) at a point if it has a quaternionic derivative independent of a way of its computation in some open connected neighborhood of a point

It was established in ⁵ that the component of any -holomorphic function can be expressed as follows:

(1.7)

where has a symmetric (in variables and ) form that is invariant under complex conjugation:

In other words, the function is real-valued.

Definition 1.1 leads to the following definition of the necessary and sufficient conditions for to be -holomorphic ¹.

Definition 1.2 Suppose that the constituents and of a quaternionic function possess continuous first-order partial derivatives with respect to and in some open connected neighborhood of a point Then a function is -holomorphic (further is denoted by ) at a point if and only if the functions and satisfy in the following quaternionic generalization of complex Cauchy-Riemann's equations:

(1.8)

Here denotes the partial derivative with respect to The overbars designate the complex (also quaternionic if needed) conjugation. The brackets with the closing vertical bar indicate that the transition has been already performed in expressions enclosed in brackets. Thus, dealing with the brackets in (1.8), we, first, calculate the partial derivatives of the functions with respect to variables second, we carry out the transition in them; third, we test equations (1.8).

However, this doesn’t mean that we deal with triplets in general, since the transition (or ) cannot be initially done for quaternionic variables and functions. Any quaternionic function remains the same 4-dimensional quaternionic function regardless of whether we check its holomorphy or not. This transition is needed only to check - holomorphy of any quaternionic function. It is also used when solving the 3D tasks ⁴. For details we refer to ^{1, 4}.

We recall the following theorem, which allows us to get a -holomorphic function directly from its -holomorphic counterpart.

Theorem 1.3. Let a complex function be complex holomorphic everywhere in a connected open set except, possibly, at certain singularities. Then a -holomorphic function of the same kind as can be constructed (without change of a functional dependence form) from by replacing a complex variable (as a single whole) in an expression for by a quaternionic variable where is defined (except, possibly, at certain singularities) by the relation in the sense that exactly follows from upon the transition from to

This theorem allows us to construct each -holomorphic functions from its complex holomorphic (-holomorphic) analog by simple replacing a complex variable by a quaternionic variable without violating of a functional dependence form (function kind).

Technically, to obtain any -holomorphic function, it is sufficient to represent its -holomorphic analog as a function depending only on complex variable (as a single whole), and then to replace by in this analog.

So, for example, we can obtain the corresponding -holomorphic function from its -holomorphic analog However, in such general expressions there are no components and in an explicit form. Therefore we further need to represent such a general expression in the Cayley-Dickson doubling form whence we can extract the components and required to use equations (1.8) and the theory as a whole.

In cases of uncomplicated functions such as etc. and simple compositions of them ⁶ we can easy do it just after replacing by (see “Constructing rule 2.1” in ¹). However, it is very difficult for many complicated -holomorphic compositions of these functions to extract with confidence the functions and which must immediately satisfy equations (1.8).

The aim of this article is to develop some general ways of constructing complicated -holomorphic functions in the Cayley-Dickson doubling form in order to determine their components and

Throughout this article we assume that -holomorphic functions and their derivatives are defined in the simply-connected open domains We do not point concrete domains of functions definition in this article, so that we do not clutter this article and thus further complicate our task. In each case in question they can be specified individually.

As complicated functions we here regard such functions whose expressions are so large and give such a high risk of errors that it is better to employ the computer software.

Given a practical impossibility of manual processing of complicated -holomorphic functions without using computer programmes, we have to represent such programmes in the necessary quantities in the Appendix.

It should be mentioned that we do not study here singularities of -holomorphic functions, since they can be studied as singularities of complex components and It should be also noted that the “” sign of quaternionic multiplication is often omitted if it is clear from the context that values multiplied are quaternionic.

2. Substitutions Way for Complicated -holomorphic Compositions

We present here the natural method of -holomorphic substitutions that allows us to construct composite -holomorphic functions of any degree of difficulty.

Assertion 2.1. A -holomorphic function remains -holomorphic when replacing its argument by another -holomorphic function.

Proof. Consider two - holomorphic functions:

(2.1)

A replacement of the argument of the function by the function can be only exercised as replacement of the “real” part of the argument of by the “real” part of the function and the “imaginery” part of the argument of by the “imaginery” part of the function With this in mind, we now consider the composition of these two - holomorphic functions.

As a base function we define the function in which we carry out substitutions. Such functions examples are considered in the subsection A.1 of the Appendix to this article. We further assume that is -holomorphic in a domain that contains a range of

Introducing the following substitutions:

(2.2)

into base function (2.1): instead of and instead of (correspondingly, instead of and instead of ), we obtain the expression for the composite function as follows:

where and are desired components of the composite function got by the substitutions (2.2).

In complex analysis ( ⁹, p.85) we get a -holomorphic composite function if complex functions and are both -holomorphic. Then by virtue of Theorem 1.3 we get the -holomorphic composite function from by replacing the complex variable by the quaternionic variable without change of a functional dependence forms ( and ). At that, by virtue of the same theorem, the function is -holomorphic as well. Thus, if we will use the - holomorphic function as a substitution into then we shall get immediately the -holomorphic function Q.e.d.

Note that the substitution of the functions instead of the variables respectively, does not change the function kind In other words, the character of actions performed by the functions and with their variables is independent of variables.

Consistently, step by step using this assertion, we can construct composite functions of any degree of difficulty.

Assertion 2.1 does not prohibit using previously obtained complicated -holomorphic composite functions as the functions In this case constructing -holomorphic functions can be significantly simplified. A variety of different composite functions, which can be used as the functions is represented in preprint ⁶.

Example 2.2. We consider the function In this case we have the base -holomorphic function

Then the base function is the following:

where

(2.3)

(2.4)

Since we represent all employed base functions in the subsection A1 “Base functions examples” of the Appendix to this article, we can directly obtain these expressions by launching (or evaluating ⁷) the data cell A1.9. At that, as indicated in Appendix, we need to copy the data cell A1.9 into an empty file .nb (into separate cell) of the computing system Wolfram Mathematica^{® 7} and then launch it there. Speaking of launching any data cell or processing program, we always mean these actions.

In this example the function is the following:

Using the corresponding substitutions into :

we obtain the expressions for the complicated function as follows:

We can get the long deployed expressions for these functions by launching the data cell A2.1.

By the next launching of Program in the cell A3.1 we confirm the - holomorphy of the function

Example 2.3. Now we consider the following complicated composition of four -holomorphic functions:

where

We have to use Assertion 2.1 three times, performing the substitutions step by step, to get the functions:

1) The function By launching the data cell A1.4. from the Appendix (further we will write shortly A1.4.), we get the function as follows:

where

We also have the following conjugate functions:

The first substitutions are the following:

(2.5)

(2.6)

(2.7)

(2.8)

By launching the data cell A1.8 we get the base function as follows:

where

(2.9)

(2.10)

as well as (see ¹ or data cell A1.1.)

(2.11)

(2.12)

Substituting expressions (2.5), (2.6), (2.7), and (2.8), instead of and respectively, into expressions (2.9), (2.10), (2.11) and (2.12), we obtain the following expressions for the function

where

(2.13)

(2.14)

2) The function By launching the data cell A1.5 we get the base function in the case of as follows:

where

(2.15)

(2.17)

(2.18)

To substitute the function into the function we employ the following substitutions:

(2.19)

(2.20)

(2.21)

(2.22)

where and are determined by (2.13) and (2.14).

Substituting (2.19), (2.20), (2.21), (2.22) instead of respectively, into (2.15, (2.16), (2.17), (2.18) we get the following expression for the function :

where

3) The function

By launching the data cell A1.6 we get the base function as follows:

where

(2.23)

(2.24)

The third substitution to get the is the following:

Substituting them into (2.23) and (2.24) as well as into (2.11) and (2.12): instead of instead of instead of and instead of we get the required composition as follows:

where

and

If we replace the variables by their expressions, then we get the deployed expressions for the functions and however they are too long to write them here. It is possible to see the fully deployed expressions for and by launching the data cell A.2.2.

The deployed expressions are just those who are always processed by Programmes A3.1 and A3.2 in Appendix. In programming codes they (corresponding to the components and ) are denoted by and Further, by launching Program A3.1 we use these functions to verify the - holomorphy of the function Calculation of the quaternionic expressions for this function in - representation can be performed by launching the programing cell 3.2.

3. Vector Parts, Polar Forms and Logarithmic Functions of Complicated -holomorphic Functions

3.1. Vector Parts of -holomorphic Functions

The earlier established properties ^{1, 5} of -holomorphic functions allows us to establish a specific form of -holomorphic functions in - representation.

Theorem 3.1. A vector part of any -holomorphic function where are real-valued functions of the real variables can be expressed as follows:

where is a real-valued multiplicative factor

in – representation.

Proof. The expression for is obtained from (1.7) and then rewritten in – representation by using (1.2) and (1.3).

The proof will be divided into 2 steps. First (Step 1) we will prove the expression

(3.1)

Then (Step 2) we will prove the final expression

Step 1. Substituting expressions (1.6), (1.7), (1.3) into (1.5) and using the multiplication rule for the quaternionic units: we immediately obtain the expression (3.1):

where is defined from (1.7) and written in –representation.

Step 2. It was earlier (see e.g. ^{4, 5}) established that in case of -holomorphic functions the relation as is always performed, whence, without loss of generality, we can represent the function in the form

Now, every -holomorphic function can be written as

(3.2)

Let

(3.3)

be another arbitrary -holomorphic function in the –representation (the “” sign is not to be confused with the derivative sign). The and (as well as and ) are different and do not depend on each other.

Let

be two different arbitrary quaternions. As is known ², the general quaternionic multiplication rule is the following:

(3.4)

Substituting the -holomorphic functions (3.2) and (3.3) into (3.4) instead of and relatively, we obtain the quaternionic product as follows:

(3.5)

By exchanging the order of functions multiplication, we get

(3.6)

The main property of the -holomorphic functions established in ¹ is that their quaternionic multiplication behaves as commutative, i.e. Then from (3.5) and (3.6) the following equalities must be met:

(3.7)

(3.8)

(3.9)

(3.10)

The equality (3.7) is the identity, i.e. is fulfilled.

After simplifyung, equalities (3.8), (3.9), (3.10) become, respectively, the following:

(3.11)

(3.12)

(3.13)

The equality (3.11) is the identity, i.e. is fulfilled.

Thus, one is left with two equalities (3.12) and (3.13), which must be met by choice of some and These equalities are fulfilled, if and Then the expressions (3.2) and (3.3) become, respectively, the following:

(3.14)

Thus, we see that a vector part of any -holomorphic function can be expressed by Q.e.d

Remark. The function is arbitrary when considering this theorem. This function is determined, in principle, by equations (1.8). It can be extracted for every concrete -holomorphic function as a real part (see (1.3)) of the function by launching Program A3.2.

We have established a new form of –representation inherent only to -holomorphic functions.

3.2. Polar Form of -holomorphic Functions

There exist some methods to represent quaternions in a polar form. See, for example ⁸, polar form with a complex modulus and complex argument “inspired by the Cayley-Dickson form”. We derive here the polar representation of -holomorphic function with a real modulus and real argument like complex analysis.

According to the definition of a quaternion modulus ² (here in the notation as in (1.1)), we have

Correspondingly, we define a modulus of a -holomorphic function taking into account (3.14) as follows:

Given (3.14), the -holomorphic function can be represented by the following expression:

(3.15)

where the real-valued is determined by (2.12),

Using the quaternionic analog ¹:

(3.16)

of the complex imaginary unit we can rewrite (3.15) as follows:

(3.17)

Then, a polar form (or polar representation) of the -holomorphic function similar to complex one ⁹, is the following:

where, given that the functions are real-valued, we interpret the functions and as follows:

(3.18)

(3.19)

Here plays a role of a polar angle in, so to speak, “the complex plane, with the imaginary unit ”, which is isomorphic to usual complex plane with the imaginary unit since are real-valued. We can also speak of polar coordinates of the -holomorphic functions. Note that we must always replace the complex imaginary unit by the quaternionic imaginary unit when passing from complex case to quaternionic one.

We can finally express polar form of a -holomorphic function similar to complex one as follows:

(3.20)

where

and are determined by (3.18) and (3.19).

Inequalities and must be met. When processing concrete -holomorphic functions it is sufficient to check the equality

It seems useful to employ, when concrete calculating, the following expression for

(3.21)

Example 3.2.1. To illustrate how we get a polar form of a -holomorphic function we consider the uncomplicated function which is defined as the quaternionic generalization of the principal branch of the -holomorphic function

By launching the data cell A1.9 we get the function in –representation:

where and are represented above by (2.3) and (2.4). Note that and are the programming designations for the functions and

The functions constitute the input data for Program A3.2. By launching Program A3.2, we obtain (RESULT 1) the following deployed expression for the function in –representation:

where

Comparing the last three expressions with (3.14) and (1.4) we get in –representation as follows:

The expression for is the following:

(3.22)

According to (3.21), we obtain the following expression for real-valued

(3.23)

where is determined by (2.12).

Thus, we have specified polar form of the function

where and are defined by (3.22) and (3.23). The values of and for any -holomorphic function can be calculated by launching Program A3.2 (RESULT 2).

The conformity of polar forms (3.20) of -holomorphic functions and polar forms of complex holomorphic functions ⁹ reflects the similarity between concepts of essentially adequate quaternionic holomorphic functions and holomorphic functions in complex analysis, which is already identified earlier in ¹.

3.3. General Formula for Logarithms of Complicated -holomorphic Functions

The isomorphy of the algebras of complex numbers with imaginary unit and “complex numbers with imaginary unit ” allows us to use the following quaternionic generalization of complex Euler's formula:

Using this formula we rewrite (3.20) as follows:

(3.24)

Substituting the identity into (3.24), we obtain the following expression:

whence, taking into account the above mentioned isomorphy of complex algebras with imaginary units and we have

(3.25)

According to the general definition of the logarithm ⁹, we now get from (3.25) the following expression for the quaternionic logarithm of any complicated -holomorphic function in –representation:

(3.26)

It must be emphasized that we use the designation for natural logarithms, as is customary in system Wolfram Mathematica^®, instead of the usual designation

To get this expression in –representation needed for further processing by Programmes A3.1 and A3.2, we must represent as a quaternionic function in the Cayley-Dickson doubling form. It follows from (1.2) and (1.3) that

Substituting these into (3.16) we get in the Cayley-Dickson doubling form as hollows:

(3.27)

Further, substituting (3.27) into (3.26), we obtain the following expression:

whence, given that is real-valued, we have

Given (3.21), we represent this expression in the Cayley-Dickson doubling form, so to speak, in the mixed and – representation as follows:

where

Considering the function in –representation, we could use Program A3.2 to represent in the form (1.4), whence we could extract the expressions for and in –representation. However, using all programmes of Appendix provides for data input in –representation, and therefore we must rewrite the expressions for and in –representation.

Using expression (1.6) and its complex conjugation, we get directly in –representation as follows:

(3.28)

Further, using (1.7), we have in –representation:

(3.29)

According to usual ⁹ definition of the modulus of a comlex function, we also get the following expression for in –representation:

(3.30)

Finally, we obtain the following general formula for the logarithm of any complicated function in –representation:

(3.31)

where

and and are defined by (3.28), (3.29), (3.30), and (2.12), respectively, in –representation.

Given (3.26), we can interpret logarithms of -holomorphic functions as holomorphic logarithms in “the complex plane with imaginary unit r”. Then we can speak of the principal values domains ⁹: and

Calculation of the logarithm of any complicated -holomorphic function is carried out by the special program represented in the cell A2.5.

Recall that in all data cells and Programmes A3.1, A3.2 we employ the designations of components and of the function in the Cayley-Dickson doubling form instead of designations and respectively.

4. Inverse Trigonometric and Hyperbolic -holomorphic Functions

Now, knowing how to build logarithms of complicated -holomorphic functions, we can construct quaternionic inverse trigonometric and hyperbolic functions.

The principal branches of the basic inverse trigonometric and hyperbolic -holomorphic functions are given ⁹ by the formulas:

where designates an independent complex variable.

It is sufficient to note that the domains of the definitions of logarithms are here such that the inverse functions are single-valued, i.e. if we have then the domain of inverse function with this logarithm can be considered as and . For example, the principal value of the inverse function is given in and In order not to overburden this article we do not here detail.

By replacing the complex variable by the quaternionic variable (here it is taken into account that complex imaginary unit must be also replaced by quaternionic ) we get by virtue of Theorem 1.3 the following quaternionic generalizations of the above principal branches of inverse complex trigonometric and hyperbolic functions:

where “” sign indicates the quaternionic multiplication.

Since we perform the quaternionic generalizations of the principal values of the complex inverse functions, i.e. single-valued functions, it is evident that the above inverse quaternionic trigonometric and hyperbolic functions are single-valued.

To calculate an inverse quaternionic function in question it is necessary 1) to calculate its complicated argument (i.e. the functions and of it), 2) then the logarithmic function of this argument, and then, finally, 3) the inverse quaternionic function on the whole. Next we can verify the -holomorphy of the obtained inverse quaternionic function by launching Program A3.1.

The given sequence of launching is important, since the calculated needed functions and will be transmitted from one data cell or program to another.

Consider in detail the function The needed components and of the complicated variable in the logarithm:

are already got in Example 2.2. They are calculated by launching the data cell A2.1. Next, we launch the data cell A2.5 to obtain the function whereafter we launch the cell A2.6 to calculate, finally, the components and of the inverse function

They are the following:

and

where

Consider the inverse hyperbolic function By launching the data cell A2.4 we obtain the components of the complicated argument Then we launch the data cell A2.5 to calculate the components and of the logarithm of Further, we launch the data cell A2.9 to get, finally, the components and of the function Next, by launching Program A3.1 we can verify whether this function is -holomorphic.

The substitutions into the base function (see Example 2.2) when calculating are the following:

The -holomorphic function is calculated by the following sequence of launching: 1) launching the data cell A2.3 to calculate , 2) launching the data cell A2.5 to calculate and 3) launching the data cell A2.7.

The -holomorphic function is calculated by the following sequence of launching: 1) launching the data cell A2.1, 2) launching the data cell A2.5 to calculate and 3) launching the data cell A2.8.

We shall not dwell further on the remaining inverse functions These can be calculated analogously. They are also -holomorphic. We notice only that calculation of quaternionic arguments in the expressions for these functions is performed by using the following formulas:

Instead of these, it is also possible to use the formulas:

We have shown that within the essentially adequate concept of the quaternionic holomorphy it is possible to construct successfully the complicated -holomorphic functions and their -holomorphic compositions by using the presented substitutions way and the general formula (3.31) for quaternionic logarithmic function, based on deduced expressions for vector parts and polar forms.

We have reaffirmed the main principle of the essentially adequate concept of -holomorphy: all -holomorphic functions of any degree of difficulty can be constructed from their -holomorphic analogs. The established –representations of vector parts and polar forms inherent only to -holomorphic functions are similar to complex ones that demonstrates continuity in the development of the essentially adequate theory of the quaternionic holomorphy.

References

Appendix

The data base and programming codes, without wich no work with complicated -holomorphic functions is practically possible, are represented here.

To work with represented below data and processing programmes we need to open an empty Notebook file .nb in the installed computing system Wolfram Mathematica^{® 7}. Then we need to copy (for instance, by keys "Strg"+"C" and "Strg"+"V") all functions examples and processing programmes, cell by cell, from PDF file of this text into input cells (only one function or one program into one new cell!) of the opened file .nb. Copying starts always with the line (*...*).

Checking the correctness of cells copying, we need to take into account that the functions without semicolon at the end of them must after copying be each in a separate line in the cell of file .nb. All data cells and programmes shall be left-aligned. If it is not a case, then it must be corrected by the Enter key in copied file .nb. For more details, refer to ^{1, 6}.

Further, to launch each function data or programing code we need to click on it's cell in the file .nb of Wolfram Mathematica^® computing system, and then holding down the Shift key while press the Enter key. When speaking of launching (evaluating ⁷) any programming code in any cell we will always mean this sequence of key-board and mouse actions.

The task of each data cell is to calculate the functions which are, respectively, the programming designations for the components and of a quaternionic function in question. The designations and are used, respectively instead of and in programming codes. In the case of quaternionic derivatives the functions and can designate, respectively, the components and of the th derivative in its Cayley-Dickson doubling form ¹.

These components are calculated by launching the data cells. The lastest calculated expressions for and remain in Mathematica^® computing system memory as long as they will be replaced by the others. By launching the functions processing, it is important to remember what the functions and are in computing system memory at the moment.

The functions and are the input data for data cells A2.5–A2.9 and main Programmes A3.1 and A3.2. Program A3.1 verifies whether a quaternionic function in question is -holomorphic. Program A3.2 calculates the needed quaternionic expressions in –representation for -holomorphic functions in question, including their polar form as well as expressions for the first derivatives, expressions for 3D field vectors and their vortex density and divergence.

The cell A2.5 calculates the logarithm of -holomorphic function given by any of the cells A1.2-A1.9, A2.1-A2.4 as well as by A2.6-A2.9 or another -holomorphic function.

Calculation of the inverse trigonometric or hyperbolic function is proceeded in the following sequence: 1) by launching one of the cells: A2.1, A2.3 or A2.4, according to an argument of a logarithm in an inverse function in question, then 2) by launching the cell A2.5 to calculate the Log of this argument, and then 3) by launching one of the cells A2.6 – A2.9, corresponding the inverse function in question. In the case of violation of the correct sequence the programmes generate error messages.

In order to have a possibility to copy all programming codes directly from PDF file of this article into empty input cells of the opened Notebook blank .nb of the computing system Wolfram Mathematica^®, and then to launch them immediately, without corrections, in the file .nb, the following designations are used in programing codes:

1) psi(p), psi1, psi2, psi3, psi4 instead of respectively; 2) phi1, phi2, phi3, phi4 instead of respectively; 3) d1psi, d1f1, d1f2 and d1psi1, d1psi2, d1psi3, d1psi4 instead of and respectively; 4) instead of the components of the vector field and instead of ⁴.

At the beginning of each Mathematica^® session on processing of the -holomorphic functions we necessarily need to launch the data cell A1.1 one time, otherwise data processing shall be incorrect. When having difficulty the more details could be find in ^{1, 6}.

(*Initial functions and variables setting *)

beta=(1/2)*E^((a+ac)/2);

v=(1/2)*Sqrt[4*(a*ac+b*bc)-(a+ac)^2];

alpha=ArcCos[(a+ac)/(2*Sqrt[(a*ac+b*bc)])];

epl=E^v; emin=E^(-v);

s=0; s1=0; forarc=0;

(*A1.2: Funcion p*)

Clear[f1,f2,f1c,f2c,inia1,inia1c,inia2,inia2c,inib1,inib1c, inib2,inib2c, quatfunctiontested];

quatfunctiontested:= "p";

quatfunctiontested

f1[a_,ac_,b_,bc_]:=a;

f2[a_,ac_,b_,bc_]:=b;

f1c[a_,ac_,b_,bc_]:=ac;

f2c[a_,ac_,b_,bc_]:=bc;

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False;

markquot=False; s=0;

(*A1.3: Funcion p^2*)

Clear[f1,f2,f1c,f2c,inia1,inia1c, inia2,inia2c, inib1,inib1c, inib2,inib2c, quatfunctiontested];

quatfunctiontested:=Evaluate[p^2];

quatfunctiontested

f1[a_,ac_,b_,bc_]:=a^2-b*bc

f2[a_,ac_,b_,bc_]:=(a+ac)*b

f1c[a_,ac_,b_,bc_]:=ac^2-b*bc

f2c[a_,ac_,b_,bc_]:=(a+ac)*bc

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False;

markquot=False; s=0;

(*A1.4: Funcion p^3*)

Clear[f1,f2,f1c,f2c,inia1,inia1c, inia2,inia2c, inib1,inib1c, inib2,inib2c, quatfunctiontested];

quatfunctiontested:=Evaluate[p^3];

quatfunctiontested

f1[a_,ac_,b_,bc_]:=a^3-(2*a+ac)*b*bc

f2[a_,ac_,b_,bc_]:=(a^2+a*ac+ac^2)*b-b^2*bc

f1c[a_,ac_,b_,bc_]:=ac^3-(2*ac+a)*b*bc

f2c[a_,ac_,b_,bc_]:=(ac^2+a*ac+a^2)*bc-bc^2*b

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False;

markquot=False; s=0;

A1.5. The Function

(*A1.5: Function 1/p*)

Clear[f1,f2,f1c,f2c,inia1,inia1c, inia2,inia2c, inib1,inib1c, inib2,inib2c, quatfunctiontested];

quatfunctiontested:=Evaluate[1/p];

quatfunctiontested

f1[a_,ac_,b_,bc_]:=ac/(a*ac+b*bc)

f2[a_,ac_,b_,bc_]:=-b/(a*ac+b*bc)

f1c[a_,ac_,b_,bc_]:=a/(a*ac+b*bc)

f2c[a_,ac_,b_,bc_]:=-bc/(a*ac+b*bc)

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False;

markquot=False; s=0;

(*A1.6: Funcion sinp*)

Clear[f1,f2,f1c,f2c,inia1,inia1c, inia2,inia2c, inib1,inib1c, inib2,inib2c, quatfunctiontested];

quatfunctiontested:="sinp";

quatfunctiontested

f1[a_,ac_,b_,bc_]:=((emin+epl)*Sin[(a+ac)/2])/2-((a-ac)*(emin-epl)*Cos[(a+ac)/2])/(4*v)

f2[a_,ac_,b_,bc_]:=-((emin-epl)*Cos[(a+ac)/2]*b)/(2*v)

f1c[a_,ac_,b_,bc_]:=((emin+epl)*Sin[(a+ac)/2])/2-((ac-a)*(emin-epl)*Cos[(a+ac)/2])/(4*v)

f2c[a_,ac_,b_,bc_]:=-((emin-epl)*Cos[(a+ac)/2]*bc)/(2*v)

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False;

markquot=False; s=0;

(*A1.7: Funcion cosp*)

Clear[f1,f2,f1c,f2c,inia1,inia1c, inia2,inia2c, inib1,inib1c, inib2,inib2c, quatfunctiontested];

quatfunctiontested:="cosp";

quatfunctiontested

f1[a_,ac_,b_,bc_]:=((emin+epl)*Cos[(a+ac)/2])/2+((a-ac)*(emin-epl)*Sin[(a+ac)/2])/(4*v)

f2[a_,ac_,b_,bc_]:=((emin-epl)*b*Sin[(a+ac)/2])/(2*v)

f1c[a_,ac_,b_,bc_]:=((emin+epl)*Cos[(a+ac)/2])/2+((ac-a)*(emin-epl)*Sin[(a+ac)/2])/(4*v)

f2c[a_,ac_,b_,bc_]:=((emin-epl)*bc*Sin[(a+ac)/2])/(2*v)

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False;

markquot=False; s=0;

(*A1.8: Funcion e^p*)

Clear[f1,f2,f1c,f2c,inia1,inia1c,inia2,inia2c,inib1,inib1c,inib2,inib2c,quatfunctiontested];

quatfunctiontested:=Evaluate[e^p];

quatfunctiontested

f1[a_,ac_,b_,bc_]:=2*beta*Cos[v]+(beta*(a-ac)*Sin[v])/v;

f2[a_,ac_,b_,bc_]:=(2*beta*b*Sin[v])/v;

f1c[a_,ac_,b_,bc_]:=2*beta*Cos[v]+(beta*(ac-a)*Sin[v])/v;

f2c[a_,ac_,b_,bc_]:=(2*beta*bc*Sin[v])/v;

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False;

markquot=False; s=0;

A1.9. The Function

(*A1.9: Quaternionic generalization of a principal branch of a complex square root*)

Clear[f1,f2,f1c,f2c,inia1,inia1c, inia2,inia2c, inib1,inib1c, inib2,inib2c, quatfunctiontested];

quatfunctiontested:= Evaluate[Sqrt[p]];

quatfunctiontested

sr:=(Sqrt[((a+ac)/2+Sqrt[a*ac+b*bc])/2]);

f1[a_,ac_,b_,bc_]:=sr+(a-ac)/(4*sr);f1c[a_,ac_,b_,bc_]:=sr+(ac-a)/(4*sr);

f2[a_,ac_,b_,bc_]:=b/(2*sr);

f2c[a_,ac_,b_,bc_]:=bc/(2*sr);

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False;

markquot=False; s=0;

A2.1. The Function

(*A2.1: Funcion p+Sqrt[p^2-1], argument of Log in the functions Arccos(p) and Arccosh(p) *)

Clear[f1,f2,f1c,f2c,inia1,inia1c,inia2,inia2c,inib1,inib1c,inib2,inib2c,quatfunctiontested];

quatfunctiontested:=Evaluate[p+Sqrt[p^2-1]];

ta:=a^2-b*bc-1;tac:=ac^2-b*bc-1;tb:=(a+ac)*b;tbc:=(a+ac)*bc;

sr1:=Sqrt[((ta+tac)/2+Sqrt[ta*tac+tb*tbc])];

f1[a_,ac_,b_,bc_]:=a+(ta-tac)/(2*Sqrt[2]*sr1)+sr1/Sqrt[2];f1c[a_,ac_,b_,bc_]:=ac+(tac-ta)/(2*Sqrt[2]*sr1)+sr1/Sqrt[2];

f2[a_,ac_,b_,bc_]:=b+tb/(Sqrt[2]*sr1);

f2c[a_,ac_,b_,bc_]:=bc+tbc/(Sqrt[2]*sr1);

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"];

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False;markquot=False; s=0; s1=0; forarc=1;

A2.2. The Function

(*A2.2: Funcion sin(1/(e^p^3))*)

Clear[f1,f2,f1c,f2c,inia1,inia1c,inia2,inia2c,inib1,inib1c,inib2,inib2c,quatfunctiontested];

quatfunctiontested:=Evaluate[Sin[1/e^(p^3)]];

quatfunctiontested

ta:=a^3-(2*a+ac)*b*bc;

tb:=(a^2+a*ac+ac^2)*b-b^2*bc;

tac:=ac^3-(2*ac+a)*b*bc;

tbc:=(ac^2+a*ac+a^2)*bc-bc^2*b;

tbeta=(1/2)*E^((ta+tac)/2);

tv=(1/2)*Sqrt[4*(ta*tac+tb*tbc)-(ta+tac)^2];

t2a:=Simplify[2*tbeta*Cos[tv]+(tbeta*(ta-tac)*Sin[tv])/tv];

t2b:=Simplify[(2*tbeta*tb*Sin[tv])/tv];

t2ac:=Simplify[2*tbeta*Cos[tv]+(tbeta*(tac-ta)*Sin[tv])/tv];

t2bc:=Simplify[(2*tbeta*tbc*Sin[tv])/tv];

t3a:=Simplify[t2ac/(t2a*t2ac+t2b*t2bc)];

t3b:=Simplify[-t2b/(t2a*t2ac+t2b*t2bc)];

t3ac:=Simplify[t2a/(t2a*t2ac+t2b*t2bc)];

t3bc:=Simplify[-t2bc/(t2a*t2ac+t2b*t2bc)];

t3v=Simplify[(1/2)*Sqrt[4*(t3a*t3ac+t3b*t3bc)-(t3a+t3ac)^2]];

t3epl=Simplify[E^t3v];

t3emin=Simplify[E^(-t3v)];

f1[a_,ac_,b_,bc_]:=Simplify[((t3emin+t3epl)*Sin[(t3a+t3ac)/2])/2-((t3a-t3ac)*(t3emin-t3epl)*Cos[(t3a+t3ac)/2])/(4*t3v)];

f2[a_,ac_,b_,bc_]:=Simplify[-((t3emin-t3epl)*Cos[(t3a+t3ac)/2]*t3b)/(2*t3v)];

f1c[a_,ac_,b_,bc_]:=Simplify[((t3emin+t3epl)*Sin[(t3a+t3ac)/2])/2-((t3ac-t3a)*(t3emin-t3epl)*Cos[(t3a+t3ac)/2])/(4*t3v)];

f2c[a_,ac_,b_,bc_]:=Simplify[-((t3emin-t3epl)*Cos[(t3a+t3ac)/2]*t3bc)/(2*t3v)];

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False;

markquot=False; s=0;

A2.3. The Function

(*A2.3: Funcion rp+Sqrt[1- p^2], argument of Log in the function Arcsin(p)*)

Clear[f1,f2,f1c,f2c,inia1,inia1c,inia2,inia2c,inib1,inib1c,inib2,inib2c,quatfunctiontested];

quatfunctiontested:=Evaluate[r*p+Sqrt[1-p^2]];

fa1:=(a-ac)/(2*v);fa2:=b/v;fa1c:=(ac-a)/(2*v);fa2c:=bc/v;

fb1:=a; fb2:=b; fb1c:=ac; fb2c:=bc;

p1f1:=fa1*fb1-fa2*fb2c; p1f1c:=fa1c*fb1c-fa2c*fb2;p1f2:=fa1*fb2+fa2*fb1c; p1f2c:=fa1c*fb2c+fa2c*fb1;

ta:=1-a^2+b*bc; tac:=1-ac^2+b*bc; tb:=-(a+ac)*b; tbc:=-(a+ac)*bc;

tsr:=(Sqrt[((ta+tac)/2+Sqrt[ta*tac+tb*tbc])/2]);

p2f1:=tsr+(ta-tac)/(4*tsr); p2f1c:=tsr+(tac-ta)/(4*tsr);

p2f2:=tb/(2*tsr); p2f2c:=tbc/(2*tsr);

f1[a_,ac_,b_,bc_]=Simplify[p1f1+p2f1];f1c[a_,ac_,b_,bc_]=Simplify[p1f1c+p2f1c];

f2[a_,ac_,b_,bc_]=Simplify[p1f2+p2f2];

f2c[a_,ac_,b_,bc_]=Simplify[p1f2c+p2f2c];

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"];

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False; markquot=False; s=0; s1=0; forarc=2;

A2.4. The Function

(*A2.4: Funcion p+Sqrt[1+ p^2], argument of Log in the function Arcsinh(p)*)

Clear[f1,f2,f1c,f2c,inia1,inia1c,inia2,inia2c,inib1,inib1c,inib2,inib2c,quatfunctiontested];

quatfunctiontested:=Evaluate[p+Sqrt[p^2+1]];

ta:=a^2-b*bc+1; tac:=ac^2-b*bc+1; tb:=(a+ac)*b; tbc:=(a+ac)*bc;

sr1:=Sqrt[((ta+tac)/2+Sqrt[ta*tac+tb*tbc])];

f1[a_,ac_,b_,bc_]:=a+(ta-tac)/(2*Sqrt[2]*sr1)+sr1/Sqrt[2];f1c[a_,ac_,b_,bc_]:=ac+(tac-ta)/(2*Sqrt[2]*sr1)+sr1/Sqrt[2];

f2[a_,ac_,b_,bc_]:=b+tb/(Sqrt[2]*sr1);

f2c[a_,ac_,b_,bc_]:=bc+tbc/(Sqrt[2]*sr1);

Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"];

f1[a,ac,b,bc]

f2[a,ac,b,bc]

mark=False; markquot=False; s=0; s1=0; forarc=3;

First we launch one of the functions from A1 or A2 (or another -holomorphic function) and then launch this cell to obtain the logarithm of the function in question, i.e. the functions and of the function

(*A2.5: Special program to get the Log of any -holomorphic function*)

Clear[inia1,inia1c,inia2,inia2c,inib1,inib1c,inib2,inib2c,bbig,m,logm,psi1,coteta, siteta,cosikv];

isf1=!StringFreeQ[ToString[f1[a,ac,b,bc], StandardForm],"f1"];

If[(f1[a,ac,b,bc]===inia1[a,ac,b,bc] inib1[a,ac,b,bc]-inia2[a,ac,b,bc] inib2c[a,ac,b,bc])||isf1||mark,Print[" /////////////////// ERROR:////////////////\n Incorrect data input (including also the improper function f1c). Repeat again launching the correct\n function in question and then the correct sequence of launching the needed programming codes."];

ClearAll[f1,f1c,f2,f2c];,

If[s==0,name=ToString[quatfunctiontested, StandardForm]; argf1=f1[a,ac,b,bc];argf1c=f1c[a,ac,b,bc]; argf2=f2[a,ac,b,bc];argf2c=f2c[a,ac,b,bc]; quatfunctiontested="Log["<>name<>"]"; bbig=Simplify[Cancel[argf2/b]];m=Simplify[Sqrt[argf1*argf1c+argf2*argf2c]]; logm=Simplify[Log[m]];

psi1=Simplify[(argf1+argf1c)/2]; coteta=psi1/m;siteta=(bbig*v)/m;cosikv=Simplify[coteta^2+siteta^2];

f1[a_,ac_,b_,bc_]=Simplify[logm+((a-ac)*ArcTan[(bbig*v)/psi1])/(2*v)]; f1c[a_,ac_,b_,bc_]=Simplify[logm+((ac-a)*ArcTan[(bbig*v)/psi1])/(2*v)];

f2[a_,ac_,b_,bc_]=Simplify[(b*ArcTan[(bbig*v)/psi1])/v];

f2c[a_,ac_,b_,bc_]=Simplify[(bc*ArcTan[(bbig*v)/psi1])/v];]];

If[(f1[a,ac,b,bc]===inia1[a,ac,b,bc] inib1[a,ac,b,bc]-inia2[a,ac,b,bc] inib2c[a,ac,b,bc])||isf1||mark,,Print["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"];];

f1[a,ac,b,bc]

f2[a,ac,b,bc]

s=s+1; mark=False; markquot=False;

A2.6. The Function

(*A2.6: Function Arccos(p), launching this cell should follow only after the following sequence of launching:

1) launching the data cell A2.1, then 2) launching the data cell A2.5 *)

Clear[inia1,inia1c,inia2,inia2c,inib1,inib1c,inib2,inib2c,bbig,m,logm,psi1,coteta, siteta,cosikv];

nolog=StringFreeQ[ToString[quatfunctiontested, StandardForm],"Log"];

If[forarc!=1||nolog||mark,

Print[" /////////////////// ERROR:////////////////\n Incorrect data input! The imposed argument is\n the wrong for the function Arccos. The supplied function\n can not be used. Results can not be correct."];

ClearAll[f1,f1c,f2,f2c];,

If[s1==0,name=ToString[quatfunctiontested, StandardForm];lgf1=f1[a,ac,b,bc]; lgf1c=f1c[a,ac,b,bc];lgf2=f2[a,ac,b,bc]; lgf2c=f2c[a,ac,b,bc];

quatfunctiontested="Arccos(p)=-r*"<>name;

fa1=(ac-a)/(2*v);fa2=-b/v;fa1c=(a-ac)/(2*v);fa2c=-bc/v;

vf1=fa1*lgf1-fa2*lgf2c;vf1c=fa1c*lgf1c-fa2c*lgf2;

f1[a_,ac_,b_,bc_]=Simplify[vf1,TimeConstraint->4400];

f1c[a_,ac_,b_,bc_]=Simplify[vf1c,TimeConstraint->4400];

vf2=fa1*lgf2+fa2*lgf1c;vf2c=fa1c*lgf2c+fa2c*lgf1;

f2[a_,ac_,b_,bc_]=Simplify[vf2,TimeConstraint->4400];

f2c[a_,ac_,b_,bc_]=Simplify[vf2c,TimeConstraint->4400];]];

If[forarc!=1||nolog||mark,,

Print

["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]];

f1[a,ac,b,bc]

f2[a,ac,b,bc]

s1=s1+1; mark=False; markquot=False; s=0; forarc=0;

A2.7. The Function

(*A2.7: Function Arcsin(p), launching only after the following sequence: 1) launching the data cell A2.3, then 2) launching the data cell A2.5 *)

Clear[inia1,inia1c,inia2,inia2c,inib1,inib1c,inib2,inib2c,bbig,m,logm,psi1, coteta,siteta,cosikv];

nolog=StringFreeQ[ToString[quatfunctiontested, StandardForm],"Log"];

If[forarc!=2||nolog||mark,Print[" /////////////////// ERROR:////////////////\n Incorrect data input! The imposed argument is\n the wrong for the function Arcsin. The supplied function\n can not be used. Results can not be correct."];

ClearAll[f1,f1c,f2,f2c],

If[s1==0,name=ToString[quatfunctiontested, StandardForm];lgf1=f1[a,ac,b,bc];lgf1c=f1c[a,ac,b,bc];

lgf2=f2[a,ac,b,bc];lgf2c=f2c[a,ac,b,bc];

quatfunctiontested="Arcsin(p)=-r*"<>name;

fa1=(ac-a)/(2*v); fa2=-b/v; fa1c=(a-ac)/(2*v); fa2c=-bc/v;

vf1=fa1*lgf1-fa2*lgf2c; vf1c=fa1c*lgf1c-fa2c*lgf2;

f1[a_,ac_,b_,bc_]=Simplify[vf1,TimeConstraint->4400];

f1c[a_,ac_,b_,bc_]=Simplify[vf1c,TimeConstraint->4400];

vf2=fa1*lgf2+fa2*lgf1c; vf2c=fa1c*lgf2c+fa2c*lgf1;

f2[a_,ac_,b_,bc_]=Simplify[vf2,TimeConstraint->4400];

f2c[a_,ac_,b_,bc_]=Simplify[vf2c,TimeConstraint->4400];]];

If[forarc!=2||nolog||mark,,

Print

["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]];

f1[a,ac,b,bc]

f2[a,ac,b,bc]

s1=s1+1; mark=False; markquot=False; s=0; forarc=0;

A2.8. The Function

(*A2.8: Function Arccosh(p), launching only after the following sequence: 1) launching the data cell A2.1, then 2) launching the data cell A2.5 *)

Clear[inia1,inia1c,inia2,inia2c,inib1,inib1c,inib2,inib2c,bbig,m,logm,psi1,coteta,siteta,cosikv];

nolog=StringFreeQ[ToString[quatfunctiontested, StandardForm],"Log"];

If[forarc!=1||nolog||mark,

Print[" /////////////////// ERROR:////////////////\n Incorrect data input! The imposed argument is\n the wrong for the function Arccosh. The supplied function\n can not be used. Results can not be correct."];

ClearAll[f1,f1c,f2,f2c];,

If[s1==0,name=ToString[quatfunctiontested, StandardForm];lgf1=f1[a,ac,b,bc];

lgf1c=f1c[a,ac,b,bc];lgf2=f2[a,ac,b,bc];lgf2c=f2c[a,ac,b,bc];

quatfunctiontested="Arccosh(p)="<>name;

f1[a_,ac_,b_,bc_]=Simplify[lgf1,TimeConstraint->4400];

f1c[a_,ac_,b_,bc_]=Simplify[lgf1c,TimeConstraint->4400];

f2[a_,ac_,b_,bc_]=Simplify[lgf2,TimeConstraint->4400];

f2c[a_,ac_,b_,bc_]=Simplify[lgf2c,TimeConstraint->4400];]];

If[forarc!=1||nolog||mark,,

Print

["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]];

f1[a,ac,b,bc]

f2[a,ac,b,bc]

s1=s1+1; mark=False; markquot=False; s=0; forarc=0;

A2.9. The Function

(*A2.9: Function Arcsinh(p), launching only after the following sequence: 1) launching the data cell A2.4, then 2) launching the data cell A2.5 *)

Clear[inia1,inia1c,inia2,inia2c,inib1,inib1c,inib2,inib2c,bbig,m,logm,psi1,coteta,siteta,cosikv];

nolog=StringFreeQ[ToString[quatfunctiontested, StandardForm],"Log"];

If[forarc!=3||nolog||mark,

Print[" /////////////////// ERROR:////////////////\n Incorrect data input! The imposed argument is\n the wrong for the function Arcsinh. The supplied function\n can not be used. Results can not be correct."];

ClearAll[f1,f1c,f2,f2c];,

If[s1==0,name=ToString[quatfunctiontested, StandardForm];lgf1=f1[a,ac,b,bc]; lgf1c=f1c[a,ac,b,bc];lgf2=f2[a,ac,b,bc];lgf2c=f2c[a,ac,b,bc];

quatfunctiontested="Arcsinh(p)="<>name;

f1[a_,ac_,b_,bc_]=lgf1;

f1c[a_,ac_,b_,bc_]=lgf1c;

f2[a_,ac_,b_,bc_]=lgf2;

f2c[a_,ac_,b_,bc_]=lgf2c;]];

If[forarc!=3||nolog||mark,,

Print

["Constituents f1,f2 of the quaternionic function ",quatfunctiontested,":"]];

f1[a,ac,b,bc]

f2[a,ac,b,bc]

s1=s1+1; mark=False; markquot=False; s=0; forarc=0;

The programmes are adapted for the direct transfer of these programmes (copying) into empty file .nb of the computing system Wolfram Mathematica® to work with them (launch) in this system. To obtain the functions as input data for Programmes A3.1, A3.2 it is needed to launch the copied data cell of a function in question from subsections A1 and A2. After that we can launch copied Programmes A3.1, A3.2 for processing of this function.

A3.1. Testing of -holomorphy

The input data for this program are only the functions To get, for example, the expression for the system of equations (1.8) this program calculates the derivative of with respect to and then sets (the transition to 3D space) in the obtained expression for the derivative

(*Program A3.1, H - holomorphy testing*)

ClearAll[df1,df1c,df2,df2c,trdf1,sftrdf1,trdf1c,sftrdf1c,trdf2,sftrdf2,trdf2c,sftrdf2c,trmdf1da, trmdf2cdbc,dif1,trmdf2da,trmdf1cdbc,dif2,trmdf2db,dif3,trmdf2dac,trmdf1dbc,dif4, eq1,eq2,eq3,eq4];

ClearAll[a,ac,b,bc,x,y,z,u];

inif1=f1[a,ac,b,bc]/.{a->x+I*y,ac->x-I*y,b->z+I*u,bc->z-I*u};

f1s=Simplify[inif1,{_Symbol∈Reals},TimeConstraint->4400];f1sexp=Expand[f1s];ref1=Simplify[selectpart[f1sexp,True],{_Symbol∈Reals},TimeConstraint->4400];

imf1=Simplify[selectpart[f1sexp,False],{_Symbol∈Reals},TimeConstraint->4400];

inif1c=f1c[a,ac,b,bc]/.{a->x+I*y,ac->x-I*y,b->z+I*u,bc->z-I*u};

f1cs=Simplify[inif1c,{_Symbol∈Reals},TimeConstraint->4400];f1csexp=Expand[f1cs];

ref1c=Simplify[selectpart[f1csexp,True],{_Symbol∈Reals},TimeConstraint->4400];

imf1c=Simplify[selectpart[f1csexp,False],{_Symbol∈Reals},TimeConstraint->4400];

f1recoinc=True===Simplify[ref1==ref1c,TimeConstraint->2400];

nonrightf1c=True===Simplify[imf1==imf1c,TimeConstraint->2400];

If[(f1[a,ac,b,bc]===inia1[a,ac,b,bc] inib1[a,ac,b,bc]-inia2[a,ac,b,bc] inib2c[a,ac,b,bc])||mark||nonrightf1c,Print["/////////////////// ERROR:////////////////\n Incorrect data input (including also the improper function f1c). Repeat again launching the correct function in question and then the correct sequence of launching the needed main programmes."],

df1=D[f1[a,ac,b,bc],{{a,bc}}];

trdf1=df1/.{a->x,ac->x};

sftrdf1=Simplify[trdf1,TimeConstraint->4400];

ClearAll[trdf1,df1];

df1c=D[f1c[a,ac,b,bc],{bc}];

trdf1c=df1c/.{a->x,ac->x};

sftrdf1c=Simplify[trdf1c,TimeConstraint->4400];

ClearAll[trdf1c,df1c];

df2=D[f2[a,ac,b,bc],{{a,ac,b}}];

trdf2=df2/.{a->x,ac->x};

sftrdf2=Simplify[trdf2,TimeConstraint->4400];

ClearAll[trdf2,df2];

df2c=D[f2c[a,ac,b,bc],{bc}];

trdf2c=df2c/.{a->x,ac->x};

sftrdf2c=Simplify[trdf2c,TimeConstraint->4400];

ClearAll[trdf2c,df2c];

trmdf1da=PowerExpand[sftrdf1[[ 1 ]]]//Expand;

trmdf2cdbc=PowerExpand[sftrdf2c]//Expand;

dif1=Simplify[trmdf1da-trmdf2cdbc,TimeConstraint->4400];

ClearAll[trmdf2cdbc];

eq1=True===Simplify[dif1==0,TimeConstraint->4400];

If[eq1,,Print["The equation 1) is not satisfied"]];

ClearAll[dif1];

trmdf2da=PowerExpand[sftrdf2[[ 1 ]]]//Expand;

trmdf1cdbc=PowerExpand[-sftrdf1c]//Expand;

dif2=Simplify[trmdf2da-trmdf1cdbc,TimeConstraint->4400];

ClearAll[trmdf2da,trmdf1cdbc];

eq2=True===Simplify[dif2==0,TimeConstraint->4400];

ClearAll[dif2];

If[eq2,,Print["The equation 2) is not satisfied"]];

trmdf2db=PowerExpand[sftrdf2[[ 3 ]]]//Expand;

dif3=Simplify[trmdf1da-trmdf2db,TimeConstraint->4400];

ClearAll[trmdf1da,trmdf2db];

eq3=True===Simplify[dif3==0,TimeConstraint->4400];

ClearAll[dif3];

If[eq3,,Print["The equation 3) is not satisfied"]];

trmdf2dac=PowerExpand[sftrdf2[[ 2 ]]]//Expand;

trmdf1dbc=PowerExpand[-sftrdf1[[ 2 ]]]//Expand;

dif4=Simplify[trmdf2dac-trmdf1dbc,TimeConstraint->4400];

ClearAll[trmdf2dac,trmdf1dbc];

eq4=True===Simplify[dif4==0,TimeConstraint->4400];

ClearAll[dif4];

If[eq4,,Print["The equation 4) is not satisfied"]];

Print["Testing eq1: ",eq1,"// eq2: ",eq2,"// eq3: ",eq3,"// eq4: ",eq4];

If[eq1∧eq2∧eq3∧eq4,Print["General result: The quaternionic function ",quatfunctiontested,"

is H-holomorphic."],Print["General result: The quaternionic function ",quatfunctiontested,"

is not H-holomorphic."]];]

ClearAll[df1,df1c,df2,df2c,trdf1,sftrdf1,trdf1c,sftrdf1c,trdf2,sftrdf2,trdf2c,sftrdf2c,trmdf1da, trmdf2cdbc,dif1,trmdf2da,trmdf1cdbc,dif2,trmdf2db,dif3,trmdf2dac,trmdf1dbc,dif4, eq1,eq2,eq3,eq4];

Remark. When processing of non--holomorphic functions, this program will indicate those -holomorphy equations from (1.8), which is not satisfied. Such a resultat appears immediately and we can immediately abort the program to avoid further unnecessary work.

The input data for this program are only the functions The calculated quaternionic expressions are displayed in –representation. In the cases of some complicated -holomorphic functions operating of this program can take a very long time to get all planned expressions for them. However, the calculation of the representation (1.4) and polar form (3.20) takes relatively little time and the results (RESULT 1 and RESULT 2) appear very quickly, whereafter operating of this program, if needed, can be aborted.

(*Program A3.2, Calculating quaternionic expressions*)

ClearAll[f1s,f2s,f1sexp,f2sexp,ref1,imf1,ref2,imf2,ref1tr,imf1tr,ref2tr,imf2tr,iniderf1,iniderf2, derf1r4,derf2r4,derf1s,derf2s,derf1sexp,derf2sexp,rederf1,imderf1,rederf2,imderf2,redf1tr, imdf1tr,redf2tr,imdf2tr,trmf1y0sf,trmf3y0sf,trmf4y0sf,trmcurl,const1,const2,const3, curl1,curl2,curl3,curl1together,curl2together,curl3together,curl1togpowexp,curl2togpowexp, curl3togpowexp,comp1,comp2,comp3,df1dx,df2dy,df3dz,df4du,df1dxtr,df2dytr,df3dztr,df4dutr, df1dxtrsf,trmdf2dytrfullsf,df3dztrsf,df4dutrsf,df1dxtrsfpowexex,df2dytrsfpowexex, df3dztrsfpowexex,df4dutrsfpowexex,vordivfield,divfieldfullsf, divsumminusdf2dy,keydiv];

If[(f1[a,ac,b,bc]===inia1[a,ac,b,bc] inib1[a,ac,b,bc]-inia2[a,ac,b,bc] inib2c[a,ac,b,bc])||mark,Print["/////////////////// ERROR:////////////////\n Incorrect data input! Repeat again launching the function in question and then the correct sequence of launching main programmes."],selectpart[vr_,keyreorim_]:=(vrm:=vr/.Complex[0,p_]->Μ*p;revr:=Select[(vrm//Expand),FreeQ[#,Μ]&];

imvr:=(vr-revr)/I//Expand;bg1:=MatchQ[vr,d_.*Complex[0,cc_]];bg2:=MatchQ[vr,(cc_/;NumberQ[cc]&&Im[cc]==0)];bg3:=MatchQ[vr,Complex[xx_/;NumberQ[xx]& &Re[xx]!=0,yy/;NumberQ[yy]]];bg:=bg1||bg2||bg3;If[bg,revr:=Simplify[Re[vr],{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->9800]];If[bg,imvr:=Simplify[Im[vr],{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->9800]];

If[keyreorim,Return[revr],Return[imvr]]);

ClearAll[a,ac,b,bc,x,y,z,u];

inif1=f1[a,ac,b,bc]/.{a->x+I*y,ac->x-I*y,b->z+I*u,bc->z-I*u};

inif2=f2[a,ac,b,bc]/.{a->x+I*y,ac->x-I*y,b->z+I*u,bc->z-I*u};f1s=Simplify[inif1,{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->9800]; f2s=Simplify[inif2,{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->9800];f1sexp=Expand[f1s];ref1=Simplify[selectpart[f1sexp,True],{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->9800];imf1=Simplify[selectpart[f1sexp,False],{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->9800]; f2sexp=Expand[f2s];ref2=Simplify[selectpart[f2sexp,True],{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->9800];

imf2=Simplify[selectpart[f2sexp,False],{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->9800];

Print["RESULT 1: Quaternionic function: psi(p)=",quatfunctiontested,"=psi1+psi2*i+psi3*j+psi4*k, where psi1=",ref1,";//psi2=",imf1,";//psi3=",ref2,";//psi4=",imf2];

ClearAll[f1s,f2s,f1sexp,f2sexp];m:=Simplify[Sqrt[ref1^2+imf1^2+ref2^2+imf2^2],{_Symbol∈Reals},TimeConstraint->9800];

bbig:=Simplify[Cancel[imf1/y],{_Symbol∈Reals},TimeConstraint->9800];

realv:=Sqrt[y^2+z^2+u^2];tangteta:=Simplify[(bbig*realv)/ref1,{_Symbol∈Reals},TimeConstraint->9800];

Print["RESULT 2 (correct only for H -holomorphic functions) : Polar form of the function

",quatfunctiontested," is m[cos(teta)+rsin(teta)], where m=",m,"; //teta=Arctan[",tangteta,"]"];

ClearAll[m,bbig,realv,tangteta];

ref1tr=ref1/.{y->0};

imf1tr=imf1/.{y->0};

ref2tr=ref2/.{y->0};

imf2tr=imf2/.{y->0};

ClearAll[ref1,imf1,ref2,imf2];

Print["RESULT 3: Quaternionic function after transition to 3D (y=0): (psi(p)\[LeftBracketingBar]=phi1+phi2*i+phi3*j+phi4*k, where phi1=",ref1tr,";// phi2=",imf1tr,";//phi3=",ref2tr,";//phi4=",imf2tr];

ClearAll[ref1tr,imf1tr,ref2tr,imf2tr];iniderf1=D[f1[a,ac,b,bc],a]+D[f1[a,ac,b,bc],ac]; iniderf2=D[f2[a,ac,b,bc],a]+D[f2[a,ac,b,bc],ac];

ClearAll[a,ac,b,bc,x,y,z,u];

derf1r4=iniderf1/.{a->x+I*y,ac->x-I*y,b->z+I*u,bc->z-I*u};

derf2r4=iniderf2/.{a->x+I*y,ac->x-I*y,b->z+I*u,bc->z-I*u};

ClearAll[iniderf1,iniderf2];derf1s=Simplify[derf1r4,{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->59200];derf2s=Simplify[derf2r4,{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->59200];

ClearAll[derf1r4,derf2r4];

derf1sexp=Expand[derf1s];

ClearAll[derf1s];rederf1=Simplify[selectpart[derf1sexp,True],{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->59200];imderf1=Simplify[selectpart[derf1sexp,False],{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->59200];

ClearAll[derf1sexp];

derf2sexp=Expand[derf2s];ClearAll[derf2s];rederf2=Simplify[selectpart[derf2sexp,True],{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->59200];imderf2=Simplify[selectpart[derf2sexp,False],{_Symbol∈Reals,x>0,y>0,z>0,u>0},TimeConstraint->59200];

ClearAll[derf2sexp];

Print["RESULT 4: Quaternionic derivative: d1psi = d1f1+d1f2*j = d1psi1+d1psi2*i+d1psi3*j+d1psi4*k, where d1psi1=",rederf1,";// d1psi2=",imderf1,";//d1psi3=",rederf2,";//d1psi4=",imderf2];

redf1tr=rederf1/.{y->0};

imdf1tr=imderf1/.{y->0};

redf2tr=rederf2/.{y->0};

imdf2tr=imderf2/.{y->0};

Print["RESULT 5: Quaternionic field vector: F(p)=fn1+fn2*i+fn3*j+fn4*k, where fn1=d1psi1 =",rederf1,";//fn2=-d1psi2=",-imderf1,";//fn3=-d1psi3=",-rederf2,";//fn4=-d1psi4=",-imderf2];

Print["RESULT 6: 3D field vector (after y=0):(F(p)\[LeftBracketingBar]=(fn1\[LeftBracketingBar]+(fn2\[LeftBracketingBar]*i+(fn3\[LeftBracketingBar]*j+(fn4\[LeftBracketingBar]*k, where (fn1\[LeftBracketingBar]=(d1psi1\[LeftBracketingBar]=",redf1tr,";//(fn2\[LeftBracketingBar]=-(d1psi2\[LeftBracketingBar]=",-imdf1tr,";//(fn3\[LeftBracketingBar]=-(d1psi3\[LeftBracketingBar]=",-redf2tr,";//(fn4\[LeftBracketingBar]=-(d1psi4\[LeftBracketingBar]=",-imdf2tr];

trmf1y0sf=PowerExpand[redf1tr]//Expand;

trmf3y0sf=PowerExpand[-redf2tr]//Expand;

trmf4y0sf=PowerExpand[-imdf2tr]//Expand;

ClearAll[redf1tr,redf2tr,imdf2tr];

trmcurl=Curl[{trmf1y0sf,trmf3y0sf,trmf4y0sf},{x,z,u}];

ClearAll[trmf1y0sf,trmf3y0sf,trmf4y0sf];

const1=trmcurl[[ 1 ]];

curl1=Simplify[const1,TimeConstraint->59200];

ClearAll[const1];

const2=trmcurl[[ 2 ]];

curl2=Simplify[const2,TimeConstraint->59200];

ClearAll[const2];

const3=trmcurl[[ 3 ]];

curl3=Simplify[const3,TimeConstraint->59200];

ClearAll[const3];

curl1together=Together[curl1];

curl1togpowexp=PowerExpand[curl1together];

ClearAll[curl1,curl1together];

curl2together=Together[curl2];

curl2togpowexp=PowerExpand[curl2together];

ClearAll[curl2,curl2together];

curl3together=Together[curl3];

curl3togpowexp=PowerExpand[curl3together];

ClearAll[curl3,curl3together];

comp1=True===Simplify[curl1togpowexp==0,TimeConstraint->59200];

ClearAll[curl1togpowexp];comp2=True===Simplify[curl2togpowexp==0,TimeConstraint->59200];

ClearAll[curl2togpowexp];comp3=True===Simplify[curl3togpowexp==0,TimeConstraint->59200];ClearAll[curl3togpowexp];If[comp1∧comp2∧comp3,Print["RESULT 7: For quaternionic function psi(p)= ",quatfunctiontested," the vortex density curl(F(p)\[LeftBracketingBar]=0. The field (F(p)\[LeftBracketingBar] is potential."],Print["RESULT 7: For quaternionic function psi(p)= ",quatfunctiontested," the vortex density curl(F(p)\[LeftBracketingBar]!= 0. The field (F(p)\[LeftBracketingBar] is not potential."]];

Print["\n The following part of program calculates the divergence div(F(p)\[LeftBracketingBar] and tests the equality div(F(p)\[LeftBracketingBar]=(dfn2/dy\[LeftBracketingBar]. For some complicated H-holomorphic functions this procedure can take a long time and RESULT 8 long time does not appear. If you do not need it, you can abort this program and use the obtained RESULTS 1-7.\n"];

ClearAll[comp1,comp2,comp3];

df1dx=D[rederf1,x];

df2dy=D[-imderf1,y];

df3dz=D[-rederf2,z];

df4du=D[-imderf2,u];

df1dxtr=df1dx/.{y->0};

df2dytr=df2dy/.{y->0};

df3dztr=df3dz/.{y->0};

df4dutr=df4du/.{y->0};

ClearAll[df1dx,df2dy,df3dz,df4du];

trmdf2dytrfullsf=Simplify[df2dytr,TimeConstraint->59200];

df1dxtrsf=Simplify[df1dxtr,TimeConstraint->59200];

df3dztrsf=Simplify[df3dztr,TimeConstraint->59200];

df4dutrsf=Simplify[df4dutr,TimeConstraint->59200];

ClearAll[df1dxtr,df3dztr,df4dutr];

df1dxtrsfpowexex=PowerExpand[df1dxtrsf]//Expand;

ClearAll[df1dxtrsf];

df2dytrsfpowexex=PowerExpand[df2dytr]//Expand;

ClearAll[df2dytr];

df3dztrsfpowexex=PowerExpand[df3dztrsf]//Expand;

ClearAll[df3dztrsf];

df4dutrsfpowexex=PowerExpand[df4dutrsf]//Expand;

ClearAll[df4dutrsf];vordivfield=df1dxtrsfpowexex+df3dztrsfpowexex+df4dutrsfpowexex;

divfieldfullsf=Simplify[vordivfield,TimeConstraint->59200];

divsumminusdf2dy=Simplify[vordivfield-df2dytrsfpowexex,TimeConstraint->59200];ClearAll[df1dxtrsfpowexex,df3dztrsfpowexex,df4dutrsfpowexex,vordivfield]; keydiv=True===Simplify[divsumminusdf2dy==0,TimeConstraint->59200];

If[keydiv,Print["RESULT 8: For quaternionic function psi(p)= ",quatfunctiontested," the divergence div(F(p)\[LeftBracketingBar] is equal to ",divfieldfullsf," and equal to (dfn2/dy\[LeftBracketingBar]= ",trmdf2dytrfullsf,". The derivative (dfn2/dy\[LeftBracketingBar] represents the density of sources and sinks in 3D space."],Print["RESULT 8: For quaternionic function psi(p)= ",quatfunctiontested," the divergence div(F(p)\[LeftBracketingBar]is equal to ",divfieldfullsf," and not equal to (dfs2/dy\[LeftBracketingBar]=",trmdf2dytrfullsf]];]