Fallende Fakultät Rechner

📉 Grundlegende Eigenschaften

Wichtige mathematische Eigenschaften der fallenden 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: } n_{(n)} = n \times (n-1) \times \cdots \times 1 = n!\] \[\text{Gamma-Beziehung: } x_{(n)} = \frac{\Gamma(x+1)}{\Gamma(x-n+1)} \text{ für } x > n-1\]

🔄 Verbindung zur Gamma-Funktion und Permutationen

Beziehungen zu Permutationen und anderen Funktionen:

\[\text{Permutationen: } P(n,k) = \frac{n!}{(n-k)!} = n_{(k)}\] \[\text{Gamma-Darstellung: } x_{(n)} = \frac{\Gamma(x+1)}{\Gamma(x-n+1)}\] \[\text{Fakultäts-Beziehung: } x_{(n)} = \frac{x!}{(x-n)!} \text{ für ganze Zahlen } x \geq n\] \[\text{Binomialkoeffizient: } \binom{x}{n} = \frac{x_{(n)}}{n!}\]

📊 Wichtige Werte

Häufig verwendete fallende Fakultäten:

\[\text{Für } x = 7:\] \[7_{(0)} = 1\] \[7_{(1)} = 7\] \[7_{(2)} = 7 \times 6 = 42\] \[7_{(3)} = 7 \times 6 \times 5 = 210\] \[7_{(4)} = 7 \times 6 \times 5 \times 4 = 840\] \[7_{(5)} = 7 \times 6 \times 5 \times 4 \times 3 = 2520\] \[\text{Spezialfälle: } n_{(n)} = n!, \quad 0_{(n)} = 0 \text{ für } n > 0\]

📝 Beispiel 1: Platzierungen im Wettbewerb

Aufgabe: Anzahl der Möglichkeiten für die ersten 3 Plätze
Gegeben: 10 Teilnehmer in einem Wettbewerb
Berechnung:

\[\text{Anzahl Möglichkeiten für erste 3 Plätze} = 10_{(3)}\] \[10_{(3)} = 10 \times 9 \times 8 = 720\] \[\text{Alternative Notation: } P(10,3) = \frac{10!}{(10-3)!} = \frac{10!}{7!} = 720\] \[\text{Erklärung: } \text{1. Platz: 10 Möglichkeiten, 2. Platz: 9, 3. Platz: 8}\]

Interpretation: 720 verschiedene Möglichkeiten für die ersten drei Plätze

📝 Beispiel 2: Passwort-Generierung

Aufgabe: 4-stelliges Passwort aus 26 Buchstaben
Szenario: Keine Wiederholung von Buchstaben
Berechnung:

\[\text{Anzahl möglicher Passwörter} = 26_{(4)}\] \[26_{(4)} = 26 \times 25 \times 24 \times 23 = 358{.}800\] \[\text{Mit Wiederholung wären es: } 26^4 = 456{.}976\] \[\text{Verhältnis: } \frac{26_{(4)}}{26^4} = \frac{358{.}800}{456{.}976} \approx 0.785\]

Anwendung: Sicherheitsanalyse bei verschiedenen Passwort-Strategien

📝 Beispiel 3: Differenzengleichungen

Aufgabe: Vorwärtsdifferenzen in der numerischen Analysis
Gegeben: Polynom p(x) = x³
Berechnung:

\[\text{n-te Vorwärtsdifferenz: } \Delta^n p(x) = \sum_{k=0}^{n} \binom{n}{k} (-1)^{n-k} p(x+k)\] \[\text{Für } p(x) = x^3 \text{ und } n = 3:\] \[\Delta^3 x^3 = 3! = 6 \text{ (konstant)}\] \[\text{Allgemein für } p(x) = x^m: \Delta^n x^m = \begin{cases} m_{(n)} & \text{falls } n \leq m \\ 0 & \text{falls } n > m \end{cases}\]

Bedeutung: Fallende Fakultäten vereinfachen Differenzenrechnungen

💻 Code-Implementierungen

Effiziente Implementierung der fallenden Fakultät:

