Steigende Fakultät Rechner

📈 Grundlegende Eigenschaften

Wichtige mathematische Eigenschaften der steigenden Fakultät:

\[\text{Definition: } x^{(n)} = \prod_{k=0}^{n-1} (x + k) = x \times (x+1) \times \cdots \times (x+n-1)\] \[\text{Rekursion: } x^{(n)} = x \times (x+1)^{(n-1)} \text{ für } n \geq 1\] \[\text{Basis: } x^{(0)} = 1 \text{ (per Definition)}\] \[\text{Spezialfall: } 1^{(n)} = 1 \times 2 \times 3 \times \cdots \times n = n!\] \[\text{Gamma-Beziehung: } x^{(n)} = \frac{\Gamma(x+n)}{\Gamma(x)} \text{ für } x > 0\]

🔄 Verbindung zur Gamma-Funktion

Erweiterung auf reelle und komplexe Zahlen:

\[\text{Gamma-Darstellung: } x^{(n)} = \frac{\Gamma(x+n)}{\Gamma(x)}\] \[\text{Für natürliche Zahlen: } n^{(k)} = \frac{(n+k-1)!}{(n-1)!}\] \[\text{Binomialkoeffizient: } \binom{x+n-1}{n} = \frac{x^{(n)}}{n!}\] \[\text{Beta-Funktion: } \text{B}(x,n) = \frac{\Gamma(x)\Gamma(n)}{\Gamma(x+n)} = \frac{1}{x^{(n)}} \frac{\Gamma(x)\Gamma(n+1)}{\Gamma(x+n+1)}\]

📊 Wichtige Werte

Häufig verwendete steigende Fakultäten:

\[\text{Für } x = 5:\] \[5^{(0)} = 1\] \[5^{(1)} = 5\] \[5^{(2)} = 5 \times 6 = 30\] \[5^{(3)} = 5 \times 6 \times 7 = 210\] \[5^{(4)} = 5 \times 6 \times 7 \times 8 = 1680\] \[\text{Spezialfälle: } 1^{(n)} = n!, \quad 0^{(n)} = 0 \text{ für } n > 0\]

📝 Beispiel 1: Hypergeometrische Verteilung

Aufgabe: Anzahl der Wege, k Objekte aus n zu wählen
Gegeben: Hypergeometrische Funktion ₂F₁
Berechnung:

\[\text{Hypergeometrische Funktion: } {}_2F_1(a,b;c;z) = \sum_{n=0}^{\infty} \frac{a^{(n)} b^{(n)}}{c^{(n)}} \frac{z^n}{n!}\] \[\text{Für } a=2, b=3, c=5, n=3:\] \[\frac{a^{(3)} b^{(3)}}{c^{(3)}} = \frac{2^{(3)} \times 3^{(3)}}{5^{(3)}}\] \[= \frac{(2 \times 3 \times 4) \times (3 \times 4 \times 5)}{5 \times 6 \times 7} = \frac{24 \times 60}{210} = \frac{1440}{210} = \frac{48}{7}\]

Interpretation: Koeffizienten in hypergeometrischen Reihen

📝 Beispiel 2: Permutationen mit Wiederholung

Aufgabe: Anzahl n-Tupel aus k verschiedenen Elementen
Szenario: k verschiedene Objekte, n Positionen mit Wiederholung
Berechnung:

\[\text{Variationen mit Wiederholung: } V_k^{(n)} = k^n\] \[\text{Variationen ohne Wiederholung: } V_k^n = \frac{k!}{(k-n)!} = k^{(n)}\] \[\text{Für } k=5, n=3: V_5^3 = 5^{(3)} = 5 \times 6 \times 7 = 210\] \[\text{Mit Wiederholung: } V_5^{(3)} = 5^3 = 125\]

Anwendung: Kombinatorische Zählprobleme

📝 Beispiel 3: Binomialkoeffizienten

Aufgabe: Verallgemeinerte Binomialkoeffizienten
Gegeben: Nicht-ganzzahlige Exponenten
Berechnung:

\[\text{Verallgemeinerter Binomialkoeffizient: } \binom{x}{n} = \frac{x^{(n)}}{n!}\] \[\text{Für } x = -\frac{1}{2}, n = 3:\] \[\binom{-1/2}{3} = \frac{(-1/2)^{(3)}}{3!} = \frac{(-1/2) \times (1/2) \times (3/2)}{6}\] \[= \frac{-3/8}{6} = -\frac{1}{16}\] \[\text{Binomialreihe: } (1+x)^r = \sum_{k=0}^{\infty} \binom{r}{k} x^k\]

Bedeutung: Verallgemeinerung auf reelle Exponenten

💻 Code-Implementierungen

Effiziente Implementierung der steigenden Fakultät:

Python:
def rising_factorial(x, n):
  """Berechnet die steigende Fakultät x^(n)"""
  if n == 0:
    return 1
  if n < 0:
    raise ValueError("n muss >= 0 sein")
  
  result = 1
  for k in range(n):
    result *= (x + k)
  return result

# Mit Gamma-Funktion (für reelle x)
import math
def rising_factorial_gamma(x, n):
  """Steigende Fakultät mit Gamma-Funktion"""
  if n == 0:
    return 1
  return math.gamma(x + n) / math.gamma(x)

# Rekursive Version
def rising_factorial_recursive(x, n):
  if n == 0:
    return 1
  return x * rising_factorial_recursive(x + 1, n - 1)

JavaScript:
function risingFactorial(x, n) {
  if (n === 0) return 1;
  if (n < 0) throw new Error("n muss >= 0 sein");
  
  let result = 1;
  for (let k = 0; k < n; k++) {
    result *= (x + k);
  }
  return result;
}

C++:
#include <iostream>
double risingFactorial(double x, int n) {
  if (n == 0) return 1.0;
  if (n < 0) throw std::invalid_argument("n must be >= 0");
  
  double result = 1.0;
  for (int k = 0; k < n; ++k) {
    result *= (x + k);
  }
  return result;
}

🎯 Hypergeometrische Funktionen

Anwendung in speziellen Funktionen:

Python Hypergeometrische Funktionen:
import math
from scipy.special import hyp2f1

class HypergeometricFunctions:
  @staticmethod
  def rising_factorial(x, n):
    """Steigende Fakultät"""
    if n == 0: return 1
    result = 1
    for k in range(n):
      result *= (x + k)
    return result
  
  @staticmethod
  def pochhammer_coefficient(a, b, c, n):
    """Pochhammer-Koeffizient für hypergeometrische Reihen"""
    a_n = HypergeometricFunctions.rising_factorial(a, n)
    b_n = HypergeometricFunctions.rising_factorial(b, n)
    c_n = HypergeometricFunctions.rising_factorial(c, n)
    return (a_n * b_n) / (c_n * math.factorial(n))
  
  @staticmethod
  def binomial_coefficient_general(x, n):
    """Verallgemeinerter Binomialkoeffizient"""
    if n == 0: return 1
    return HypergeometricFunctions.rising_factorial(x - n + 1, n) / math.factorial(n)
  
  @staticmethod
  def hypergeometric_term(a, b, c, x, n):
    """n-ter Term der hypergeometrischen Reihe 2F1"""
    coeff = HypergeometricFunctions.pochhammer_coefficient(a, b, c, n)
    return coeff * (x ** n)

# Beispiele
hyp = HypergeometricFunctions()
print(f"5^(3) = {hyp.rising_factorial(5, 3)}") # 210
print(f"Pochhammer(2,3,5,4) = {hyp.pochhammer_coefficient(2, 3, 5, 4):.4f}")
print(f"Binomial(-1/2, 3) = {hyp.binomial_coefficient_general(-0.5, 3):.4f}")

🎯 q-Pochhammer-Verallgemeinerung

Quantenanaloga und q-Deformationen:

Python q-Pochhammer-Symbol:
def q_pochhammer(a, q, n):
  """q-Pochhammer-Symbol (a;q)_n"""
  if n == 0:
    return 1
  if abs(q) >= 1 and n < 0:
    raise ValueError("Konvergenz erfordert |q| < 1 für n < 0")
  
  result = 1
  for k in range(n):
    result *= (1 - a * (q ** k))
  return result

def q_factorial(n, q):
  """q-Fakultät [n]_q!"""
  if n == 0:
    return 1
  result = 1
  for k in range(1, n + 1):
    result *= (1 - q**k) / (1 - q)
  return result

def q_binomial(n, k, q):
  """q-Binomialkoeffizient"""
  if k == 0 or k == n:
    return 1
  if k > n:
    return 0
  
  numerator = q_factorial(n, q)
  denominator = q_factorial(k, q) * q_factorial(n - k, q)
  return numerator / denominator

# Grenzfall q -> 1 ergibt klassische Funktionen
def classical_limit_test(a, n, q_values):
  """Test des klassischen Grenzfalls q -> 1"""
  classical = rising_factorial(a, n)
  print(f"Klassisch: {a}^({n}) = {classical}")
  
  for q in q_values:
    # Für q -> 1: (1-a*q^k) / (1-q) -> a + k
    q_result = 1
    for k in range(n):
      q_result *= (1 - a * (q ** k)) / (1 - q) if q != 1 else (a + k)
    print(f"q = {q}: Näherung = {q_result:.6f}")

# Test
classical_limit_test(5, 3, [0.9, 0.99, 0.999, 1.0])