Spaces:
Runtime error
Runtime error
Download app.py from MatDyskretna/MatD: direct link, hf CLI and curl.
- Browser
- Download file 43.1 kB
-
https://huggingface.co/spaces/MatDyskretna/MatD/resolve/main/app.py
- Command line
-
hf download hf://spaces/MatDyskretna/MatD/app.py
-
curl -L -o app.py https://huggingface.co/spaces/MatDyskretna/MatD/resolve/main/app.py
43.1 kB
import json, gradio as gr
from rapidfuzz import fuzz, process
import sympy as sp
import re
# KLUCZOWA ZMIANA: Globalny symbol n używany wszędzie
N_SYMBOL = sp.Symbol("n", integer=True, positive=True)
# --- Wczytaj bazę wiedzy ---
DATA = json.load(open("knowledge.json", "r", encoding="utf-8"))
def pretty_factorial(expr):
"""Zamienia gamma(x) → (x-1)! w dowolnym kontekście."""
expr_str = str(expr)
# regex dopasowujący np. gamma(n), gamma(n+1), gamma(k-1)
pattern = r"gamma\(([^)]+)\)"
def repl(match):
inner = match.group(1).strip()
return f"({inner}-1)!"
expr_str = re.sub(pattern, repl, expr_str)
return expr_str
def gamma_to_factorial(expr):
"""
Zamienia gamma(n+1) na factorial(n) w wyrażeniu SymPy.
"""
import sympy as sp
if not isinstance(expr, sp.Expr):
return expr
# Zamień gamma(n+1) -> factorial(n)
expr = expr.rewrite(sp.factorial)
return expr
def aggressive_simplify(expr):
"""
Agresywnie upraszcza wyrażenie sympy, w szczególności potęgi.
"""
import sympy as sp
if not isinstance(expr, sp.Expr):
return expr
# Zamień wszystkie symbole 'n' na nasz globalny N_SYMBOL
expr = expr.subs(sp.Symbol('n'), N_SYMBOL)
# KROK 1: Podstawowe uproszczenie
expr = sp.simplify(expr)
# KROK 2: Uprość potęgi (np. 2^(n-n) -> 2^0 -> 1)
expr = sp.powsimp(expr, deep=True, combine='all', force=True)
# KROK 3: Rozwiń i znów uprość
expr = sp.expand(expr)
expr = sp.simplify(expr)
# KROK 4: Usuń wspólne czynniki
expr = sp.cancel(expr)
# KROK 5: Uprość licznik i mianownik osobno
num, den = sp.fraction(expr)
num = sp.simplify(sp.powsimp(num, deep=True, combine='all'))
den = sp.simplify(sp.powsimp(den, deep=True, combine='all'))
# KROK 6: Zwróć jako ułamek
result = sp.simplify(num / den)
# KROK 7: Jeszcze raz powsimp na wyniku
result = sp.powsimp(result, deep=True, combine='all')
return result
def to_latex_display_chat(obj):
"""
Konwertuje obiekt (sympy.Expr lub string) do ładnego LaTeX-a.
Strategia:
- jeśli to sympy.Expr -> sp.latex(expr)
- jeśli to string -> spróbuj sympify -> sp.latex(expr)
- fallback: dopracowany regex: factorial(...) -> ( ... )! i ** -> ^{...}
Zwraca gotowy fragment LaTeX (bez dolarów).
"""
import sympy as sp
# Jeśli to już sympy.Expr — bezpośrednio LaTeX (SymPy dobrze obsługuje potęgi i silnie)
try:
if isinstance(obj, sp.Expr):
obj = aggressive_simplify(obj)
#latex_str = sp.latex(obj)
# POPRAWKA: Konwertuj gamma(n+1) -> n! w LaTeX
#latex_str = re.sub(r'\\Gamma\s*\(\s*([^)]+)\s*\+\s*1\s*\)', r'(\1)!', latex_str)
#latex_str = re.sub(r'\\Gamma\s*\(\s*n\s*\+\s*1\s*\)', r'n!', latex_str)
#return latex_str
#return sp.latex(obj)
# POPRAWKA: Konwertuj gamma na factorial PRZED generowaniem LaTeX
obj = gamma_to_factorial(obj)
return sp.latex(obj)
except Exception:
# w środowisku, gdzie sp nie jest poprawnie zainicjalizowane, przejdziemy dalej
pass
s = str(obj)
# 1) Spróbuj sparsować string do SymPy i wygenerować LaTeX
try:
expr = sp.sympify(s)
# POPRAWKA: Konwertuj gamma na factorial PRZED generowaniem LaTeX
expr = gamma_to_factorial(expr)
return sp.latex(expr)
except Exception:
# nie udało się sympify — idziemy do fallbacku regexowego
pass
# 2) Fallback regexowy (bezpieczniejsze transformacje niż wcześniej)
# Zamiana "factorial(x)" lub "gamma(x+1)" na (x)! (obsługa zagnieżdżonych nawiasów ograniczona)
# Najpierw ujednolicenie: zamień gamma(...) na factorial(...) jeśli przypadnie (gamma(k+1) -> factorial(k+1))
s = re.sub(r'gamma\(\s*([^)]+)\s*\)', r'factorial(\1)', s)
# Zamiana factorial(...) -> ( ... )!
# Dopasowujemy balanced parentheses w prostszy sposób: najpierw najprostsze przypadki
# (dla złożonych zagnieżdżeń sympify powinien już zadziałać wcześniej)
s = re.sub(r'factorial\(\s*([^\(\)]+)\s*\)', r'(\1)!', s)
# Potęgi: zamień ** na ^{...} tam gdzie wykładnik jest złożony
# Obsługa zagnieżdżonych i złożonych wykładników — stosujemy iteracyjne podejście
def repl_power(match):
base = match.group(1)
exponent = match.group(2)
# usuń zewnętrzne nawiasy, jeśli całe wyrażenie w nawiasach
if exponent.startswith('(') and exponent.endswith(')'):
# sprawdź, czy nawiasy są dopasowane do końca
depth = 0
for i, ch in enumerate(exponent):
if ch == '(':
depth += 1
elif ch == ')':
depth -= 1
if depth == 0 and i < len(exponent) - 1:
break
else:
# nawiasy dopasowane -> usuń
exponent = exponent[1:-1]
# jeśli pojedynczy znak (litera/liczba) — bez klamerek
if len(exponent) == 1 and exponent.isalnum():
return f"{base}^{exponent}"
return f"{base}^{{{exponent}}}"
# pattern: NONSPACE ** ( (...) lub ciąg wyrazowy/wyrażenie bez spacji do operatora )
power_pattern = r'(\S+?)\*\*(\([^\)]+\)|[^\s\+\-\*\/\)]+)'
prev = None
while prev != s:
prev = s
s = re.sub(power_pattern, repl_power, s)
# Zamień mnożenie * w prostych miejscach na \cdot (opcjonalne — lepiej czytelne w LaTeX)
# Uwaga: nie zmieniamy wszystkich '*' (np. w nazwach funkcji), lecz te otoczone liczbami/symbolami
s = re.sub(r'(?<=\w)\s*\*\s*(?=\w|\()', r' \\cdot ', s)
# Drobne porządki: usuń podwójne spacje
s = re.sub(r'\s{2,}', ' ', s).strip()
return s
def convert_negative_powers_to_fractions(expr):
"""
Konwertuje wyrażenia z ujemnymi wykładnikami (a^(-n)) na ułamki (1/a^n).
"""
import sympy as sp
# Użyj powsimp z opcją force=True, aby uprościć potęgi
expr = sp.powsimp(expr, force=True)
# Podziel wyrażenie na licznik i mianownik
num, den = sp.fraction(expr)
# Zwróć jako ułamek
return sp.simplify(num / den)
def compute_Sn_Claude_hard2a(a_0, a_1, a_n, b_1, b_n, verbose=True):
"""
Oblicza S_n = a_0 * Π_{i=1}^{n-1} a_i / Π_{i=1}^{n} b_i.
Uwzględnia przypadki prowadzące do silni i teleskopowe skracanie się wyrazów.
"""
import sympy as sp
if verbose:
print("Compute S_n HARD 2a:", a_0, a_1, a_n, b_1, b_n)
# Konwersje na sympy
a_n_sym = sp.sympify(a_n) if not isinstance(a_n, sp.Expr) else a_n
b_n_sym = sp.sympify(b_n) if not isinstance(b_n, sp.Expr) else b_n
a0_sym = sp.sympify(a_0) if not isinstance(a_0, sp.Expr) else a_0
a1_sym = sp.sympify(a_1) if not isinstance(a_1, sp.Expr) else a_1
b1_sym = sp.sympify(b_1) if not isinstance(b_1, sp.Expr) else b_1
# Zamień wszystkie symbole 'n' na N_SYMBOL
a_n_sym = a_n_sym.subs(sp.Symbol('n'), N_SYMBOL)
b_n_sym = b_n_sym.subs(sp.Symbol('n'), N_SYMBOL)
n = N_SYMBOL # Użyj globalnego symbolu
# Symbol do iteracji (musi być inny niż n)
i = sp.Symbol("i", integer=True, positive=True)
if verbose:
print(f"a_n_sym: {a_n_sym}, b_n_sym: {b_n_sym}")
print(f"Używany symbol n: {n}, id: {id(n)}")
print("--- WYKRYWANIE PRZYPADKU SPECJALNEGO HARD 2a---")
# Przypadek specjalny 1: a_n = n oraz b_n = 1 => S_n = a_0 * (n-1)!
cond_an = sp.simplify(a_n_sym - n)
cond_bn = sp.simplify(b_n_sym - 1)
if verbose:
print(f"cond_an: {cond_an}, is_zero: {cond_an.is_zero}")
print(f"cond_bn: {cond_bn}, is_zero: {cond_bn.is_zero}")
is_special_case_1 = (cond_an.is_zero and cond_bn.is_zero)
if is_special_case_1:
if verbose:
print(">>> Wykryto przypadek S_n = a_0*(n-1)! <<<")
S_n_expr = sp.simplify(a0_sym * sp.factorial(n - 1))
else:
# Przypadek specjalny 2: a_n = 1 oraz b_n = n => S_n = a_0 / n!
cond_an_2 = sp.simplify(a_n_sym - 1)
cond_bn_2 = sp.simplify(b_n_sym - n)
is_special_case_2 = (cond_an_2.is_zero and cond_bn_2.is_zero)
if is_special_case_2:
if verbose:
print(">>> Wykryto przypadek S_n = a_0/n! <<<")
S_n_expr = sp.simplify(a0_sym / sp.factorial(n))
else:
# Przypadek specjalny 3: b_n = n²/(n-1)² (teleskopowe skracanie)
# Testuj zarówno zwartą formę jak i rozwiniętą: n²/(n²-2n+1)
b_n_expanded = sp.expand(b_n_sym * (n-1)**2)
is_telescopic_square = sp.simplify(b_n_expanded - n**2).is_zero
if is_telescopic_square:
if verbose:
print(">>>HARD 2a Wykryto teleskopowe b_n = n²/(n-1)² => iloczyn = n² <<<")
# Π_{i=1}^{n} i²/(i-1)² = n² (bo środkowe wyrazy się skracają)
prod_b_done = n**2
# Oblicz a_i
#a_i = a_n_sym.subs(n, i)
#prod_a = sp.Product(a_i, (i, 1, n - 1))
#try:
# prod_a_done = prod_a.doit()
#except Exception:
# prod_a_done = prod_a
a_i = a_n_sym.subs(n, i)
prod_a_rest = sp.Product(a_i, (i, 2, n - 1))############################################
try:
prod_a_rest_done = prod_a_rest.doit()########################
except Exception as e:
if verbose:
print(f"Nie udało się obliczyć prod_a: {e}")
prod_a_rest_done = prod_a_rest #########################
print("tu jestem ", prod_a_rest_done)
prod_a_done = a1_sym * prod_a_rest_done ##########################
print("tu jestem ", prod_a_done)
S_n_expr = sp.simplify(a0_sym * prod_a_done / prod_b_done)
else:
# Przypadek specjalny 4: a_n = n²/(n-1)² (teleskopowe skracanie w liczniku)
a_n_expanded = sp.expand(a_n_sym * (n-1)**2)
is_telescopic_square_a = sp.simplify(a_n_expanded - n**2).is_zero
if is_telescopic_square_a:
if verbose:
print(">>> Wykryto teleskopowe a_n = n²/(n-1)² => iloczyn = (n-1)² <<<")
# Π_{i=1}^{n-1} i²/(i-1)² = (n-1)² (bo 1² * 2²/1² * ... * (n-1)²/(n-2)² = (n-1)²)
prod_a_done = (n-1)**2
# Oblicz b_i
b_i = b_n_sym.subs(n, i)
prod_b = sp.Product(b_i, (i, 1, n))
try:
prod_b_done = prod_b.doit()
except Exception:
prod_b_done = prod_b
S_n_expr = sp.simplify(a0_sym * prod_a_done / prod_b_done)
else:
# Przypadek specjalny 5: b_n = n/(n-1) (teleskopowe skracanie liniowe)
b_n_expanded_linear = sp.expand(b_n_sym * (n-1))
is_telescopic_linear = sp.simplify(b_n_expanded_linear - n).is_zero
if is_telescopic_linear:
if verbose:
print(">>> Wykryto teleskopowe b_n = n/(n-1) => iloczyn = n POPRAWIONE<<<")
# Π_{i=1}^{n} i/(i-1) = n
prod_b_done = n
# Oblicz a_i
a_i = a_n_sym.subs(n, i)
# Jeśli a_i = 1, to iloczyn = 1
if sp.simplify(a_i - 1).is_zero:
prod_a_done = sp.Integer(1)
if verbose:
print(">>> a_i = 1, więc iloczyn a = 1 <<<")
else:
prod_a_rest = sp.Product(a_i, (i, 2, n - 1))############################################
try:
prod_a_rest_done = prod_a_rest.doit()########################
except Exception as e:
if verbose:
print(f"Nie udało się obliczyć prod_a: {e}")
prod_a_done = prod_a_rest#########################
prod_a_done = a1_sym * prod_a_rest_done ##########################
#prod_a = sp.Product(a_i, (i, 1, n - 1))
# try:
# prod_a_done = prod_a.doit()
# except Exception:
# prod_a_done = prod_a
S_n_expr = sp.simplify(a0_sym * prod_a_done / prod_b_done)
else:
# Przypadek specjalny 6: a_n = n/(n-1) (teleskopowe w liczniku)
a_n_expanded_linear = sp.expand(a_n_sym * (n-1))
is_telescopic_linear_a = sp.simplify(a_n_expanded_linear - n).is_zero
if is_telescopic_linear_a:
if verbose:
print(">>> Wykryto teleskopowe a_n = n/(n-1) => iloczyn = (n-1) <<<")
# Π_{i=1}^{n-1} i/(i-1) = (n-1)
prod_a_done = n - 1
# Oblicz b_i
b_i = b_n_sym.subs(n, i)
prod_b = sp.Product(b_i, (i, 1, n))
try:
prod_b_done = prod_b.doit()
except Exception:
prod_b_done = prod_b
S_n_expr = sp.simplify(a0_sym * prod_a_done / prod_b_done)
else:
# Przypadek ogólny
if verbose:
print(">>> Przypadek ogólny POPRAWIONE <<<")
a_i = a_n_sym.subs(n, i)
b_i = b_n_sym.subs(n, i)
if verbose:
print(f"a_i: {a_i}, b_i: {b_i}")
# prod_a = sp.Product(a_i, (i, 1, n - 1))
# try:
# prod_a_done = prod_a.doit()
# except Exception as e:
# if verbose:
# print(f"Nie udało się obliczyć prod_a: {e}")
# prod_a_done = prod_a
prod_a_rest = sp.Product(a_i, (i, 2, n - 1))############################################
try:
prod_a_rest_done = prod_a_rest.doit()########################
except Exception as e:
if verbose:
print(f"Nie udało się obliczyć prod_a: {e}")
prod_a_done = prod_a_rest#########################
prod_a_done = a1_sym * prod_a_rest_done ##########################
prod_b = sp.Product(b_i, (i, 1, n))
try:
prod_b_done = prod_b.doit()
except Exception as e:
if verbose:
print(f"Nie udało się obliczyć prod_b: {e}")
prod_b_done = prod_b
S_n_expr = sp.simplify(a0_sym * prod_a_done / prod_b_done)
# KLUCZOWE: Agresywnie uprość i zamień n na N_SYMBOL
S_n_expr = S_n_expr.subs(sp.Symbol('n'), N_SYMBOL)
S_n_expr = aggressive_simplify(S_n_expr)
S_n_expr = convert_negative_powers_to_fractions(S_n_expr)
S_n_expr = aggressive_simplify(S_n_expr)
# Konwersja do stringa
S_n_str = to_latex_display_chat(S_n_expr)
# Oblicz S_1 podstawiając n=1
try:
S_1_expr = sp.simplify(S_n_expr.subs(n, 1))
S_1_expr = convert_negative_powers_to_fractions(S_1_expr)
S_1_str = to_latex_display_chat(S_1_expr)
if verbose:
print(f"S_1 obliczone: {S_1_expr}")
except Exception as e:
if verbose:
print(f"Nie udało się obliczyć S_1: {e}")
S_1_expr = None
S_1_str = "?"
#Oblicz S_1_df z definicji a0/b1
try:
S_1_df_expr = sp.simplify(a0_sym / b1_sym)
S_1_df_expr = convert_negative_powers_to_fractions(S_1_df_expr)
S_1_df_expr = aggressive_simplify(S_1_df_expr)
S_1_df_str = to_latex_display_chat(S_1_df_expr)
if verbose:
print(f"S_1_def = a_0/b_1 = {S_1_df_expr}")
except Exception as e:
if verbose:
print(f"Nie udało się obliczyć S_1_df: {e}")
S_1_df_expr = None
S_1_df_str = "?"
return S_n_expr, S_n_str, S_1_expr, S_1_str, S_1_df_expr, S_1_df_str
def generate_Sk_ck_product_new(S_n_expr, c_n, verbose=True):
"""
Generuje iloczyn S_k * c_k podstawiając k zamiast n.
"""
import sympy as sp
if isinstance(c_n, str):
c_n_str = re.sub(r'(\w+)!', r'factorial(\1)', str(c_n))
c_n_sym = sp.sympify(c_n_str)
elif isinstance(c_n, sp.Expr):
c_n_sym = c_n
else:
c_n_sym = sp.sympify(c_n)
if verbose:
print(f"DEBUG c_n input: {c_n}, type: {type(c_n)}")
print(f"DEBUG c_n_sym: {c_n_sym}, type: {type(c_n_sym)}")
# Wyciągnij WSZYSTKIE symbole 'n' z obu wyrażeń
all_n_symbols = set()
for s in S_n_expr.free_symbols:
if str(s) == 'n':
all_n_symbols.add(s)
for s in c_n_sym.free_symbols:
if str(s) == 'n':
all_n_symbols.add(s)
if verbose:
print(f"DEBUG All 'n' symbols found: {[(s, id(s)) for s in all_n_symbols]}")
# Utwórz symbol k
k = sp.Symbol("k", integer=True, positive=True)
# KLUCZOWA ZMIANA: Podstaw WSZYSTKIE różne symbole 'n' na k
S_k = S_n_expr
c_k = c_n_sym
for n_symbol in all_n_symbols:
S_k = S_k.subs(n_symbol, k)
c_k = c_k.subs(n_symbol, k)
if verbose:
print(f"S_n: {S_n_expr}")
print(f"c_n: {c_n_sym}")
print(f"S_k (after subs): {S_k}")
print(f"c_k (after subs): {c_k}")
# Oblicz iloczyn
product = sp.simplify(S_k * c_k)
if verbose:
print(f"S_k * c_k: {product}")
# Konwersja do LaTeX
product_latex = to_latex_display_chat(product)
return product, product_latex
def compute_sum_Sk_ck(Sk_ck_expr, n_symbol, start_k=1, verbose=True):
"""
Oblicza sumę od k=1 do n wyrażenia Sk_ck_expr.
Próbuje użyć wzoru na sumę ciągu geometrycznego lub sympy.summation.
Args:
Sk_ck_expr: wyrażenie sympy zawierające k
n_symbol: symbol n (górna granica sumy)
verbose: czy drukować informacje debugowania
Returns:
tuple: (wyrażenie_sympy, string_latex)
"""
import sympy as sp
# Wyciągnij symbol k z wyrażenia
k_symbols = [s for s in Sk_ck_expr.free_symbols if str(s) == 'k']
if not k_symbols:
# Jeśli nie ma k, to wyrażenie jest stałe względem k
range_size = n_symbol - start_k + 1
result = sp.simplify(Sk_ck_expr * range_size)
if verbose:
print(f"Brak k w wyrażeniu, wynik: {result}")
return result, to_latex_display_chat(result)
k = k_symbols[0]
if verbose:
print(f"=== compute_sum_Sk_ck ===")
print(f"Sk_ck_expr: {Sk_ck_expr}")
print(f"Symbol k: {k}, n: {n_symbol}, start: {start_k}")
# Próbuj obliczyć sumę symboliczną
try:
sum_expr = sp.summation(Sk_ck_expr, (k, start_k, n_symbol))
sum_simplified = sp.simplify(sum_expr)
if verbose:
print(f"Suma (summation): {sum_expr}")
print(f"Suma (simplified): {sum_simplified}")
# Konwersja do LaTeX
sum_latex = to_latex_display_chat(sum_simplified)
return sum_simplified, sum_latex
except Exception as e:
if verbose:
print(f"Nie udało się obliczyć sumy symbolicznej: {e}")
# Fallback: zostaw jako sumę
sum_expr = sp.Sum(Sk_ck_expr, (k, start_k, n_symbol))
sum_latex = f"\\sum_{{k={start_k}}}^{{n}} {to_latex_display_chat(Sk_ck_expr)}"
return sum_expr, sum_latex
def compute_final_Tn(S_n_expr, S_1_expr, a_n, b_1, T_0, sum_Sk_ck_expr, verbose=True):
"""
Oblicza końcowy wynik T_n = 1/(S_n * a_n) * (S_1 * b_1 * T_0 + suma(S_k * c_k))
Args:
S_n_expr: wyrażenie sympy dla S_n
S_1_expr: wyrażenie sympy dla S_1
a_n: współczynnik a_n
b_1: wartość b_1 (dla n=1)
T_0: wartość początkowa
sum_Sk_ck_expr: wyrażenie sympy dla sumy S_k * c_k
verbose: czy drukować debug info
Returns:
tuple: (T_n_expr, T_n_str) - wyrażenie sympy i string LaTeX
"""
import sympy as sp
if verbose:
print("=== compute_final_Tn ===")
print(f"S_n: {S_n_expr}")
print(f"S_1: {S_1_expr}")
print(f"a_n: {a_n}")
print(f"b_1: {b_1}")
print(f"T_0: {T_0}")
print(f"sum: {sum_Sk_ck_expr}")
# Konwersje na sympy
a_n_sym = sp.sympify(a_n) if not isinstance(a_n, sp.Expr) else a_n
b_1_sym = sp.sympify(b_1) if not isinstance(b_1, sp.Expr) else b_1
T_0_sym = sp.sympify(T_0) if not isinstance(T_0, sp.Expr) else T_0
# Oblicz 1/(S_n * a_n)
inverse_Sn_an = sp.simplify(1 / (S_n_expr * a_n_sym))
inverse_Sn_an = aggressive_simplify(inverse_Sn_an)
if verbose:
print(f"1/(S_n*a_n): {inverse_Sn_an}")
# Oblicz S_1 * b_1 * T_0 + suma
inner_expr = sp.simplify(S_1_expr * b_1_sym * T_0_sym + sum_Sk_ck_expr)
inner_expr = aggressive_simplify(inner_expr)
if verbose:
print(f"S_1*b_1*T_0 + suma: {inner_expr}")
# Oblicz końcowy wynik
#T_n_expr = sp.simplify(inverse_Sn_an * inner_expr)
T_n_expr = inverse_Sn_an * inner_expr
# KLUCZOWE: Agresywnie uprość wynik
T_n_expr = aggressive_simplify(T_n_expr)
# Konwertuj ujemne wykładniki na ułamki
T_n_expr = convert_negative_powers_to_fractions(T_n_expr)
# Jeszcze raz uprość
T_n_expr = aggressive_simplify(T_n_expr)
if verbose:
print(f"T_n (final) AGRESSIVE: {T_n_expr}")
# Konwersja do LaTeX
T_n_str = to_latex_display_chat(T_n_expr)
return T_n_expr, T_n_str
def compute_final_Tn_sprzeczne(S_n_expr, S_1_expr, a_n, b_1, T_0, s_1, c_1, sum_Sk_ck_expr, verbose=True):
"""
Oblicza końcowy wynik T_n = 1/(S_n * a_n) * (S_1 * b_1 * T_0 + s_1*c_1 + suma(S_k * c_k))
Args:
S_n_expr: wyrażenie sympy dla S_n
S_1_expr: wyrażenie sympy dla S_1
a_n: współczynnik a_n
b_1: wartość b_1 (dla n=1)
T_0: wartość początkowa
sum_Sk_ck_expr: wyrażenie sympy dla sumy S_k * c_k
verbose: czy drukować debug info
Returns:
tuple: (T_n_expr, T_n_str) - wyrażenie sympy i string LaTeX
"""
import sympy as sp
if verbose:
print("=== compute_final_Tn_Sprzecznosc ===")
print(f"S_n: {S_n_expr}")
print(f"S_1: {S_1_expr}")
print(f"a_n: {a_n}")
print(f"b_1: {b_1}")
print(f"T_0: {T_0}")
print(f"s_1: {s_1}")
print(f"c_1: {c_1}")
print(f"sum: {sum_Sk_ck_expr}")
# Konwersje na sympy
a_n_sym = sp.sympify(a_n) if not isinstance(a_n, sp.Expr) else a_n
b_1_sym = sp.sympify(b_1) if not isinstance(b_1, sp.Expr) else b_1
T_0_sym = sp.sympify(T_0) if not isinstance(T_0, sp.Expr) else T_0
s_1_sym = sp.sympify(s_1) if not isinstance(s_1, sp.Expr) else s_1
c_1_sym = sp.sympify(c_1) if not isinstance(c_1, sp.Expr) else c_1
# Oblicz 1/(S_n * a_n)
inverse_Sn_an = sp.simplify(1 / (S_n_expr * a_n_sym))
inverse_Sn_an = aggressive_simplify(inverse_Sn_an)
if verbose:
print(f"1/(S_n*a_n): {inverse_Sn_an}")
# Oblicz S_1 * b_1 * T_0 + s_1*c_1 + suma
inner_expr = sp.simplify(S_1_expr * b_1_sym * T_0_sym + s_1_sym * c_1_sym + sum_Sk_ck_expr)
inner_expr = aggressive_simplify(inner_expr)
if verbose:
print(f"S_1*b_1*T_0 + s_1*c_1 + suma: {inner_expr}")
# Oblicz końcowy wynik
T_n_expr = inverse_Sn_an * inner_expr
# KLUCZOWE: Agresywnie uprość wynik
T_n_expr = aggressive_simplify(T_n_expr)
# Konwertuj ujemne wykładniki na ułamki
T_n_expr = convert_negative_powers_to_fractions(T_n_expr)
# Jeszcze raz uprość
T_n_expr = aggressive_simplify(T_n_expr)
if verbose:
print(f"T_n (final) AGRESSIVE: {T_n_expr}")
# Konwersja do LaTeX
T_n_str = to_latex_display_chat(T_n_expr)
return T_n_expr, T_n_str
def parse_recurrence_equation_3(equation_text, compat):
"""
Analizuje rekurencję w postaci:
a_0*T_0 = c_0
[opcjonalnie] a_1*T_1 = b_1*T_0 + c_1
a_n*T_n = b_n*T_{n-1} + c_n
Zwraca: a_0, a_1, a_n, b_1, b_n, c_0, c_1, c_n, T_0, S_n (sympy + string), initials
"""
import sympy as sp
import re
# Dodaj przecinek przed T_1 jeśli go brakuje (po T_0=...)
equation_text = re.sub(
r'(T_0\s*=\s*[0-9\+\-\*/\^\(\)n]+)\s+(?=([0-9]+\s*\*\s*)?T_1\s*=)',
r'\1, ',
equation_text
)
# Dodaj przecinek przed T_n jeśli go brakuje (po T_0=... lub T_1=...)
equation_text = re.sub(
r'(T_[01]\s*=\s*[^,;]+)\s+(?=([0-9a-zA-Z\(\)]+\s*\*\s*)?T_n\s*=)',
r'\1, ',
equation_text
)
# Dodaj przecinek między T_1=... a wyrażeniem zawierającym T_n (bez znaku =)
# np. "T_1=T_0+5 2*T_n = ..." -> "T_1=T_0+5, 2*T_n = ..."
equation_text = re.sub(
r'(T_1\s*=\s*[^,;]+)\s+(?=([0-9a-zA-Z\(\)\^\*/\s]+\s*\*\s*)?T_n\s*=)',
r'\1, ',
equation_text
)
# Naprawiamy brak separatora między warunkiem początkowym a równaniem
#equation_text = re.sub(r"(T_0\s*=\s*[0-9\+\-\*/\^\(\)n]+)\s+(?=[0-9]+\*?T_n)", r"\1, ", equation_text)
#equation_text = re.sub(r"(T_0\s*=\s*[0-9\+\-\*/\^\(\)n]+)\s+(?=[0-9]+\*?T_1)", r"\1, ", equation_text)
# Normalizacja wejścia
equation_text = equation_text.replace("^", "**")
equation_text = re.sub(r"\s+", " ", equation_text.strip())
n = N_SYMBOL # UŻYJ GLOBALNEGO SYMBOLU
T = sp.Function("T")
print(f"Symbol n created: {n}, id: {id(n)}")
print("=== RAW INPUT ===")
print(equation_text)
# Rozdziel równania po przecinku lub średniku
equations = re.split(r'[,;]\s*', equation_text)
equations = [eq.strip() for eq in equations if eq.strip()]
print(f"Znaleziono {len(equations)} równań:")
for i, eq in enumerate(equations):
print(f" [{i}]: {eq}")
# Inicjalizacja zmiennych
a_0 = sp.Integer(1)
a_1 = None
a_n = None
b_1 = None
b_n = None
c_0 = None
c_1 = None
c_n = None
T_0 = None
T_1 = None
inits = []
local_dict = {'n': n, 'T': T, 'factorial': sp.factorial}
# Przetwarzanie każdego równania
for eq in equations:
# Obsługa factorial w notacji !
eq_processed = re.sub(r'(\w+)!', r'factorial(\1)', eq)
# Sprawdź, czy to warunek początkowy T_0
if re.match(r'.*T_0\s*=', eq_processed):
match = re.match(r'([0-9\*\^\+\-\s/\(\)]*)T_0\s*=\s*(.+)', eq_processed)
if match:
coeff_str = match.group(1).strip()
val_str = match.group(2).strip()
a_0 = sp.sympify(coeff_str, locals=local_dict) if coeff_str else sp.Integer(1)
c_0 = sp.sympify(val_str, locals=local_dict)
T_0 = sp.simplify(c_0 / a_0)
inits.append((0, T_0))
print(f" → T_0: a_0={a_0}, c_0={c_0}, T_0={T_0}")
continue
# Sprawdź, czy to równanie dla T_1
if re.match(r'.*T_1\s*=', eq_processed):
# Może być w postaci: T_1 = T_0 + ... lub a_1*T_1 = b_1*T_0 + c_1
eq_processed = eq_processed.replace("T_0", "T(0)").replace("T_1", "T(1)")
if "=" in eq_processed:
lhs_str, rhs_str = eq_processed.split("=", 1)
lhs = sp.sympify(lhs_str.strip(), locals=local_dict)
rhs = sp.sympify(rhs_str.strip(), locals=local_dict)
# Wyciągnij współczynniki
a_1 = lhs.expand().coeff(T(1)) or sp.Integer(1)
b_1 = rhs.expand().coeff(T(0)) or sp.Integer(0)
c_1_raw = rhs - b_1 * T(0)
c_1 = sp.simplify(c_1_raw.replace(T, lambda x: 0))
# Oblicz T_1 jeśli mamy T_0
if T_0 is not None:
T_1 = sp.simplify((b_1 * T_0 + c_1) / a_1)
inits.append((1, T_1))
print(f" → T_1: a_1={a_1}, b_1={b_1}, c_1={c_1}, T_1={T_1}")
continue
# Równanie główne dla T_n
if "T_n" in eq or "T_{n-1}" in eq:
eq_processed = eq_processed.replace("T_{n-1}", "T(n-1)").replace("T_n", "T(n)")
if "=" in eq_processed:
lhs_str, rhs_str = eq_processed.split("=", 1)
lhs = sp.sympify(lhs_str.strip(), locals=local_dict)
rhs = sp.sympify(rhs_str.strip(), locals=local_dict)
a_n = lhs.expand().coeff(T(n)) or sp.Integer(1)
b_n = rhs.expand().coeff(T(n-1)) or sp.Integer(0)
c_n_raw = rhs - b_n * T(n-1)
c_n = sp.simplify(c_n_raw.replace(T, lambda x: 0))
print(f" → T_n: a_n={a_n}, b_n={b_n}, c_n={c_n}")
# Jeśli nie podano a_1, oblicz z a_n dla n=1
if a_1 is None and a_n is not None:
a_1 = sp.simplify(a_n.subs(n, 1))
print(f" → a_1 obliczone z a_n: {a_1}")
# Jeśli nie podano b_1, oblicz z b_n dla n=1
if b_1 is None and b_n is not None:
b_1 = sp.simplify(b_n.subs(n, 1))
print(f" → b_1 obliczone z b_n: {b_1}")
# Jeśli nie podano c_1, oblicz z c_n dla n=1
if c_1 is None and c_n is not None:
c_1 = sp.simplify(c_n.subs(n, 1))
print(f" → c_1 obliczone z c_n: {c_1}")
# Zamień wszystkie symbole 'n' na N_SYMBOL
if a_n: a_n = a_n.subs(sp.Symbol('n'), N_SYMBOL)
if b_n: b_n = b_n.subs(sp.Symbol('n'), N_SYMBOL)
if c_n: c_n = c_n.subs(sp.Symbol('n'), N_SYMBOL)
print("WSZYSTKIE \n1. a_0:", a_0, "a_1:", a_1, " a_n:", a_n, "b_1:", b_1, "b_n:", b_n," c_n:", c_n," c_0:", c_0, "c_1:",c_1," T_0:", T_0)
# Obliczenie S_n
print("\n=== Obliczanie S_n ===")
S_n_expr, S_n_str, S_1_expr, S_1_str, S_1_df_expr, S_1_df_str = compute_Sn_Claude_hard2a(a_0, a_1, a_n, b_1, b_n)
# Obliczenie 1/(S_n * a_n)
try:
inverse_Sn_an = sp.simplify(1 / (S_n_expr * a_n))
inverse_Sn_an = convert_negative_powers_to_fractions(inverse_Sn_an)
inverse_Sn_an = aggressive_simplify(inverse_Sn_an)
inverse_Sn_an = gamma_to_factorial(inverse_Sn_an)
inverse_Sn_an_str = to_latex_display_chat(inverse_Sn_an)
except Exception:
inverse_Sn_an_str = "?"
print("DEBUG 1/(S_n * a_n):", inverse_Sn_an_str)
# Obliczenie S_k * c_k
Sk_ck_expr, Sk_ck_str = generate_Sk_ck_product_new(S_n_expr, c_n, verbose=True)
print("DEBUG S_k * c_k:", Sk_ck_str)
# Obliczenie sumy - zakres zależy od compatibility (compat)
if compat == "1":
# Zgodność: suma od k=1 do n
sum_start = 1
sum_Sk_ck_expr, sum_Sk_ck_str = compute_sum_Sk_ck(Sk_ck_expr, n, 1, verbose=True)
elif compat == "0":
# Brak zgodności: suma od k=2 do n
sum_start = 2
sum_Sk_ck_expr, sum_Sk_ck_str = compute_sum_Sk_ck(Sk_ck_expr, n, 2, verbose=True)
else:
# Domyślnie: suma od k=1 do n
sum_start = 1
sum_Sk_ck_expr, sum_Sk_ck_str = compute_sum_Sk_ck(Sk_ck_expr, n, 1, verbose=True)
print(f"DEBUG suma S_k*c_k (od k={sum_start} do n): {sum_Sk_ck_str}")
# Obliczenie sumy
# sum_Sk_ck_expr, sum_Sk_ck_str = compute_sum_Sk_ck(Sk_ck_expr, n, 1, verbose=True)
# print(f"DEBUG suma S_k*c_k: {sum_Sk_ck_str}")
# Obliczenie końcowego T_n
if compat == "1":
"Zgodność"
T_n_expr, T_n_str = compute_final_Tn(S_n_expr, S_1_df_expr, a_n, b_1, T_0, sum_Sk_ck_expr, verbose=True)
print(f"DEBUG T_n (final): {T_n_str}")
elif compat == "0":
# Brak zgodności:
T_n_expr, T_n_str = compute_final_Tn_sprzeczne(S_n_expr, S_1_df_expr, a_n, b_1, T_0, S_1_df_expr, c_1, sum_Sk_ck_expr, verbose=True)
print(f"DEBUG T_n (final sprzeczne): {T_n_str}")
return {
"a_0": to_latex_display_chat(a_0),
"a_1": to_latex_display_chat(a_1) if a_1 else "?",
"a_n": to_latex_display_chat(a_n),
"b_1": to_latex_display_chat(b_1),
"b_n": to_latex_display_chat(b_n),
"c_0": to_latex_display_chat(c_0) if c_0 else "?",
"c_1": to_latex_display_chat(c_1) if c_1 else "?",
"c_n": to_latex_display_chat(c_n),
"T_0": T_0,
"S_n": to_latex_display_chat(S_n_str),
"S_n_sym": S_n_expr,
"S_1": S_1_str,
"S_1_sym": S_1_expr,
"S_1_df":S_1_df_str,
"inverse_Sn_an": to_latex_display_chat(inverse_Sn_an_str),
"Sk_ck": Sk_ck_str,
"SUMA": sum_Sk_ck_str,
"T_n": T_n_str,
"T_n_sym": T_n_expr,
"initials": [(0, T_0), (1, T_1)] if T_1 else [(0, T_0)]
}
# --- Dopasowanie podobnych zadań ---
def find_similar(query, top_k=3):
corpus = [(i, d["statement"] + " | " + d.get("topic", "") + " | " + d.get("group_id", ""))
for i, d in enumerate(DATA)]
choices = [c[1] for c in corpus]
results = process.extract(query, choices, scorer=fuzz.token_set_ratio, limit=top_k)
return [DATA[corpus[r[2]][0]] for r in results]
# --- Tryb wskazówek ---
def hint_mode(user_problem, step_idx=0):
hits = find_similar(user_problem, top_k=1)
if not hits:
return "Nie znalazłam podobnego zadania. Spróbuj dodać więcej kontekstu.", step_idx, coeffs
z = hits[0]
sol = z.get("solution", {})
tips = sol.get("tips", [])
total = len(tips)
compatibility = z.get("compatibility", None)
print(f"\n=== COMPATIBILITY ===")
print(f"Compatibility:", compatibility)
try:
coeffs = parse_recurrence_equation_3(user_problem, compatibility)
for k, v in coeffs.items():
if hasattr(v, "__str__"):
coeffs[k] = str(v)
except Exception:
print("ERROR inside hint_mode():", e)
if not tips:
return "Brak wskazówek w bazie.", step_idx, coeffs
if step_idx >= total:
return "🎓 To już ostatnia wskazówka.", step_idx, coeffs
tip = tips[step_idx]
#msg = f"**Wskazówka {step_idx+1}/{total}** (na podstawie *{z['title']}*):\n\n➡️ {tip}"
msg = f"**Hint {step_idx+1}/{total}** (based on *{z['title']}*):\n\n➡️ {tip}"
#msg = f"**Wskazówka {step_idx+1}/{total}** (na podstawie *{z['title']}*):\n\n$$ {tip} $$"
return msg, step_idx, coeffs
# --- Pokaż realizację wskazówki ---
def show_solution(user_problem, step_idx, coeffs):
hits = find_similar(user_problem, top_k=1)
if not hits:
return "Nie znaleziono zadania."
z = hits[0]
sol = z.get("solution", {})
tips_solutions = sol.get("tips_solutions", [])
if step_idx >= len(tips_solutions):
return "Brak rozwiązania dla tej wskazówki."
tip_sol_template = tips_solutions[step_idx]
# Konwertujemy wszystkie wartości na string
coeffs_for_format = {k: str(v) for k, v in coeffs.items()}
#Rozwiązanie: użycie string.Formatter z bezpiecznym fallback-Python pozwala nadpisać zachowanie format_map() używając własnej klasy,
#która zwraca oryginalny tekst dla nieznanych kluczy:
# Klasa SafeDict zostawia nieznane placeholdery w szablonie
#class SafeDict(dict):
# def __missing__(self, key):
# return "{" + key + "}"
class SafeDict(dict):
def __missing__(self, key):
# pozostaw latexowe indeksy i podobne konstrukcje nietknięte
if "=" in key or not key.isidentifier():
return "{" + key + "}"
return "{" + key + "}"
try:
# <-- kluczowa zmiana: używamy format_map z SafeDict
tip_sol = tip_sol_template.format_map(SafeDict(coeffs_for_format))
except Exception:
tip_sol = tip_sol_template
#return f"🧩 **Realizacja wskazówki {step_idx+1}:**\n\n{tip_sol}"
#latex_text = f"🧩 **Realizacja wskazówki {step_idx+1}:**\n\n$$ {tip_sol} $$"
latex_text = f"🧩 **Hint {step_idx+1} realization:**\n\n$$ {tip_sol} $$"
return latex_text
# --- Tryb weryfikacji ---
def verify_mode(user_problem, user_answer):
hits = find_similar(user_problem, top_k=1)
if not hits:
return "Nie znalazłam podobnego zadania."
z = hits[0]
gold = z.get("solution", {}).get("final", "")
if not gold:
return "Brak wzorcowej odpowiedzi."
try:
x, n = sp.symbols("x n")
ue = sp.simplify(sp.sympify(user_answer))
ge = sp.simplify(sp.sympify(gold))
ok = sp.simplify(ue - ge) == 0
verdict = "✅ Wynik zgodny z rozwiązaniem wzorcowym." if ok else "❌ Wynik różni się od wzorca."
return f"**Weryfikacja** ({z['title']}):\n\n{verdict}"
except Exception as e:
return f"Nie udało się porównać wyrażeń: {e}"
with gr.Blocks() as demo:
# gr.Markdown("# 🤖 AI-MDTutor — interaktywny tryb wskazówek")
gr.Markdown("# 🤖 AI-MDTutor — interactive hints mode")
#gr.Markdown("Podaj rekurencję i przechodź krok po kroku. Przy zmianie zadania rozmowa się resetuje.")
gr.Markdown("Provide the recurrence and proceed step by step. When the task changes, the conversation is reset.")
#chatbot = gr.Chatbot(label="Rozmowa z AI-Tutorem", height=400)
chatbot = gr.Chatbot(label="Conversation with the AI-MDTutor", height=400)
#inp = gr.Textbox(label="Treść zadania", placeholder="np. T_0=1 4*T_n = 5*T_{n-1} + 2**n")
inp = gr.Textbox(label="Problem statement", placeholder="np. T_0=1 4*T_n = 5*T_{n-1} + 2**n")
#ans = gr.Textbox(label="Wynik końcowy", placeholder="Tutaj pojawi się wynik całego zadania")
# Stan aplikacji
step_state = gr.State(0) # aktualny indeks wskazówki
coeffs_state = gr.State({}) # współczynniki obliczone z treści zadania
history_state = gr.State([]) # historia rozmowy
with gr.Row():
#btn_hint = gr.Button("🧩 Pierwsza wskazówka")
#btn_show = gr.Button("👁 Pokaż realizację wskazówki")
#btn_final = gr.Button("🏁 Pokaż wynik końcowy")
btn_hint = gr.Button("🧩 First hint")
btn_show = gr.Button("👁 Show hint realization")
btn_final = gr.Button("🏁 Show the final result")
# --- Logika przycisków ---
# RESET przy zmianie treści zadania
def reset_session(_):
return [], 0, {}, gr.update(value="🧩 First hint")
inp.change(fn=reset_session, inputs=inp,
outputs=[chatbot, step_state, coeffs_state, btn_hint])
# 1. Przycisk „Pierwsza wskazówka” / „Kolejna wskazówka”
def next_hint(user_problem, history, step_idx):
msg, new_idx, coeffs = hint_mode(user_problem, step_idx)
# aktualizacja historii
#history.append(("🧩 Wskazówka", msg))
history.append(("🧩 Hint", msg))
# zmień etykietę przycisku po pierwszym kliknięciu
#new_label = "➡️ Kolejna wskazówka" if new_idx >= 0 else "🧩 Pierwsza wskazówka"
new_label = "➡️ Next hint" if new_idx >= 0 else "🧩 First hint"
return history, new_idx + 1, coeffs, gr.update(value=new_label)
btn_hint.click(
next_hint,
inputs=[inp, history_state, step_state],
outputs=[chatbot, step_state, coeffs_state, btn_hint]
)
# 2. Przycisk „Pokaż realizację wskazówki”
def show_current_solution(user_problem, history, step_idx, coeffs):
msg = show_solution(user_problem, step_idx - 1, coeffs)
#history.append(("👁 Pokaż realizację wskazówki", msg))
history.append(("👁 Show hint realization", msg))
return history
btn_show.click(
show_current_solution,
inputs=[inp, history_state, step_state, coeffs_state],
outputs=chatbot
)
# 3. Przycisk „Pokaż wynik końcowy”
def show_final_result(history, coeffs_state):
T_n_str = coeffs_state.get("T_n")
if not T_n_str:
#msg = "Nie obliczono jeszcze T_n. Najpierw przejdź przez wskazówki."
msg = "T_n has not been calculated yet. Go through the hints first."
else:
# Formatowanie jako LaTeX
#msg = f"**Wynik końcowy:**\n\n$$ T_n = {T_n_str} $$"
msg = f"**Final result:**\n\n$$ T_n = {T_n_str} $$"
#history.append(("🏁 Pokaż wynik końcowy", msg))
history.append(("🏁 Show the final result", msg))
return history
btn_final.click(
show_final_result,
inputs=[history_state, coeffs_state],
outputs=chatbot # ZMIANA: zwraca do chatbota zamiast ans
)
#gr.Markdown("---\n💡 Zmiana treści zadania resetuje rozmowę i licznik wskazówek.")
demo.launch(server_name="0.0.0.0", server_port=7860)
import json, gradio as gr
from rapidfuzz import fuzz, process
import sympy as sp
import re
# KLUCZOWA ZMIANA: Globalny symbol n używany wszędzie
N_SYMBOL = sp.Symbol("n", integer=True, positive=True)
# --- Wczytaj bazę wiedzy ---
DATA = json.load(open("knowledge.json", "r", encoding="utf-8"))
def pretty_factorial(expr):
"""Zamienia gamma(x) → (x-1)! w dowolnym kontekście."""
expr_str = str(expr)
# regex dopasowujący np. gamma(n), gamma(n+1), gamma(k-1)
pattern = r"gamma\(([^)]+)\)"
def repl(match):
inner = match.group(1).strip()
return f"({inner}-1)!"
expr_str = re.sub(pattern, repl, expr_str)
return expr_str
def gamma_to_factorial(expr):
"""
Zamienia gamma(n+1) na factorial(n) w wyrażeniu SymPy.
"""
import sympy as sp
if not isinstance(expr, sp.Expr):
return expr
# Zamień gamma(n+1) -> factorial(n)
expr = expr.rewrite(sp.factorial)
return expr
def aggressive_simplify(expr):
"""
Agresywnie upraszcza wyrażenie sympy, w szczególności potęgi.
"""
import sympy as sp
if not isinstance(expr, sp.Expr):
return expr
# Zamień wszystkie symbole 'n' na nasz globalny N_SYMBOL
expr = expr.subs(sp.Symbol('n'), N_SYMBOL)
# KROK 1: Podstawowe uproszczenie
expr = sp.simplify(expr)
# KROK 2: Uprość potęgi (np. 2^(n-n) -> 2^0 -> 1)
expr = sp.powsimp(expr, deep=True, combine='all', force=True)
# KROK 3: Rozwiń i znów uprość
expr = sp.expand(expr)
expr = sp.simplify(expr)
# KROK 4: Usuń wspólne czynniki
expr = sp.cancel(expr)
# KROK 5: Uprość licznik i mianownik osobno
num, den = sp.fraction(expr)
num = sp.simplify(sp.powsimp(num, deep=True, combine='all'))
den = sp.simplify(sp.powsimp(den, deep=True, combine='all'))
# KROK 6: Zwróć jako ułamek
result = sp.simplify(num / den)
# KROK 7: Jeszcze raz powsimp na wyniku
result = sp.powsimp(result, deep=True, combine='all')
return result
def to_latex_display_chat(obj):
"""
Konwertuje obiekt (sympy.Expr lub string) do ładnego LaTeX-a.
Strategia:
- jeśli to sympy.Expr -> sp.latex(expr)
- jeśli to string -> spróbuj sympify -> sp.latex(expr)
- fallback: dopracowany regex: factorial(...) -> ( ... )! i ** -> ^{...}
Zwraca gotowy fragment LaTeX (bez dolarów).
"""
import sympy as sp
# Jeśli to już sympy.Expr — bezpośrednio LaTeX (SymPy dobrze obsługuje potęgi i silnie)
try:
if isinstance(obj, sp.Expr):
obj = aggressive_simplify(obj)
#latex_str = sp.latex(obj)
# POPRAWKA: Konwertuj gamma(n+1) -> n! w LaTeX
#latex_str = re.sub(r'\\Gamma\s*\(\s*([^)]+)\s*\+\s*1\s*\)', r'(\1)!', latex_str)
#latex_str = re.sub(r'\\Gamma\s*\(\s*n\s*\+\s*1\s*\)', r'n!', latex_str)
#return latex_str
#return sp.latex(obj)
# POPRAWKA: Konwertuj gamma na factorial PRZED generowaniem LaTeX