Python:
def falling_factorial(x, n):
  """Berechnet die fallende 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 falling_factorial_gamma(x, n):
  """Fallende Fakultät mit Gamma-Funktion"""
  if n == 0:
    return 1
  return math.gamma(x + 1) / math.gamma(x - n + 1)

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

# Permutationen
def permutations(n, k):
  """P(n,k) = n_(k)"""
  return falling_factorial(n, k)

JavaScript:
function fallingFactorial(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 fallingFactorial(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;
}

🎯 Kombinatorik mit fallenden Fakultäten

Anwendungen in der kombinatorischen Mathematik:

Python Kombinatorik-Klasse:
import math

class FallingFactorialCombinatorics:
  @staticmethod
  def falling_factorial(x, n):
    """Fallende Fakultät x_(n)"""
    if n == 0: return 1
    result = 1
    for k in range(n):
      result *= (x - k)
    return result
  
  @staticmethod
  def permutations_without_repetition(n, k):
    """Permutationen P(n,k) = n_(k)"""
    return FallingFactorialCombinatorics.falling_factorial(n, k)
  
  @staticmethod
  def binomial_coefficient(n, k):
    """Binomialkoeffizient C(n,k) = n_(k)/k!"""
    if k > n: return 0
    return FallingFactorialCombinatorics.falling_factorial(n, k) // math.factorial(k)
  
  @staticmethod
  def stirling_first_kind(n, k):
    """Stirling-Zahlen erster Art (unsigned)"""
    # Vereinfachte Implementierung für kleine Werte
    if n == 0 and k == 0: return 1
    if n == 0 or k == 0: return 0
    if k > n: return 0
    
    # Rekursionsformel: s(n,k) = (n-1)*s(n-1,k) + s(n-1,k-1)
    # Hier vereinfacht für Demonstration
    return 1 # Placeholder
  
  @staticmethod
  def forward_difference(polynomial_coeffs, x, n):
    """Vorwärtsdifferenzen für Polynome"""
    # Für Polynom p(x) = sum(coeffs[i] * x^i)
    result = 0
    for i, coeff in enumerate(polynomial_coeffs):
      if i >= n:
        # Delta^n x^i = i_(n) wenn i >= n, sonst 0
        falling_fact = FallingFactorialCombinatorics.falling_factorial(i, n)
        result += coeff * falling_fact
    return result

# Beispiele
comb = FallingFactorialCombinatorics()
print(f"7_(3) = {comb.falling_factorial(7, 3)}") # 210
print(f"P(10,4) = {comb.permutations_without_repetition(10, 4)}") # 5040
print(f"C(7,3) = {comb.binomial_coefficient(7, 3)}") # 35
print(f"3. Differenz von x^3: {comb.forward_difference([0, 0, 0, 1], 0, 3)}") # 6

🎯 Differenzengleichungen

Anwendung in der numerischen Analysis:

Python Differenzenrechnung:
import numpy as np

class DifferenceCalculus:
  @staticmethod
  def falling_factorial(x, n):
    if n == 0: return 1
    result = 1
    for k in range(n):
      result *= (x - k)
    return result
  
  @staticmethod
  def forward_difference_table(values, max_order=None):
    """Erstellt eine Vorwärtsdifferenzen-Tabelle"""
    n = len(values)
    if max_order is None: max_order = n - 1
    
    table = [values[:] # 0-te Differenz
    current = values[:]
    
    for order in range(1, max_order + 1):
      next_diff = []
      for i in range(len(current) - 1):
        next_diff.append(current[i + 1] - current[i])
      table.append(next_diff)
      current = next_diff
      if len(current) == 0: break
    
    return table
  
  @staticmethod
  def newton_forward_interpolation(x_values, y_values, x):
    """Newton'sche Vorwärtsinterpolation"""
    n = len(x_values)
    h = x_values[1] - x_values[0] # Annahme: äquidistante Punkte
    s = (x - x_values[0]) / h
    
    # Differenzen-Tabelle
    diff_table = DifferenceCalculus.forward_difference_table(y_values)
    
    # Newton-Formel mit fallenden Fakultäten
    result = diff_table[0][0] # f(x_0)
    for i in range(1, min(n, len(diff_table))):
      if len(diff_table[i]) > 0:
        # s_(i) / i! * Delta^i f(x_0)
        coeff = DifferenceCalculus.falling_factorial(s, i) / math.factorial(i)
        result += coeff * diff_table[i][0]
    
    return result

# Beispiel: Interpolation
calc = DifferenceCalculus()
x_vals = [0, 1, 2, 3, 4]
y_vals = [1, 8, 27, 64, 125] # x^3 + 1

print("Differenzen-Tabelle:")
table = calc.forward_difference_table(y_vals)
for i, row in enumerate(table):
  print(f"Delta^{i}: {row}")

# Interpolation bei x = 2.5
interpolated = calc.newton_forward_interpolation(x_vals, y_vals, 2.5)
print(f"Interpoliert bei x=2.5: {interpolated:.2f}")
print(f"Exakt (2.5^3 + 1): {2.5**3 + 1:.2f}")