import json, gradio as gr from rapidfuzz import fuzz, process import sympy as sp import re # --- 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 parse_recurrence_equation(equation_text): """ Analizuje rekurencję w postaci: a_0*T_0 = c_0 a_n*T_n = b_n*T_{n-1} + c_n Zwraca: a_0, a_n, b_n, c_n, c_0, initials """ import re, sympy as sp # 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 = equation_text.replace("^", "**") equation_text = re.sub(r"\s+", " ", equation_text.strip()) n = sp.Symbol("n") T = sp.Function("T") print("=== RAW INPUT ===") print(equation_text) # Znajdujemy równanie główne (a_n*T_n = b_n*T_{n-1} + c_n) match_eq = re.search(r"([0-9\*\^\+\-\sT_n\{\}\(\)n]+=[^=]+)$", equation_text) if not match_eq: raise ValueError("Nie udało się rozpoznać równania rekurencji w treści.") eq_part = match_eq.group(1) expr_text = eq_part.replace("T_{n-1}", "T(n-1)").replace("T_n", "T(n)") lhs_str, rhs_str = expr_text.split("=") lhs = sp.sympify(lhs_str) rhs = sp.sympify(rhs_str) a_n = lhs.expand().coeff(T(n)) or 1 b_n = rhs.expand().coeff(T(n-1)) or 0 c_n = sp.simplify(rhs - b_n*T(n-1)) # --- Warunki początkowe --- (T_0=1, 2*T_0=5, itp.) initials = re.findall(r"([0-9\*\^\+\-\s]*)T_([0-9]+)\s*=\s*([0-9\+\-\*/\^\(\)n]+)", equation_text) a_0 = sp.Integer(1) c_0 = None inits = [] for coeff_str, idx_str, val_str in initials: idx = int(idx_str) val = sp.sympify(val_str) coeff_str = coeff_str.strip() if idx == 0: a_0 = sp.sympify(coeff_str) if coeff_str else sp.Integer(1) c_0 = val inits.append((idx, val)) # --- Obliczenie T_0 --- if c_0 is not None: try: T_0 = sp.simplify(c_0 / a_0) except Exception: T_0 = None else: T_0 = None #obliczenie b_1 try: n = sp.Symbol("n") b1 = sp.simplify(sp.sympify(str(b_n)).subs(n, 1)) except Exception: b1 = "?" #żeby sam obliczył i uprościł S_n dla odczytanych współczynników try: n = sp.Symbol("n", integer=True, positive=True) i = sp.Symbol("i", integer=True, positive=True) # a_n, b_n muszą być sympy a_i_sub = a_n.subs(n, i) b_i_sub = b_n.subs(n, i) # --- NAJWAŻNIEJSZY PATCH --- # SymPy źle upraszcza (n-1)! do n**(n-1) w pewnych ścieżkach. # Dlatego NA SIŁĘ obsługujemy poprawnie najczęstszy przypadek. if sp.simplify(b_i_sub - 1) == 0 and sp.simplify(a_i_sub - i) == 0: # Czyli a_n = n oraz b_n = 1 # Wtedy S_n = a_0 * (n-1)! S_n_expr = a_0 * sp.factorial(n - 1) S_n = pretty_factorial(str(S_n_expr)) else: # Ogólny przypadek prod_a = sp.Product(a_i_sub, (i, 1, n - 1)) prod_b = sp.Product(b_i_sub, (i, 1, n)) S_n_expr = (a_0 * prod_a) / prod_b S_n_simpl = sp.simplify(S_n_expr) S_n = S_n_simpl except Exception as e: S_n = "?" print("a_0:", a_0, " a_n:", a_n, "b_n:", b_n," c_n:", c_n," c_0:", c_0," T_0:", T_0) print("DEBUG S_n sympy:", S_n) return { "a_0": pretty_factorial(a_0), "a_n": pretty_factorial(a_n), "b_n": pretty_factorial(b_n), "c_n": pretty_factorial(c_n), "b_1": pretty_factorial(str(b1)), "S_n": pretty_factorial(str(S_n)), "c_0": c_0, "T_0": T_0, # <-- dodane "initials": inits } # --- 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): try: coeffs = parse_recurrence_equation(user_problem) for k, v in coeffs.items(): if hasattr(v, "__str__"): coeffs[k] = str(v) except Exception: coeffs = {"a_0": "?", "a_n": "?", "b_n": "?", "c_n": "?", "c_0": "?", "initials": []} 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) 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"**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 #try: # tip_sol = tip_sol_template.format(**coeffs_for_format) # except KeyError as e: # tip_sol = f"Nie udało się podstawić zmiennej: {e}" #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} $$" 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}" # --- Interfejs Gradio --- with gr.Blocks() as demo: gr.Markdown("# 🤖 AI-TutorMD — interaktywny tryb wskazówek (z resetem)") gr.Markdown("Podaj rekurencję i przechodź krok po kroku. Przy zmianie zadania rozmowa się resetuje.") chatbot = gr.Chatbot(label="Rozmowa z AI-Tutorem", height=400) inp = gr.Textbox(label="Treść zadania", placeholder="np. T_0=1 4*T_n = 5*T_{n-1} + 2**n") ans = gr.Textbox(label="Twój wynik", placeholder="np. (5**n - 1)/4") step_state = gr.State(0) coeffs_state = gr.State({}) history_state = gr.State([]) with gr.Row(): btn_first = gr.Button("🧩 Pierwsza wskazówka") btn_next = gr.Button("➡️ Kolejna wskazówka") btn_show = gr.Button("👁 Pokaż realizację wskazówki") btn_verify = gr.Button("🔍 Weryfikuj wynik") # --- Logika przycisków --- def first_hint(user_problem, history): msg, step_idx, coeffs = hint_mode(user_problem, 0) history.append((user_problem, msg)) return history, step_idx, coeffs def next_hint(user_problem, history, step_idx): msg, new_idx, coeffs = hint_mode(user_problem, step_idx + 1) history.append(("➡️ Kolejna wskazówka", msg)) return history, new_idx, coeffs def show_current_solution(user_problem, history, step_idx, coeffs): msg = show_solution(user_problem, step_idx, coeffs) history.append(("👁 Pokaż realizację wskazówki", msg)) return history def verify(user_problem, user_answer, history): msg = verify_mode(user_problem, user_answer) history.append((f"🧮 {user_problem} = {user_answer}", msg)) return history # --- RESET przy zmianie treści zadania --- def reset_session(_): return [], 0, {} inp.change(fn=reset_session, inputs=inp, outputs=[chatbot, step_state, coeffs_state]) # --- Podpięcie przycisków --- btn_first.click(first_hint, inputs=[inp, history_state], outputs=[chatbot, step_state, coeffs_state]) btn_next.click(next_hint, inputs=[inp, chatbot, step_state], outputs=[chatbot, step_state, coeffs_state]) btn_show.click(show_current_solution, inputs=[inp, chatbot, step_state, coeffs_state], outputs=chatbot) btn_verify.click(verify, inputs=[inp, ans, chatbot], outputs=chatbot) gr.Markdown("---\n💡 Zmiana treści zadania automatycznie resetuje rozmowę i licznik kroków.") demo.launch()