MatD / app.py
AnnaAneta's picture
Update app.py
89b6243 verified
Raw History Blame Contribute Delete
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