share/gamma_simp/README.md

   1 # Gamma function simplification
   2
   3 Maxima code for simplifying expressions that involve gamma and factorial functions.
   4
   5 ## Installation
   6
   7 To use the `gamma_simp` package, copy the file `gamma_simp.mac` to a folder that Maxima can find. To load the package, enter `load(gamma_simp)` at the Maxima command line.
   8
   9 To view the paths that Maxima searches to find a *.mac file, enter
  10 `file_search_maxima;` at a Maxima command line.
  11
  12 ## Usage
  13
  14 There are two user level functions in the package. They are `gamma_simp` and `factorial_simp.` Both of these functions take a single Maxima expression as input and both return a simplification of the input.
  15
  16 The function `gamma_simp` matches subexpressions of the input to various gamma function identities and replaces the match with a simplification. The simplification process generally only converts gamma functions to gamma functions (not, for example,
  17 into beta functions), but depending on the value of the option variable `pochhammer_max_index,` the output can involve a pochhammer symbol.
  18
  19 The function `factorial_simp` works similarly.
  20
  21 To simplify all gamma-like functions, including binomial coefficients, pochhammer symbols, beta functions, and factorials, apply the function `makegamma` to the input of `gamma_simp.`
  22
  23 _Option variables:_ The option variables `radsubstflag,` `pochhammer_max_index,` and `ratfac` sometimes alter the results of `gamma_simp` and `factorial_simp.`
  24
  25 _Related functions:_ `factcomb,` `minfactorial,` `makegamma,` and `makefactorial.`
  26
  27 ## Examples
  28
  29 The last example shows the use of `makegamma` to pre-process the input.
  30 ~~~
  31 (%i1)   load(gamma_simp)$
  32
  33 (%i2)   gamma_simp(gamma(z)*gamma(1-z));
  34 (%o2)   %pi/sin(%pi*z)
  35
  36 (%i3)   gamma_simp(gamma(1/4)*gamma(3/4));
  37 (%o3)   sqrt(2)*%pi
  38
  39 (%i4)   gamma_simp(gamma(z)*gamma(z + 1/2));
  40 (%o4)   sqrt(%pi)*2^(1-2*z)*gamma(2*z)
  41
  42 (%i5)   gamma_simp(x*gamma(x)+gamma(x+3)/(x+2));
  43 (%o5)   x*gamma(x+1)+2*gamma(x+1)
  44
  45 (%i6)   gamma_simp(makegamma((k - n) *binomial(n,k)  + n * binomial(n-1,k)));
  46 (%o6)   0
  47 ~~~
  48
  49 ## Details
  50
  51 The functions `gamma_simp` and `factorial_simp` make a good effort to simplify every vanishing expression to zero. But if an expression doesn't simplify to zero, it does _not_ mean that the expression is non vanishing.
  52
  53 Additionally, `gamma_simp` does not always simplify semantically identical expressions to syntactically identical expressions. That is, `gamma_simp` does not produce a canonical form. An example:
  54
  55 ~~~
  56 (%i1)   load(gamma_simp)$
  57
  58 (%i2)   declare(n,integer)$
  59
  60 (%i3)   xx : makegamma(pochhammer(a-n,n));
  61 (%o3)   gamma(a)/gamma(a-n)
  62
  63 (%i4)   yy : makegamma(pochhammer(1-a,n)*(-1)^n);
  64 (%o4)   ((-1)^n*gamma(n-a+1))/gamma(1-a)
  65
  66 (%i5)   gamma_simp(xx) = gamma_simp(yy);
  67 (%o5)   gamma(a)/gamma(a-n)=((-1)^n*gamma(n-a+1))/gamma(1-a)
  68
  69 (%i6)   trigexpand(gamma_simp(xx-yy));
  70 (%o6)   0
  71 ~~~
  72
  73 Although the expressions xx and yy are semantically the same (see %o6), `gamma_simp` does not simplify them to identical expressions.
  74
  75
  76 ## Identities
  77
  78 The function `gamma_simp` matches subexpressions of the input to the left hand side of each of the following identities and replaces them by the right side:
  79
  80 $$
  81 \dfrac{\Gamma\left(z+1\right)}{z} = \Gamma\left(z\right), \quad z \in \mathbf{C_\neq 0}
  82 $$
  83
  84 $$
  85 \Gamma\left(z\right)\Gamma\left(1-z\right)= \dfrac{\uppi}{\sin\left(\uppi z\right)},  \quad z \in \mathbf{C} \setminus \mathbf{Z},
  86 $$
  87
  88 $$
  89 \prod_{k=0}^{n-1}\Gamma\left (z+\frac{k}{n}\right) = (2\uppi)^{(n-1)/2}n^{1/2-nz}  \Gamma \left(n z \right)
  90 $$
  91
  92 $$
  93 \Gamma\left(\dfrac{1}{2}+\mathrm{i}y\right)\Gamma\left(\dfrac{1}{2}-\mathrm{i}%
  94 y\right)=\dfrac{\uppi}{\cosh\left(\uppi y\right)},
  95 $$
  96
  97 $$
  98 \Gamma\left(\mathrm{i} y\right) \Gamma\left(-\mathrm{i} y\right)  =
  99 \frac{\uppi}{y\sinh\left(\uppi y\right)}, \quad y \in \mathbf{R}_{\neq 0}
 100 $$
 101
 102 See: http://dlmf.nist.gov/5.5.E1, http://dlmf.nist.gov/5.5.E3, http://dlmf.nist.gov/5.4.E4, and http://dlmf.nist.gov/5.4.E3
 103
 104 ## Implementation
 105
 106 The package is written in the Maxima language.
 107
 108 The function `gamma_simp` matches subexpressions of the input to various gamma function identities. The function `gamma_simp` uses `radsubst` to match the subexpressions, it does _not_ explicitly use Maxima's pattern matcher.
 109
 110 The function `factorial_simp` converts all factorials to gamma form. It then dispatches `gamma_simp` and converts back to factorial form. Any gamma functions in
 111 the input are protected from participating in the gamma function simplification process.
 112
 113 The only user level functions in the package are `gamma_simp` and `factorial_simp.`
 114 The remaining functions in the package are _not_ intended to be user level functions.
 115
 116
 117 ## Testing
 118
 119 To run the test suite for the package `gamma_simp,` enter `batch(rtest_gamma_simp, 'test)` at the Maxima prompt. To do this, you will need to copy the file `rtest_gamma_simp` to a folder that Maxima can find.
 120
 121
 122 ## Thanks
 123
 124 Part of the test file (`rtest_gamma_simp`) is adapted from the [SymPy package](https://www.sympy.org/en/index.html) for simplification of gamma functions. I thank the SymPy developers for making this resource available.
 125
 126 Additionally, I thank readers of the Maxima list, including Oscar Benjamin, Stavros Macrakis, Ray Rogers, and Raymond Toy, for suggestions and encouragement. Of course, all bugs are mine.
 127
 128 _Reference:_ https://github.com/sympy/sympy/blob/master/sympy/simplify/tests/test_gammasimp.py