convert/function_rules  convert special functions applying contiguity rules

Calling Sequence


convert(expr, function, "rule1", "rule2", ...)


Parameters


expr



Maple expression, equation, or a set or list of them

function



name of the function to which the contiguity rule(s) are applied

"rule"



Maple string indicating the rule, for example, "raise a"





Description


•

convert/function_rules converts the special functions in an expression applying to it contiguity rules, that is, rules which mix, raise or lower by one, or normalize each of the parameters entering a special function. For example,

 (1) 
>

(1) = convert((1), HermiteH, "raise a");

 (2) 

A typical call to convert to apply these contiguity conversion rules may include many rules at once, in which case the rules are applied in sequence, as given (see the second last example).

•

The special functions implemented in Maple typically depend on one variable  say  and zero parameters  for example, the Airy functions  up to one variable and three parameters  for example, the JacobiP function. The convention followed to indicate the parameter with respect to which the contiguity rule will be applied is: use to respectively refer to the first, second and third parameters. The rules known by the system are:

"raise a",

"lower a",

"normalize a",

"raise b",

"lower b",

"normalize b",

"raise c",

"lower c",

"normalize c",

"mix a and b",

"1F1 to 0F1",

"0F1 to 1F1"




It is then possible to raise, lower, or normalize the first, second or third parameter in an independent manner. In addition, it is possible to "mix" the first and second parameters, where mixing means applying a contiguity relation where both the first and second parameters change and the new parameters are a function of the original ones.


In addition to these rules, the following rules with application restricted to the hypergeometric function are available.

"quadratic 1",

"quadratic 2",

"quadratic 3"

"quadratic 4",

"quadratic 5",

"quadratic 6"

"2a2b",

"raise 1/2",

"lower 1/2"



•

Regarding the rule relating 0F1 to 1F1, the 0F1(;gamma;z) hypergeometric function  in Maple represented by hypergeom([],[gamma],z)  can always be rewritten as 1F1(alpha;beta;z)) for some alpha and beta, and these resulting 1F1 functions, which are not the most general ones, can be converted back to the 0F1 form. To perform those conversions, use the rules "0F1 to 1F1", "1F1 to 0F1" respectively, for example, as in convert(expr, hypergeom, "0F1 to 1F1"). For these two rules, which relate Kummer, Cylindrical and Whittaker, all 1F1 functions, to the Bessel related ones, all 0F1, due to the frequency with which the rule is applied, a special shortcut is also provided via convert(expr, `0F1 to 1F1`) and ditto for `1F1 to 0F1`.

•

When normalizing a parameter  for example, using the option "normalize a"  if the parameter value is positive and greater than one the parameter will be lowered as close as possible to one; if its value is negative and lower than 1, it will be raised as close as possible to 1. When the parameter is an algebraic expression involving symbols, the approach described will be applied to the rational numeric part of it  see the examples below. This normalization scheme is convenient in varied situations, including zero recognition.

•

Regarding the contiguity rules for the pFq hypergeometric function, they are implemented only for 1F1 and 2F1 and the convention is as follows. For the confluent hypergeometric function, that is 1F1(alpha; beta; z) , in Maple implemented as hypergeom([alpha],[beta],z), the rule "raise a" will raise by one the single parameter found in the first list (here alpha) while the rule "raise b" will raise by one the single parameter found in the second list (here beta).


For the Gauss hypergeometric function, that is 2F1(alpha, beta; gamma; z), in Maple implemented as hypergeom([alpha,beta],[gamma],z), the rule "raise a" will raise by one the first parameter in the first list (here alpha), "raise b" will raise by one the second parameter of the first list (here beta) and "raise c" will raise by one the first parameter in the second list (here gamma). The idea is to think first, second, third the same way you read the parameters in the usual mathematical notation 2F1(alpha, beta; gamma; z).



Examples


Consider the 1F1 confluent hypergeometric function and the contiguity rule for raising by one the first parameter
>


 (3) 
>


 (4) 
Here is a concrete example
>


 (5) 
>


 (6) 
The contiguity rule "mixing" the indices is
>


 (7) 
Applying it to our original appears rewritten as
>


 (8) 
The contiguity rule for lowering by one the second parameter is
>


 (9) 
Applying it to our original appears now as
>


 (10) 
Applying recursively the rules for the raising and lowering the first and second parameters in order to make them as close as possible to one you normalize to
>


 (11) 
This expression is equal to the original
>


 (12) 
The given actually admits a 0F1 representation:
>


 (13) 
from which a Bessel related form is possible, in this case  in turn  automatically simplified to trigonometric functions:
>


 (14) 
Consider the associated Legendre function
>


 (15) 
The first parameter is raised using the rule
>


 (16) 
The rule for raising the second parameter involves radicals in a particular way, related to the way these functions are defined in Maple
>


 (17) 
The Maple definition for the associated Legendre functions is in terms of their hypergeometric representation:
>


 (18) 
>


 (19) 
The application of "rule conversions" can be requested with many rules at once and performed in any desired specific order; for instance, consider the following expression
>


 (20) 
By applying rules for normalizing the first and second indices of all Kummer functions and then mixing these two parameters you obtain varied mathematically equivalent representations for the same expression
>


 (21) 
>


 (22) 
A further manipulation actually shows the expression is equal to zero
>


 (23) 
>


 (24) 
Due to the importance of the 2F1 hypergeometric function, a special set of conversion rules for it is available. Each of these rules is valid under certain conditions on the 2F1 parameters. The conversion happens only when the condition is satisfied. For arbitrary values of the parameters, these conversions can also performed using assuming.
>


 (25) 
>


 (26) 
To see "which assumptions" are required for each rule as well as all the rules available for the 2F1 function use
>


 (27) 

