#!/usr/bin/env python3
# T2 — GÉNÉRATEUR des 60 dérivations à résultat vérifiable. Vérités calculées par SymPy
# DANS le générateur (jamais tapées à la main), conventions écrites DANS l'énoncé.
# 6 familles × 10 items, 30 EN / 30 FR. Auto-test sur 4 valeurs connues avant d'écrire.
import json, sympy as sp

items = []


def add(fam, lang, enonce, cible):
    items.append({"id": len(items), "famille": fam, "langue": lang,
                  "enonce": enonce + (" Work step by step. End with exactly one line: FINAL: <expression>. "
                                      "No LaTeX on that line — plain arithmetic like 47/3 or 11/(16*pi**2)."
                                      if lang == "en" else
                                      " Raisonne étape par étape. Termine par exactement une ligne : FINAL: <expression>. "
                                      "Pas de LaTeX sur cette ligne — arithmétique simple type 47/3."),
                  "cibles": [str(sp.nsimplify(cible))]})


# F1 — b0 une boucle, convention DANS l'énoncé
for k, (N, nf) in enumerate([(3, 0), (3, 6), (4, 2), (5, 4), (2, 3), (6, 0), (3, 4), (4, 6), (5, 0), (2, 5)]):
    b0 = sp.Rational(11 * N, 3) - sp.Rational(2 * nf, 3)
    if k % 2 == 0:
        add("b0", "en", f"In SU({N}) gauge theory with {nf} Dirac fermions in the fundamental "
            f"representation, the one-loop beta function is beta(g) = -b0*g**3/(16*pi**2) + O(g**5) "
            f"with b0 = 11*N/3 - 2*nf/3. Derive b0 from the gluon and fermion loop contributions "
            f"and give its numeric value.", b0)
    else:
        add("b0", "fr", f"Dans la théorie de jauge SU({N}) avec {nf} fermions de Dirac dans la "
            f"fondamentale, la fonction beta à une boucle est beta(g) = -b0*g**3/(16*pi**2) + O(g**5) "
            f"avec b0 = 11*N/3 - 2*nf/3. Dérive b0 depuis les contributions gluons et fermions et "
            f"donne sa valeur numérique.", b0)

# F2 — Casimirs / indices / dimensions, en chaîne (multi-étapes)
cas = [(3, "en"), (4, "fr"), (5, "en"), (6, "fr"), (2, "en"), (7, "fr"), (3, "fr"), (4, "en"), (5, "fr"), (8, "en")]
for N, lg in cas:
    c2f = sp.Rational(N * N - 1, 2 * N)
    dimadj = N * N - 1
    val = c2f * dimadj
    if lg == "en":
        add("casimir", lg, f"For SU({N}): first compute the quadratic Casimir of the fundamental "
            f"representation C2(F) = (N**2-1)/(2N), then the dimension of the adjoint, then their "
            f"product C2(F)*dim(adj).", val)
    else:
        add("casimir", lg, f"Pour SU({N}) : calcule d'abord le Casimir quadratique de la fondamentale "
            f"C2(F) = (N**2-1)/(2N), puis la dimension de l'adjointe, puis leur produit C2(F)*dim(adj).", val)

# F3 — intégrales définies
ints = [(5, 3), (4, 2), (6, 1), (3, 5), (7, 2), (2, 7), (5, 4), (4, 3), (6, 2), (3, 2)]
x = sp.symbols('x', positive=True)
for k, (n, a) in enumerate(ints):
    val = sp.integrate(x**n * sp.exp(-a * x), (x, 0, sp.oo))
    lg = "en" if k % 2 == 0 else "fr"
    if lg == "en":
        add("integrale", lg, f"Evaluate the integral of x**{n} * exp(-{a}*x) from 0 to infinity, "
            f"deriving the general formula first.", val)
    else:
        add("integrale", lg, f"Évalue l'intégrale de x**{n} * exp(-{a}*x) de 0 à l'infini, en "
            f"dérivant d'abord la formule générale.", val)

# F4 — sommes finies
soms = [(20, 2), (15, 3), (30, 1), (12, 3), (25, 2), (10, 4), (40, 1), (18, 2), (14, 3), (50, 1)]
kk = sp.symbols('k')
for i, (n, p) in enumerate(soms):
    val = sp.summation(kk**p, (kk, 1, n))
    lg = "en" if i % 2 == 0 else "fr"
    if lg == "en":
        add("somme", lg, f"Compute the sum of k**{p} for k from 1 to {n}, using the closed formula "
            f"(derive it or state it, then apply).", val)
    else:
        add("somme", lg, f"Calcule la somme des k**{p} pour k de 1 à {n}, via la formule fermée "
            f"(dérive-la ou énonce-la, puis applique).", val)

# F5 — algèbre linéaire paramétrée
mats = [(3, 1), (5, 2), (4, 3), (7, 1), (2, 9), (6, 5), (8, 3), (5, 4), (9, 2), (10, 7)]
for i, (a, b) in enumerate(mats):
    M = sp.Matrix([[a, b], [b, a]])
    val = max(M.eigenvals().keys(), key=lambda e: sp.re(e)) * M.det()
    lg = "en" if i % 2 == 0 else "fr"
    if lg == "en":
        add("matrice", lg, f"For the matrix [[{a},{b}],[{b},{a}]]: compute its eigenvalues, then its "
            f"determinant, then (largest eigenvalue) * determinant.", val)
    else:
        add("matrice", lg, f"Pour la matrice [[{a},{b}],[{b},{a}]] : calcule ses valeurs propres, puis "
            f"son déterminant, puis (plus grande valeur propre) * déterminant.", val)

# F6 — chaînes mixtes b0 → utilisation (propagation d'erreur)
mix = [(3, 2, "en"), (4, 0, "fr"), (5, 6, "en"), (2, 1, "fr"), (6, 3, "en"),
       (3, 5, "fr"), (4, 4, "en"), (5, 2, "fr"), (2, 0, "en"), (6, 6, "fr")]
for N, nf, lg in mix:
    b0 = sp.Rational(11 * N, 3) - sp.Rational(2 * nf, 3)
    val = b0**2 - sp.Rational(N, 2)
    if lg == "en":
        add("chaine", lg, f"Step 1: compute b0 = 11*N/3 - 2*nf/3 for N={N}, nf={nf}. "
            f"Step 2: compute b0**2 - N/2. Give the final value of step 2.", val)
    else:
        add("chaine", lg, f"Étape 1 : calcule b0 = 11*N/3 - 2*nf/3 pour N={N}, nf={nf}. "
            f"Étape 2 : calcule b0**2 - N/2. Donne la valeur finale de l'étape 2.", val)

# auto-test du générateur sur 4 valeurs connues
assert items[0]["cibles"] == ["11"], items[0]
assert any(i["cibles"] == ["40/243"] for i in items if i["famille"] == "integrale"), "int x^5 e^-3x = 5!/3^6 = 40/243"
assert any(i["cibles"] == ["2870"] for i in items if i["famille"] == "somme"), "somme k^2, 20 = 2870"
c2f4 = sp.Rational(15, 8) * 15
assert any(i["cibles"] == [str(c2f4)] for i in items if i["famille"] == "casimir")

with open("./t2_items.jsonl", "w") as f:
    for it in items:
        f.write(json.dumps(it, ensure_ascii=False) + "\n")
print(f"  {len(items)} items écrits ({sum(1 for i in items if i['langue']=='fr')} FR), générateur auto-testé")