Mode Declinaisons QCM/QAT: spec MCQ/FGQ (calibree sur 33 exemples valides), harnais etendu (collisions options multi-graines, arite FGQ, un seul bloc python), filets deterministes (mcqOption, None dernier, fusion blocs), UI mode+types, analyse partagee QCM/QAT, zero regression pythonisation (smoke 45/45)

README_APP.md

@@ -0,0 +1,116 @@
+# Pythonise Exercice — v2
+
+App Flask à deux modes :
+- **Pythonisation** d'exercices PyxiScience MyST (valeurs fixes → randomisées) ;
+- **Déclinaisons** (2026-07) : génération de versions **QCM** (MCQ) et/ou
+  **QAT** (FGQ, champs libres ordonnés) d'un exercice, randomisées elles aussi.
+
+Pipeline async : analyse LLM + notions + RAG (parallèles, **partagés entre QCM
+et QAT**) → génération par paires → audit LLM → filets déterministes → **porte
+harnais** (100 graines + contrôles étendus déclinaisons : unicité des options
+MCQ sur toutes les graines, 1 seule bonne réponse, « None » en dernier, arité
+FGQ, `:solution:` JSON) ; verdict exposé dans l'UI.
+
+## Architecture (refonte 2026-06)
+
+```
+run.py                      Lancement : python run.py   (ou python -m app)
+app/
+├── __init__.py             create_app() + logging + .env
+├── config.py               TOUTE la config : modèles, PYTHON_FENCE_BACKTICKS=4,
+│                           ANALYSIS_MODEL_IDX, RAG_TOP_K, USE_REASONING,
+│                           DEFAULT_LANG, JOB_TTL, chemins, prix
+├── server.py               routes Flask (/, /health, /api/models, /api/jobs)
+├── keys.py                 chargement des clés API (.env)
+├── pipeline/
+│   ├── orchestrator.py     chef d'orchestre (1 exercice)
+│   ├── analyze.py          analyse + notions + RAG en PARALLÈLE
+│   ├── generate.py         découpage + génération par paires
+│   ├── audit.py            audit LLM ≤2 itérations + filet de sécurité patches
+│   ├── postprocess.py      filets déterministes (auto-lift {{}}, ${}, fences 4,
+│   │                       renommage camelCase, décimales/langue, dédoublonnage)
+│   ├── solutions.py        substitution des solutions validées (règle 8.1)
+│   ├── translate.py        langue cible fr/en/both (prose seule, Python masqué)
+│   ├── prompts.py          tous les prompts (v1 archivée dans knowledge/)
+│   └── fewshots.py         sélection d'un exemple canonique par type détecté
+├── rag/                    functions.py (FAISS) · formatter.py · notions.py ·
+│                           catalogue.py (catalogue curé injecté par domaine)
+├── llm/                    client.py (OpenRouter + reasoning opt.) · cost.py
+├── validation/             harness.py (porte qualité) · sandbox.py (exec sandboxée)
+├── knowledge/              pythonisation_rules.md · rules_digest.py ·
+│                           fewshots/ (exemples VERTS) · prompts_v1_archive.md ·
+│                           functions_catalogue.md (catalogue curé des helpers)
+├── corpus/                 5 fichiers de fonctions PyxiScience (RAG)
+└── web/templates/index.html  UI (batch, langue, verdict harnais, coût)
+data/                       notions.xlsx · faiss_cache/
+tests/smoke.py              smoke tests hors-ligne (LLM mocké)
+```
+
+## Installation (WSL Ubuntu)
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install -r requirements.txt        # faiss-cpu + sentence-transformers ≈ 1.5 Go
+cp .env.example .env                   # renseigner OPENROUTER_API_KEY / OPENAI_API_KEY
+python run.py                          # http://127.0.0.1:5000
+```
+
+Smoke tests (sans réseau) : `.venv/bin/python tests/smoke.py`
+Validation d'une sortie : `python ../.claude/skills/validation-harness/harness.py <fichier>.md --seeds 300`
+
+### Endpoints
+
+| Méthode | URL              | Description                                            |
+|---------|------------------|--------------------------------------------------------|
+| GET     | `/`              | UI web                                                 |
+| GET     | `/health`        | sanity check                                           |
+| GET     | `/api/models`    | roster des modèles + défauts                           |
+| POST    | `/api/jobs`      | démarre un job (1 fichier OU batch) → `{job_id}`       |
+| GET     | `/api/jobs/<id>` | suivi + résultats par fichier (harnais, coût, langue)  |
+| GET     | `/api/jobs/<id>/download` | ZIP de toutes les sorties `.md` + `_recapitulatif.md` |
+
+POST body :
+```json
+{
+  "files": [{"filename": "exo.md", "content": "<MyST>"}, ...],
+  "lang": "fr | en | both",
+  "level": "",
+  "model_idx": 1,
+  "mode": "pythonise | declinaisons",
+  "types": {"qcm": true, "qat": true}
+}
+```
+(`mode` absent ⇒ `pythonise`, rétro-compatible ; `types` requis en mode
+`declinaisons`, au moins un `true` — les deux cochés ⇒ 2 fichiers par source,
+nommés `<source>_QCM.md` / `<source>_QAT.md`, avec UNE seule analyse partagée.
+Rétro-compat : `{"content": "...", "filename": "..."}` accepté pour 1 fichier.)
+
+Résultat par fichier : `exercise`, `analysis`, `notions`, `audit_patches`,
+`warnings`, **`harness` {ok, seeds, summary}**, **`lang` {source, target, action}**,
+**`cost` {usd, eur, requests}**, `duration_s`.
+
+**Téléchargement** (UI, panneau Résultat) : bouton **« Télécharger .md »**
+(sortie pythonisée du fichier affiché, suffixe `_pythonise.md` pour ne pas
+écraser la source) ; en **batch**, bouton **« Tout (.zip) »** → ZIP de toutes
+les sorties + un `_recapitulatif.md` (verdict harnais / warnings / coût par fichier).
+
+## Sécurité
+
+🚨 **Les clés API dans `.env` étaient en clair dans le zip d'origine** —
+considère-les comme exposées et **rotate-les** :
+- OpenRouter : https://openrouter.ai/keys
+- OpenAI : https://platform.openai.com/api-keys
+
+La sandbox (`app/validation/sandbox.py`) exécute le code généré par le LLM
+avec builtins restreints, imports whitelistés et timeout (mono-poste : le
+modèle de menace est l'accident LLM, pas un adversaire).
+
+## Notes
+
+- Premier lancement : reconstruit le cache FAISS si absent (≈ 30 s).
+- Modèles (IDs vérifiés sur OpenRouter 2026-06-12) : Opus 4.8, **Sonnet 4.6
+  (défaut)**, Fable 5, Haiku 4.5, Gemini 2.5 Pro, GPT-5.2.
+- L'étape d'analyse suit le modèle choisi par l'utilisateur
+  (`ANALYSIS_MODEL_IDX=None` dans config.py pour ce comportement).
+- Mode batch : fichiers traités séquentiellement ; un échec n'arrête pas les
+  autres ; récapitulatif VERT/ROUGE/erreurs + coût total.

app/config.py

@@ -70,6 +70,12 @@ HARNESS_REPAIR_MAX   = 2         # boucles de réparation LLM si la porte est ro
 # ── Langue cible ─────────────────────────────────────────────────────────────
 DEFAULT_LANG = "fr"              # "fr" | "en" | "both"
 
+# ── Modes (pythonisation / déclinaisons QCM-QAT) ─────────────────────────────
+DEFAULT_MODE = "pythonise"       # "pythonise" | "declinaisons"
+DECLINAISON_TYPES = ("qcm", "qat")
+MCQ_NUM_OPTIONS = 5              # 1 correcte + 3 distracteurs + « None » en dernier
+QAT_FALLBACK_TO_MCQ = True       # question non auto-corrigeable en champ libre → MCQ
+
 # ── Serveur / jobs ───────────────────────────────────────────────────────────
 JOB_TTL = 1800                   # s avant purge d'un job terminé
 # HOST/PORT pilotables par l'environnement (déploiement). En local : 127.0.0.1.

app/knowledge/fewshots/declinaisons/{en}`Domain of`{fr}`Domaine de définition de` $_frac{a + bx}{x^2 - c}$.md

@@ -0,0 +1,84 @@
+`````{exercise}
+:originalExerciseId: 22d960b8-d57e-46d2-8ebd-09d8bed0a1fb
+:title: {en}`Domain of`{fr}`Domaine de définition de` $\frac{a + bx}{x^2 - c}$
+:modules: Analyse_I_EFREI, Calc_1_Pyx
+:recommendedExecutionTime: 0
+:level: Elementary
+:chap: chap_realFunctions_Graphs_functionsFundamentalDefinitions_ESCP, Second_chap_VIII, chap_I_fonction_reel_EFREI, Calculus_I_Functions_and_their_Representations_1_1
+:involvedConcepts: 
+:originalSource: Selin
+:visibility: All
+:variations: 
+:comment: 
+:id: 91465036-709e-11f1-a8a1-0ed8d3b012a9
+
+```{python}
+
+import random as rd
+from sympy import *
+from pyxiscience.Mes_fctions_d_analyse import pxs_config
+
+from pyxiscience.Classes_Extensions import pxs_Interval
+
+config_standard = pxs_config()
+
+import random as rd
+
+x = symbols('x')
+a, b, c = rd.sample(range(1, 10), 3)
+
+
+f_num = (a*x+b)
+f_den =(x**2 - c)
+f = f_num/f_den
+domaine1 = pxs_Interval(-oo, -sqrt(c), True, True)
+domaine2 = pxs_Interval(sqrt(c), +oo, True, True)
+
+# === Ajouts conversion FGQ ===
+b_inf = latex(-sqrt(c))
+b_sup = latex(sqrt(c))
+```
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ b_inf }}$","${{ b_sup }}$"],["0.000001","0.000001"]]
+
+::::{questionStatement}
+{en}`Find the domain of the function`{fr}`Donner le domaine de la fonction` 
+\begin{equation*}
+\ds f(x) = {{ latex(f, **config_standard) }}.
+\end{equation*}
+{en}`The function is defined for every real number except the two values that cancel the denominator. Give these two excluded values`{fr}`La fonction est définie pour tout réel sauf aux deux valeurs qui annulent le dénominateur. Donner ces deux valeurs exclues` $x_1 < x_2$ :
+
+$x_1 =$ {input}`||120` {en}`and`{fr}`et` $x_2 =$ {input}`||120`
+::::
+
+::::{questionHint}
+{en}`A rational function is defined whenever its denominator is not zero. Start by solving`{fr}`Une fonction rationnelle est définie lorsque son dénominateur n’est pas nul. Commencez par résoudre` $x^2-c=0$.
+::::
+
+::::{displayedSolution}
+$x_1 = {{ b_inf }}$ {en}`and`{fr}`et` $x_2 = {{ b_sup }}$
+::::
+
+::::{detailedSolution}
+
+{en}`The denominator cannot be zero, therefore:`{fr}`Le dénominateur doit être différent de zéro :` 
+\begin{equation*}
+{{ latex(f_den, **config_standard) }}\neq 0 \implies x \neq \pm {{ latex(sqrt(c)) }}.
+\end{equation*}
+{en}`Thus we have`{fr}`On a donc`
+\begin{equation*}
+\boxed{
+\text{{en}`Domain:`{fr}`Domaine de définition :` }{{ domaine1.print() }} \cup {{ domaine2.print() }}}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 20
+:logic: 35
+:abstraction: 30
+:calculation: 15
+::::
+:::::
+`````

app/knowledge/fewshots/declinaisons/{en}`Domain of`{fr}`Domaine de définition de` $_sqrt{a - bx}$.md

@@ -0,0 +1,73 @@
+`````{exercise}
+:originalExerciseId: e8559359-32c0-4394-94be-daf9a701cb6a
+:title: {en}`Domain of`{fr}`Domaine de définition de` $\sqrt{a - bx}$
+:modules: Analyse_I_EFREI, Calc_1_Pyx
+:recommendedExecutionTime: 0
+:level: Elementary
+:chap: chap_realFunctions_Graphs_functionsFundamentalDefinitions_ESCP, Second_chap_VIII, chap_I_fonction_reel_EFREI, Calculus_I_Functions_and_their_Representations_1_1
+:involvedConcepts: 
+:originalSource: Selin
+:visibility: All
+:variations: 
+:comment: 
+:id: 8f0a1b0c-709e-11f1-a8a1-0ed8d3b012a9
+
+```{python}
+
+import random as rd
+from sympy import *
+from pyxiscience.Mes_fctions_d_analyse import pxs_config
+from pyxiscience.Classes_Extensions import pxs_Interval
+
+config_standard = pxs_config()
+
+import random as rd
+
+x = symbols('x')
+a, b = rd.sample(range(1, 10), 2)
+
+arg = a - b*x
+f = sqrt(arg)
+
+domaine = pxs_Interval(-oo, Rational(a,b), True, False)
+
+# === Ajouts conversion FGQ ===
+borne = latex(Rational(a, b))
+```
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ borne }}$"],["0.000001"]]
+
+::::{questionStatement}
+{en}`Find the domain of the function`{fr}`Trouver le domaine de définition de la fonction` $f(x) = {{ latex(f) }}$. {en}`Its domain is an interval of the form`{fr}`Son domaine de définition est un intervalle de la forme` $(-\infty,\ \alpha]$. {en}`Give the value of`{fr}`Donner la valeur de` $\alpha$ :
+
+$\alpha =$ {input}`||120`
+::::
+
+::::{questionHint}
+{en}`A square root is defined only when its radicand is nonnegative. Start by solving`{fr}`Une racine carrée est définie seulement lorsque son radical est positif ou nul. Commencez par résoudre` ${{ latex(arg) }} \ge 0$.
+::::
+
+::::{displayedSolution}
+$\alpha = {{ borne }}$
+::::
+
+::::{detailedSolution}
+
+{en}`For the square root to be defined,`{fr}`Pour que la racine carrée soit définie, il faut que` ${{ latex(arg) }}\geq 0$. {en}`Solving for $x$ gives`{fr}`En résolvant l'inéquation, nous obtenons` ${{ a }} \geq {{ latex(b*x) }}$, {en}`or`{fr}`ou` $x \leq {{ latex(Rational(a,b)) }}$. 
+\begin{equation*}
+\boxed{
+\text{{en}`Domain:`{fr}`Domaine :` }{{ domaine.print() }}}.
+\end{equation*}
+
+::::
+
+::::{weightDistribution}
+:reasoning: 30
+:logic: 25
+:abstraction: 30
+:calculation: 15
+::::
+:::::
+`````

app/knowledge/fewshots/declinaisons/{en}`Solution sets for homogeneous and nonhomogeneous systems in $_mathbb{R}^3$`{fr}`Ensembles des solutions pour des systèmes homogènes et inhomogènes de $_mathbb{R}^3$` - MCQ.md

@@ -0,0 +1,373 @@
+`````{exercise}
+:id: 27512f8b-6fb2-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 9cad7853-dc83-4e8f-b06c-dcfc516b66fb
+:title: {en}`Solution sets for homogeneous and nonhomogeneous systems in $\mathbb{R}^3$`{fr}`Ensembles des solutions pour des systèmes homogènes et inhomogènes de $\mathbb{R}^3$` - MCQ
+:modules: Linear_Algebra_Pyx, Linear_Algebra_Trush
+:recommendedExecutionTime: 30
+:level: Elementary
+:chap: section_2_4_linalg_Trush
+:involvedConcepts: 
+:originalSource: 7.4 Ronan
+:visibility: All
+:variations: 
+:comment: 
+
+```{python}
+
+# Code Python : Ecrivez ci-dessous votre code Python
+from __future__ import division
+from pyxiscience.Mes_fctions_d_alg_lineaire_bis import *
+from sympy import *
+import random as rd 
+
+
+
+
+#### Question 1
+
+ 
+n = 3
+p = 3
+
+lam=rd.randint(-9,9)
+nu=rd.randint(-9,9)
+bnn=rd.randint(-9,9)
+while lam==0 or nu==0 or bnn==0:
+    lam=rd.randint(-9,9)
+    nu=rd.randint(-9,9)
+    bnn=rd.randint(-9,9)
+
+A= randmatrixrect(n,p,-9,9)
+B= randmatrixrect(n,1,-9,9)
+
+A[0,0]=1
+A[0,1]=lam
+A[0,2]=nu
+
+for i in range(1,n):
+    for j in range(0,p):
+        A[i,j]=0
+        B[i]=0
+ 
+B[0]=0
+x='x'
+vect_x=Matrix([Symbol(x+'_1')])
+for i in range(p-1):
+    vect_x=vect_x.row_join(Matrix([Symbol(x+'_'+str(i+2))]))
+expr=myst(r""" """,globals(),locals())
+
+if A[0, :].is_zero_matrix:
+    expr += "0"
+# Gère l'affichage du premier terme non nul sans le '+' devant
+if A[0, 0] != 0:
+    expr+=pxsl_ax(A[0,0],vect_x[0], frac = frac)
+    sign="+"
+else:
+    sign=""
+for j in range(1,p):
+    if A[0,j]!=0:
+        expr+=pxsl_ax(A[0,j],vect_x[j],sign, frac = frac)
+        sign="+"
+
+rhs = myst(r"""{{ B[0].p }}/{{ B[0].q }}""", globals(), locals()) if (isinstance(B[i], Rational) and B[0].q != 1 and not frac) else latex(B[0])
+
+expr+=myst(r""" ={{ rhs }}""",globals(),locals())
+
+sys=expr
+
+ 
+Alat=pxsl_matrix(A)
+Blat=pxsl_matrix(B)
+augmentmat1=pxsl_double_matrix(A,B,opt='ext')
+
+ 
+ 
+ 
+soluce1=pxs_gauss_jordan(A.copy(), B.copy(), method = "mat", view = "ext")
+ 
+Ared1=pxsl_double_matrix(soluce1["A"],soluce1["B"],opt='ext')
+ 
+
+
+#### Question 2
+
+B[0]=bnn
+
+x='x'
+vect_x=Matrix([Symbol(x+'_1')])
+for i in range(p-1):
+    vect_x=vect_x.row_join(Matrix([Symbol(x+'_'+str(i+2))]))
+expr=myst(r""" """,globals(),locals())
+
+if A[0, :].is_zero_matrix:
+    expr += "0"
+# Gère l'affichage du premier terme non nul sans le '+' devant
+if A[0, 0] != 0:
+    expr+=pxsl_ax(A[0,0],vect_x[0], frac = frac)
+    sign="+"
+else:
+    sign=""
+for j in range(1,p):
+    if A[0,j]!=0:
+        expr+=pxsl_ax(A[0,j],vect_x[j],sign, frac = frac)
+        sign="+"
+
+rhs = myst(r"""{{ B[0].p }}/{{ B[0].q }}""", globals(), locals()) if (isinstance(B[i], Rational) and B[0].q != 1 and not frac) else latex(B[0])
+
+expr+=myst(r""" ={{ rhs }}""",globals(),locals())
+
+sys2=expr
+
+ 
+Alat=pxsl_matrix(A)
+Blat=pxsl_matrix(B)
+augmentmat2=pxsl_double_matrix(A,B,opt='ext')
+
+ 
+ 
+ 
+soluce2=pxs_gauss_jordan(A.copy(), B.copy(), method = "mat", view = "ext")
+ 
+Ared2=pxsl_double_matrix(soluce2["A"],soluce2["B"],opt='ext')
+ 
+
+
+```
+
+
+ 
+
+
+:::::{question}
+:questionType: MCQ
+:questionId: 1
+:questionIndex: 1
+
+::::{questionStatement}
+{en}`Which of the following best describes the solution set of the equation`{fr}`Laquelle des propositions suivantes décrit le mieux l'ensemble des solutions de l'équation`
+
+\begin{equation}\label{hom}
+{{ sys }}.
+\end{equation}
+::::
+
+::::{questionHint}
+
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{en}`A plane through the origin`{fr}`Un plan passant par l'origine`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`A line through the origin`{fr}`Une droite passant par l'origine`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`The whole space $\mathbb{R}^3$`{fr}`L'espace $\mathbb{R}^3$ tout entier`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`Only the origin $\{0\}$`{fr}`Uniquement l'origine $\{0\}$`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte` {en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+
+{en}`The equation`{fr}`L'équation` ${{ sys }}$ {en}`may be written with an augmented matrix as`{fr}`peut s'écrire sous la forme de matrice augmentée comme`
+\begin{equation*}
+{{ Ared1 }},
+\end{equation*}
+ 
+
+{en}`which is equivalent to the system`{fr}`ce qui est équivalent au système`
+\begin{equation*}
+{{ soluce1["sys"] }}.
+\end{equation*}
+
+{en}`The set of solutions of the equation`{fr}`L'ensemble des solution de l'équation` ${{ sys }}$ {en}`is then`{fr}`est donc`
+\begin{equation*}
+\boxed{ 
+{{ soluce1["span"] }}.
+}
+\end{equation*}
+{en}`Geometrically, the solution set forms a plane in`{fr}`Géométriquement, l'ensemble des solutions forme un plan de` $\mathbb{R}^3.$
+::::
+
+::::{weightDistribution}
+:
+::::
+:::::
+
+
+
+:::::{question}
+:questionType: MCQ
+:questionId: 2
+:questionIndex: 2
+
+::::{questionStatement}
+{en}`Which of the following best describes the solution set of the equation`{fr}`Laquelle des propositions suivantes décrit le mieux l'ensemble des solutions de l'équation`
+\begin{equation}\label{inhom}
+{{ sys2 }}.
+\end{equation}
+::::
+
+::::{questionHint}
+
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{en}`A plane that does not pass through the origin`{fr}`Un plan ne passant pas par l'origine`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`A plane through the origin`{fr}`Un plan passant par l'origine`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`A single point`{fr}`Un unique point`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`The empty set (the equation has no solution)`{fr}`L'ensemble vide (l'équation n'a aucune solution)`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte` {en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+
+{en}`The equation`{fr}`L'équation` ${{ sys2 }}$ {en}`may be written with an augmented matrix as`{fr}`peut s'écrire sous la forme de matrice augmentée comme`
+\begin{equation*}
+{{ Ared2 }},
+\end{equation*}
+ 
+
+{en}`which is equivalent to the system`{fr}`ce qui est équivalent au système`
+\begin{equation*}
+{{ soluce2["sys"] }}.
+\end{equation*}
+
+{en}`The set of solutions of the equation`{fr}`L'ensemble des solution de l'équation` ${{ sys2 }}$ {en}`is then`{fr}`est donc`
+\begin{equation*}
+\boxed{ 
+{{ soluce2["span"] }}.
+}
+\end{equation*}
+{en}`Geometrically, the solution set forms a plane in`{fr}`Géométriquement, l'ensemble des solutions forme un plan de` $\mathbb{R}^3.$
+::::
+
+::::{weightDistribution}
+:
+::::
+:::::
+
+
+
+:::::{question}
+:questionType: MCQ
+:questionId: 3
+:questionIndex: 3
+
+::::{questionStatement}
+{en}`How do the two solution sets compare geometrically?`{fr}`Comment peut-on comparer géométriquement les deux ensembles de solutions ?`
+::::
+
+::::{questionHint}
+
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{en}`They are parallel planes: the nonhomogeneous one is a translate of the homogeneous one`{fr}`Ce sont des plans parallèles : celui du système inhomogène est un translaté de celui du système homogène`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`They are the same plane`{fr}`Ce sont le même plan`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`They are two perpendicular planes`{fr}`Ce sont deux plans perpendiculaires`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`They intersect along a line`{fr}`Ils se coupent selon une droite`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte` {en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+
+{en}`Geometrically, the solution set of the nonhomogeneous equation` [](#inhom) {en}`is a translation by the vector` ${{ Blat }}$ {en}`of the solution set of the homogeneous equation` [](#hom).
+
+
+```{python}
+
+# Code Python : Ecrivez ci-dessous votre code Python
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+
+# Création de la figure et de l'axe 3D
+fig = plt.figure(figsize=(10, 8))
+ax = fig.add_subplot(111, projection='3d')
+
+# Définition des limites pour x et y
+x = np.linspace(-4, 4, 10)
+y = np.linspace(-4, 4, 10)
+X, Y = np.meshgrid(x, y)
+
+# Équation du premier plan : z = a*x + b*y + c
+a, b, c = -1/nu, -lam/nu, 0
+Z1 = a*X + b*Y + c
+
+# Équation du deuxième plan parallèle : z = a*x + b*y + d (d ≠ c)
+d = -bnn/nu
+Z2 = a*X + b*Y + d
+
+# Tracé des deux plans
+ax.plot_surface(X, Y, Z1, alpha=0.5, color='blue', label='Plane (1)')
+ax.plot_surface(X, Y, Z2, alpha=0.5, color='red', label='Plane (2)')
+
+# Ajout des labels et titre
+ax.set_xlabel('$x_1$')
+ax.set_ylabel('$x_2$')
+ax.set_zlabel('$x_3$')
+ax.set_title('The two planes')
+
+# Affichage de la légende
+ax.legend()
+
+plt.show()
+
+```
+::::
+
+::::{weightDistribution}
+:
+::::
+:::::
+`````

app/knowledge/fewshots/declinaisons/{en}`The set of solutions of a homogeneous system`{fr}`Ensemble des solutions d'un système homogène` - MCQ.md

@@ -0,0 +1,133 @@
+`````{exercise}
+:id: e2c3b203-6fb1-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: e5717816-752a-4abf-9afc-55df5774e4e0
+:title: {en}`The set of solutions of a homogeneous system`{fr}`Ensemble des solutions d'un système homogène` - MCQ
+:modules: 
+:recommendedExecutionTime: 30
+:level: Elementary
+:chap: section_2_4_linalg_Trush
+:involvedConcepts: 
+:originalSource: 7.1 Ronan
+:visibility: All
+:variations: 
+:comment: 
+
+````{python}
+# Code Python : Ecrivez ci-dessous votre code Python
+from __future__ import division
+from pyxiscience.Mes_fctions_d_alg_lineaire_bis import *
+from sympy import *
+import random as rd 
+
+
+
+
+systems = []
+
+ 
+n = rd.randint(2,3)
+p = rd.randint(n+1,n+2)
+
+nb_pivots = rd.randint(2, min(n, p))
+pivots = tuple(rd.sample([i for i in range(1, min(n, p) + 1)], nb_pivots))
+A, B = pxs_repeat_generate_sys(n = n, p = p, M = tuple(pivots), N = Matrix([rd.randint(1, 5) for _ in range(n-1)] + [0]), backup = zeros(3, 3))
+if A == zeros(3, 3):
+    A = Matrix([[1, -5, -1, 0], [-2, 10, 1, -4], [0, 0, -1, -4]])
+    B = Matrix([[0, -3, -3]]).T
+    
+A, B = pxs_break_all_colinear_rows(A, B, max_iter=5)
+systems.append((A, B))
+
+B=0*B
+Blat=pxsl_matrix(B)
+Alat=pxsl_matrix(A)
+
+augmentmat=pxsl_double_matrix(A,B,opt='ext')
+
+sys = pxsl_system_lin(A, B)
+
+soluce=pxs_gauss_jordan(A.copy(), B.copy(), method = "mat", view = "ext")
+ 
+Ared=pxsl_double_matrix(soluce["A"],soluce["B"],opt='ext')
+
+
+````
+
+:::::{question}
+:questionType: MCQ
+:questionId: 1
+:questionIndex: 1
+
+::::{questionStatement}
+{en}`Which of the following best describes the solution set of the equation`{fr}`Laquelle des propositions suivantes décrit le mieux l'ensemble des solutions de l'équation` $Ax=0$ {en}`where`{fr}`où`
+\begin{equation*}
+A={{Alat}}?
+\end{equation*}
+::::
+
+::::{questionHint}
+
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{en}`An infinite set of vectors forming a subspace through the origin (the system has infinitely many solutions)`{fr}`Un ensemble infini de vecteurs formant un sous-espace vectoriel passant par l'origine (le système a une infinité de solutions)`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`Only the trivial solution $x=0$`{fr}`Uniquement la solution triviale $x=0$`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`The empty set (the system has no solution)`{fr}`L'ensemble vide (le système n'a aucune solution)`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`A single nonzero vector`{fr}`Un unique vecteur non nul`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte` {en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{en}`The equation `{fr}`L'équation ` $Ax=0$ {en}`may be written with an augmented matrix as `{fr}`peut s'écrire sous la forme de matrice augmentée comme `
+\begin{equation*}
+{{augmentmat}}
+\end{equation*}
+{en}`The Row Reduction Echelon Form of this matrix is`{fr}`La forme échelonnée réduite de cette matrice est `
+\begin{equation*}
+{{Ared}}
+\end{equation*}
+
+:::{dropdown} {en}`See more details`{fr}`Voir plus de détails`
+{en}`We may apply the Row Reduction Algorithm to reduce the augmented matrix: `{fr}`Nous pouvons appliquer l'algorithme de Gauss pour réduire la matrice augmentée :`
+{{soluce["resol"]}}
+:::
+
+{en}`which is equivalent to the system `{fr}`ce qui est équivalent au système`
+\begin{equation*}
+{{soluce["sys"]}}.
+\end{equation*}
+
+{en}`The set of solutions of the equation `{fr}`L'ensemble des solution de l'équation ` $Ax=0$ {en}` is then `{fr}` est donc `
+\begin{equation*}
+\boxed{
+{{soluce["span"]}}.
+
+}
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 25
+:logic: 25
+:abstraction: 25
+:calculation: 25
+::::
+:::::
+`````

app/knowledge/fewshots/declinaisons/{en}`The set of solutions of an inhomogeneous system`{fr}`Ensemble des solutions d'un système inhomogène` - MCQ.md

@@ -0,0 +1,131 @@
+`````{exercise}
+:id: f48b19b6-6fb1-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: d8e6061b-52be-424b-8dc6-45548d0c00ce
+:title: {en}`The set of solutions of an inhomogeneous system`{fr}`Ensemble des solutions d'un système inhomogène` - MCQ
+:modules: 
+:recommendedExecutionTime: 30
+:level: Elementary
+:chap: section_2_4_linalg_Trush
+:involvedConcepts: 
+:originalSource: 7.1 Ronan
+:visibility: All
+:variations: 
+:comment: 
+
+````{python}
+# Code Python : Ecrivez ci-dessous votre code Python
+from __future__ import division
+from pyxiscience.Mes_fctions_d_alg_lineaire_bis import *
+from sympy import *
+import random as rd 
+
+
+
+
+systems = []
+
+ 
+n = rd.randint(2,3)
+p = rd.randint(n+1,n+2)
+
+nb_pivots = rd.randint(2, min(n, p))
+pivots = tuple(rd.sample([i for i in range(1, min(n, p) + 1)], nb_pivots))
+A, B = pxs_repeat_generate_sys(n = n, p = p, M = tuple(pivots), N = Matrix([rd.randint(1, 5) for _ in range(n-1)] + [0]), backup = zeros(3, 3))
+if A == zeros(3, 3):
+    A = Matrix([[1, -5, -1, 0], [-2, 10, 1, -4], [0, 0, -1, -4]])
+    B = Matrix([[0, -3, -3]]).T
+    
+A, B = pxs_break_all_colinear_rows(A, B, max_iter=5)
+systems.append((A, B))
+ 
+Blat=pxsl_matrix(B)
+Alat=pxsl_matrix(A)
+
+augmentmat=pxsl_double_matrix(A,B,opt='ext')
+
+sys = pxsl_system_lin(A, B)
+
+soluce=pxs_gauss_jordan(A.copy(), B.copy(), method = "mat", view = "ext")
+ 
+Ared=pxsl_double_matrix(soluce["A"],soluce["B"],opt='ext')
+
+
+````
+
+:::::{question}
+:questionType: MCQ
+:questionId: 1
+:questionIndex: 1
+
+::::{questionStatement}
+{en}`Which of the following best describes the solution set of the equation`{fr}`Laquelle des propositions suivantes décrit le mieux l'ensemble des solutions de l'équation` $Ax=b$ {en}`where`{fr}`où`
+\begin{equation*}
+A={{Alat}} \quad \textrm{{en}` and `{fr}` et `} \quad b={{Blat}}?
+\end{equation*}
+::::
+
+::::{questionHint}
+
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{en}`An infinite affine set: a particular solution plus all the solutions of $Ax=0$ (in general it does not pass through the origin)`{fr}`Un ensemble affine infini : une solution particulière à laquelle on ajoute toutes les solutions de $Ax=0$ (en général il ne passe pas par l'origine)`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`A subspace through the origin`{fr}`Un sous-espace vectoriel passant par l'origine`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`A single unique solution`{fr}`Une unique solution`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{en}`The empty set (the system has no solution)`{fr}`L'ensemble vide (le système n'a aucune solution)`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte` {en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{en}`The equation `{fr}`L'équation ` $Ax=b$ {en}`may be written with an augmented matrix as `{fr}`peut s'écrire sous la forme de matrice augmentée comme `
+\begin{equation*}
+{{augmentmat}}
+\end{equation*}
+{en}`The Row Reduction Echelon Form of this matrix is`{fr}`La forme échelonnée réduite de cette matrice est `
+\begin{equation*}
+{{Ared}}
+\end{equation*}
+
+:::{dropdown} {en}`See more details`{fr}`Voir plus de détails`
+{en}`We may apply the Row Reduction Algorithm to reduce the augmented matrix: `{fr}`Nous pouvons appliquer l'algorithme de Gauss pour réduire la matrice augmentée :`
+{{soluce["resol"]}}
+:::
+
+{en}`which is equivalent to the system `{fr}`ce qui est équivalent au système`
+\begin{equation*}
+{{soluce["sys"]}}.
+\end{equation*}
+
+{en}`The set of solutions of the equation `{fr}`L'ensemble des solution de l'équation ` $Ax=b$ {en}` is then `{fr}` est donc `
+\begin{equation*}
+\boxed{
+{{soluce["span"]}}.
+}
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 25
+:logic: 25
+:abstraction: 25
+:calculation: 25
+::::
+:::::
+`````

app/knowledge/fewshots/declinaisons/{fr}`Amortissement dégressif d'un équipement`{en}`Declining Balance Depreciation of Equipment`.md

@@ -0,0 +1,189 @@
+`````{exercise}
+:title: {fr}`Amortissement dégressif d'un équipement`{en}`Declining Balance Depreciation of Equipment`
+:modules: 
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: chap_expLogFunctions_exponentialFunctions_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Appliqué (économie & gestion) : valeur résiduelle V(n)=V0·(1−d)^n d'un actif, décroissance exponentielle (base 0,8∈(0,1)) et interprétation.
+:id: c70b202b-74d9-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 773a7c51-6597-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from fractions import Fraction
+from decimal import Decimal, ROUND_HALF_UP
+
+def _grp(ip):
+    neg = ip.startswith('-'); ip = ip.lstrip('-'); g = []
+    while len(ip) > 3:
+        g.insert(0, ip[-3:]); ip = ip[:-3]
+    g.insert(0, ip)
+    return ('-' if neg else '') + '\\,'.join(g)
+
+def money_fr(v, dec=2):
+    f = Fraction(v)
+    d = (Decimal(f.numerator) / Decimal(f.denominator)).quantize(Decimal(1).scaleb(-dec), rounding=ROUND_HALF_UP)
+    s = format(abs(d), 'f'); ip, _, fp = s.partition('.')
+    return ('-' if d < 0 else '') + _grp(ip) + (('{,}' + fp) if dec > 0 else '')
+
+def num_fr(v, maxdec=5):
+    f = Fraction(v)
+    d = (Decimal(f.numerator) / Decimal(f.denominator)).quantize(Decimal(1).scaleb(-maxdec), rounding=ROUND_HALF_UP)
+    s = format(abs(d), 'f'); ip, _, fp = s.partition('.'); fp = fp.rstrip('0')
+    return ('-' if d < 0 else '') + _grp(ip) + (('{,}' + fp) if fp else '')
+
+# Construction déterministe, arithmétique exacte
+V0 = rd.choice([5000, 8000, 10000, 12000, 15000, 18000, 20000])
+taux = rd.choice([Fraction(7, 10), Fraction(3, 4), Fraction(4, 5), Fraction(17, 20), Fraction(9, 10)])
+
+V1val = V0 * taux
+V2val = V0 * taux**2
+V3val = V0 * taux**3
+n5 = rd.randint(4, 7)
+V5val = V0 * taux**n5
+pourcentageRestant = taux**n5 * 100
+pourcentagePerdu = 100 - pourcentageRestant
+
+# Rendus
+V0Aff = money_fr(V0, 0)
+V1Aff = money_fr(V1val, 2)
+V2Aff = money_fr(V2val, 2)
+V3Aff = money_fr(V3val, 2)
+V5valAff = money_fr(V5val, 2)
+tauxAff = num_fr(taux, 2)
+taux2Aff = num_fr(taux**2, 4)
+taux3Aff = num_fr(taux**3, 5)
+n5Aff = str(n5)
+tauxPuissanceN5Aff = num_fr(taux**n5, 5)
+pourcentageRestantAffQ3 = num_fr(pourcentageRestant, 2)
+pourcentagePerduAffQ3 = num_fr(pourcentagePerdu, 2)
+
+# === Ajouts conversion FGQ ===
+def _solnum(s):
+    return s.replace("\\,", "").replace("{,}", ".")
+V0Sol = _solnum(V0Aff)
+V1Sol = _solnum(V1Aff)
+V2Sol = _solnum(V2Aff)
+V3Sol = _solnum(V3Aff)
+V5Sol = _solnum(V5valAff)
+globals()
+````
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["ord","${{ V0Sol }}$","${{ V1Sol }}$","${{ V2Sol }}$","${{ V3Sol }}$"],["0","0","0","0"]]
+
+::::{questionStatement}
+{fr}`Une entreprise acquiert un serveur pour`{en}`A company acquires a server for` ${{ V0Aff }}$ €. {fr}`Sa valeur résiduelle après`{en}`Its residual value after` $n$ {fr}`années est`{en}`years is` $V(n)={{ V0Aff }}\times({{ tauxAff }})^{n}$. {fr}`Calculer`{en}`Calculate` $V(0)$, $V(1)$, $V(2)$ {fr}`et`{en}`and` $V(3)$ {fr}`(valeurs exactes).`{en}`(exact values).`
+
+$V(0) =$ {input}`||80` $\quad V(1) =$ {input}`||80` $\quad V(2) =$ {input}`||80` $\quad V(3) =$ {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Appliquer la formule ; on a`{en}`Apply the formula; we have` $({{ tauxAff }})^{2}={{ taux2Aff }}$ {fr}`et`{en}`and` $({{ tauxAff }})^{3}={{ taux3Aff }}$.
+::::
+
+::::{displayedSolution}
+$V(0) = {{ V0Aff }}$ € $\quad V(1) = {{ V1Aff }}$ € $\quad V(2) = {{ V2Aff }}$ € $\quad V(3) = {{ V3Aff }}$ €
+::::
+
+::::{detailedSolution}
+{fr}`On applique la formule en augmentant`{en}`We apply the formula by increasing` $n$. {fr}`La base élevée à la puissance`{en}`The base raised to the power` $0$ {fr}`vaut`{en}`equals` $1$, {fr}`donc`{en}`so` $V(0)={{ V0Aff }}$. {fr}`Ensuite :`{en}`Then:`
+
+$V(1)={{ V0Aff }}\times{{ tauxAff }}={{ V1Aff }}$, $\quad V(2)={{ V0Aff }}\times{{ taux2Aff }}={{ V2Aff }}$, $\quad V(3)={{ V0Aff }}\times{{ taux3Aff }}={{ V3Aff }}$.
+::::
+
+::::{weightDistribution}
+:logic: 10
+:abstraction: 20
+:reasoning: 25
+:calculation: 45
+::::
+:::::
+
+:::::{question}
+:questionType: MCQ
+:questionId: 1
+:questionIndex: 1
+
+::::{questionStatement}
+{fr}`Déterminer si`{en}`Determine whether` $V$ {fr}`est croissante ou décroissante, et justifier à partir de la base.`{en}`is increasing or decreasing, and justify from the base.`
+::::
+
+::::{questionHint}
+{fr}`La base est`{en}`The base is` ${{ tauxAff }}\in(0,1)$.
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{fr}`Strictement décroissante (base dans $(0,1)$)`{en}`Strictly decreasing (base in $(0,1)$)`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Strictement croissante (base $> 1$)`{en}`Strictly increasing (base $> 1$)`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Constante`{en}`Constant`
+::::
+
+::::{detailedSolution}
+{fr}`La base est`{en}`The base is` $b={{ tauxAff }}\in(0,1)$, {fr}`donc`{en}`so` $V$ {fr}`est strictement décroissante : la valeur du serveur diminue chaque année. On vérifie :`{en}`is strictly decreasing: the server's value decreases each year. We verify:` ${{ V0Aff }}>{{ V1Aff }}>{{ V2Aff }}>{{ V3Aff }}$.
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 35
+:reasoning: 30
+:calculation: 10
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 2
+:questionIndex: 2
+:solution: [["ord","${{ V5Sol }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`Calculer`{en}`Calculate` $V({{ n5Aff }})$ {fr}`(on donne`{en}`(given` $({{ tauxAff }})^{ {{ n5Aff }} }={{ tauxPuissanceN5Aff }}$), {fr}`puis interpréter le résultat dans le contexte de l'entreprise.`{en}`then interpret the result in the company's context.`
+
+$V({{ n5Aff }}) =$ {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Multiplier`{en}`Multiply` ${{ V0Aff }}$ {fr}`par la valeur fournie, puis comparer à la valeur d'achat.`{en}`by the given value, then compare to the purchase value.`
+::::
+
+::::{displayedSolution}
+$V({{ n5Aff }}) = {{ V5valAff }}$ €
+::::
+
+::::{detailedSolution}
+{fr}`On évalue`{en}`We evaluate` $V$ {fr}`en`{en}`at` $n={{ n5Aff }}$ :
+
+\begin{equation*}
+V({{ n5Aff }}) &= {{ V0Aff }} \times {{ tauxPuissanceN5Aff }} \\
+&= {{ V5valAff }}.
+\end{equation*}
+
+{fr}`Après`{en}`After` ${{ n5Aff }}$ {fr}`ans, le serveur ne vaut plus que`{en}`years, the server is only worth` ${{ V5valAff }}$ €, {fr}`soit environ`{en}`which is approximately` ${{ pourcentageRestantAffQ3 }}\,\%$ {fr}`de sa valeur d'achat : l'entreprise a perdu environ`{en}`of its purchase value: the company has lost approximately` ${{ pourcentagePerduAffQ3 }}\,\%$ {fr}`de la valeur de cet actif en`{en}`of the value of this asset in` {{ n5Aff }} {fr}`ans.`{en}`years.`
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 25
+:reasoning: 35
+:calculation: 20
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Capitalisation annuelle contre capitalisation continue`{en}`Annual Compounding versus Continuous Compounding`.md

@@ -0,0 +1,193 @@
+`````{exercise}
+:title: {fr}`Capitalisation annuelle contre capitalisation continue`{en}`Annual Compounding versus Continuous Compounding`
+:modules: 
+:recommendedExecutionTime: 12
+:level: Elementary
+:chap: chap_expLogFunctions_exponentialFunctions_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Appliqué (économie & gestion) : comparaison d'un placement en capitalisation annuelle S=P(1+r)^n et en capitalisation continue S=P·e^(rn), évaluations numériques (e fourni) et interprétation de l'écart.
+:id: daf335a0-74d9-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 5c4c10be-6598-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+import math
+from fractions import Fraction
+from decimal import Decimal, ROUND_HALF_UP
+
+def _grp(ip):
+    neg = ip.startswith('-'); ip = ip.lstrip('-'); g = []
+    while len(ip) > 3:
+        g.insert(0, ip[-3:]); ip = ip[:-3]
+    g.insert(0, ip)
+    return ('-' if neg else '') + '\\,'.join(g)
+
+def money_fr(v, dec=2):
+    f = Fraction(v)
+    d = (Decimal(f.numerator) / Decimal(f.denominator)).quantize(Decimal(1).scaleb(-dec), rounding=ROUND_HALF_UP)
+    s = format(abs(d), 'f'); ip, _, fp = s.partition('.')
+    return ('-' if d < 0 else '') + _grp(ip) + (('{,}' + fp) if dec > 0 else '')
+
+def num_fr(v, maxdec=4):
+    f = Fraction(v)
+    d = (Decimal(f.numerator) / Decimal(f.denominator)).quantize(Decimal(1).scaleb(-maxdec), rounding=ROUND_HALF_UP)
+    s = format(abs(d), 'f'); ip, _, fp = s.partition('.'); fp = fp.rstrip('0')
+    return ('-' if d < 0 else '') + _grp(ip) + (('{,}' + fp) if fp else '')
+
+# Paramètres financiers (déterministe). Annuel exact ; continu approché (e).
+P = rd.choice([5000, 10000, 15000, 20000, 25000, 30000, 40000, 50000])
+n = rd.randint(3, 10)
+rPct = rd.choice([Fraction(2), Fraction(5, 2), Fraction(3), Fraction(7, 2), Fraction(4),
+                  Fraction(9, 2), Fraction(5), Fraction(11, 2), Fraction(6), Fraction(13, 2),
+                  Fraction(7), Fraction(15, 2), Fraction(8)])
+r = rPct / 100
+
+# Placement A : capitalisation annuelle (exact)
+baseComp = 1 + r
+puissance = baseComp ** n
+sA = P * puissance
+
+# Placement B : capitalisation continue (e^(r n), approché)
+exposant = r * n
+expVal = Fraction(math.exp(float(exposant)))
+sB = P * expVal
+ecart = sB - sA
+
+# Rendus
+pAff = money_fr(P, 0)
+nAff = str(n)
+rPctStr = num_fr(rPct, 1)
+baseCompStr = num_fr(baseComp, 4)
+puissanceApproxStr = num_fr(puissance, 4)
+saAff = money_fr(sA, 2)
+exposantContStr = num_fr(exposant, 2)
+expApproxStr = num_fr(expVal, 4)
+sbAff = money_fr(sB, 2)
+ecartAff = money_fr(ecart, 2)
+
+# === Ajouts conversion FGQ ===
+def _solnum(s):
+    return s.replace("\\,", "").replace("{,}", ".")
+saSol = _solnum(saAff)
+sbSol = _solnum(sbAff)
+ecartSol = _solnum(ecartAff)
+globals()
+````
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["ord","${{ saSol }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`Un investisseur place`{en}`An investor invests` ${{ pAff }}$ € {fr}`sur`{en}`over` ${{ nAff }}$ {fr}`ans au taux de`{en}`years at a rate of` ${{ rPctStr }}\,\%$ {fr}`par an. Placement A (capitalisation annuelle) :`{en}`per year. Investment A (annual compounding):`  $S_{A}={{ pAff }}\times({{ baseCompStr }})^{ {{ nAff }} }$. {fr}`Calculer`{en}`Calculate` $S_{A}$ {fr}`(arrondir au centime). On donne`{en}`(round to the nearest cent). We are given` $({{ baseCompStr }})^{ {{ nAff }} }\approx {{ puissanceApproxStr }}$.
+
+$S_{A} =$ {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Multiplier`{en}`Multiply` ${{ pAff }}$ {fr}`par la valeur fournie.`{en}`by the given value.`
+::::
+
+::::{displayedSolution}
+$S_{A} = {{ saAff }}$ €
+::::
+
+::::{detailedSolution}
+{fr}`On applique la formule de capitalisation annuelle :`{en}`We apply the annual compounding formula:`
+
+\begin{equation*}
+S_{A} &= {{ pAff }} \times ({{ baseCompStr }})^{ {{ nAff }} } \approx {{ pAff }} \times {{ puissanceApproxStr }} \\
+&= {{ saAff }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 10
+:abstraction: 15
+:reasoning: 25
+:calculation: 50
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 1
+:questionIndex: 1
+:solution: [["ord","${{ sbSol }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`Placement B (capitalisation continue) :`{en}`Investment B (continuous compounding):` $S_{B}={{ pAff }}\times e^{r\times {{ nAff }}}$ {fr}`où`{en}`where` $r=\dfrac{ {{ rPctStr }} }{100}$, {fr}`avec`{en}`with` $e\approx 2{,}718$. {fr}`Calculer`{en}`Calculate` $S_{B}$ {fr}`(arrondir au centime). On donne`{en}`(round to the nearest cent). We are given` $e^{ {{ exposantContStr }} }\approx {{ expApproxStr }}$.
+
+$S_{B} =$ {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`L'exposant vaut`{en}`The exponent equals` $r\times {{ nAff }}=\dfrac{ {{ rPctStr }} }{100}\times {{ nAff }}={{ exposantContStr }}$ ; {fr}`utiliser`{en}`use` $e^{ {{ exposantContStr }} }\approx {{ expApproxStr }}$.
+::::
+
+::::{displayedSolution}
+$S_{B} = {{ sbAff }}$ €
+::::
+
+::::{detailedSolution}
+{fr}`L'exposant vaut`{en}`The exponent equals` $r\times {{ nAff }}=\dfrac{ {{ rPctStr }} }{100}\times {{ nAff }}={{ exposantContStr }}$, {fr}`donc :`{en}`so:`
+
+\begin{equation*}
+S_{B} &= {{ pAff }} \times e^{ {{ exposantContStr }} } \approx {{ pAff }} \times {{ expApproxStr }} \\
+&= {{ sbAff }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 10
+:abstraction: 20
+:reasoning: 25
+:calculation: 45
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 2
+:questionIndex: 2
+:solution: [["ord","${{ ecartSol }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`Comparer`{en}`Compare` $S_{A}$ {fr}`et`{en}`and` $S_{B}$, {fr}`et interpréter l'écart dans le contexte financier.`{en}`and interpret the difference in the financial context.`
+
+$S_{B} - S_{A} =$ {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Calculer`{en}`Calculate` $S_{B}-S_{A}$.
+::::
+
+::::{displayedSolution}
+$S_{B} - S_{A} = {{ ecartAff }}$ €
+::::
+
+::::{detailedSolution}
+{fr}`On compare les deux montants :`{en}`We compare the two amounts:`
+
+\begin{equation*}
+S_{B} - S_{A} &\approx {{ sbAff }} - {{ saAff }} \\
+&= {{ ecartAff }}.
+\end{equation*}
+
+{fr}`À taux affiché identique (`{en}`At the same stated rate (` ${{ rPctStr }}\,\%$ ), {fr}`la capitalisation continue`{en}`continuous compounding` $S_{B}\approx {{ sbAff }}$ € {fr}`rapporte un peu plus que la capitalisation annuelle`{en}`yields slightly more than annual compounding` $S_{A}\approx {{ saAff }}$ €, {fr}`l'écart étant d'environ`{en}`the difference being approximately` ${{ ecartAff }}$ €. {fr}`La capitalisation continue réinvestit les intérêts à chaque instant, alors que la capitalisation annuelle ne les réinvestit qu'une fois par an.`{en}`Continuous compounding reinvests interest at every instant, whereas annual compounding reinvests it only once per year.`
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 25
+:reasoning: 35
+:calculation: 20
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Contrainte de budget publicitaire`{en}`Advertising budget constraint`.md

@@ -0,0 +1,110 @@
+`````{exercise}
+:originalExerciseId: df9c98f5-633f-11f1-a8a1-0ed8d3b012a9
+:title: {fr}`Contrainte de budget publicitaire`{en}`Advertising budget constraint`
+:modules: 
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: 
+:involvedConcepts: Solving_inequalities, Sets
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Version QCM — contrainte de budget, nombre maximal d'insertions et ensemble admissible.
+:id: 0f2a4c67-6e48-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_format_number
+from pyxiscience.Classes_Extensions import pxs_Interval
+
+config_standard = pxs_config()
+
+# Contrainte : budget multiple du coût d'insertion, nMax entier >= 5
+for _ in range(2000):
+    cout_insertion = rd.choice([40, 50, 60, 80, 100, 120, 150])
+    budget = cout_insertion * rd.randint(10, 50)
+    nMax = budget // cout_insertion
+    if nMax >= 5 and 800 <= budget <= 3000:
+        break
+
+verif_max = cout_insertion * nMax
+verif_exclu = cout_insertion * (nMax + 1)
+
+# Rendus
+budgetAff = pxsl_format_number(budget)
+coutInsertion = cout_insertion
+nMaxPlusUn = nMax + 1
+verifMaxAff = pxsl_format_number(verif_max)
+verifExcluAff = pxsl_format_number(verif_exclu)
+
+# === Distracteurs MCQ (ajouts ; le code ci-dessus est inchangé) ===
+interCorrect = pxs_Interval(0, nMax, False, False).print()
+interD1 = pxs_Interval(0, budget, True, False).print()
+interD2 = pxs_Interval(0, nMax, True, False).print()
+interD3 = pxs_Interval(0, budget, False, False).print()
+
+globals()
+````
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Une start-up dispose d'un budget de communication de`{en}`A start-up has a communication budget of` ${{ budgetAff }}$ €. {fr}`Chaque insertion publicitaire coûte`{en}`Each advertising insertion costs` ${{ coutInsertion }}$ €. {fr}`On note`{en}`Let` $n$ {fr}`le nombre d'insertions. Quel est l'ensemble des valeurs admissibles de`{en}`be the number of insertions. What is the set of admissible values of` $n$ {fr}`en notation intervalle ?`{en}`in interval notation?`
+::::
+
+::::{questionHint}
+{fr}`Traduire la contrainte de budget par`{en}`Translate the budget constraint as` ${{ coutInsertion }}n\leq {{ budgetAff }}$, {fr}`puis diviser par`{en}`then divide by` ${{ coutInsertion }}>0$ {fr}`(sens conservé). Ne pas oublier`{en}`(inequality sign preserved). Do not forget` $n\geq 0$.
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+$S = {{ interCorrect }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ interD1 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ interD2 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ interD3 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`La dépense totale`{en}`The total expenditure` ${{ coutInsertion }}n$ {fr}`ne doit pas dépasser le budget, d'où une inéquation résolue par division par un réel positif.`{en}`must not exceed the budget, hence an inequality solved by division by a positive real number.`
+
+\begin{equation*}
+{{ coutInsertion }}n \leq {{ budgetAff }}&\implies \frac{ {{ coutInsertion }}n }{ {{ coutInsertion }} } \leq \frac{ {{ budgetAff }} }{ {{ coutInsertion }} } \\[10pt]
+&\implies n \leq {{ nMax }}.
+\end{equation*}
+
+{fr}`Comme`{en}`Since` $n$ {fr}`est un nombre d'insertions,`{en}`is a number of insertions,` $n\geq 0$. {fr}`L'ensemble admissible est donc :`{en}`The admissible set is therefore:`
+
+\begin{equation*}
+S = {{pxs_Interval(0, nMax, False, False).print()}}.
+\end{equation*}
+
+{fr}`La start-up peut financer au maximum`{en}`The start-up can finance at most` ${{ nMax }}$ {fr}`insertions.`{en}`insertions.`
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 30
+:calculation: 35
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Discontinuité d'une fraction rationnelle`{en}`Discontinuity of a Rational Fraction`.md

@@ -0,0 +1,81 @@
+`````{exercise}
+:id: ff0cf9ac-7067-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: dd834157-3f2f-11f1-a8a1-0ed8d3b012a9
+:title: {fr}`Discontinuité d'une fraction rationnelle`{en}`Discontinuity of a Rational Fraction`
+:modules: CalcI, Calc_1_Pyx
+:recommendedExecutionTime: 5
+:level: Intermediate
+:chap: chap_limitsContinuity_continuity_ESCP, Calculus_I_Continuity_1_5
+:involvedConcepts: Continuity_at_a_point, Domain_of_function, Rational_Function
+:originalSource: Selin
+:visibility: All
+:variations: 
+:comment: 
+
+```{python}
+import random as rd
+from sympy import *
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config
+from pyxiscience.Classes_Extensions import pxs_Interval
+from pyxiscience.Mes_fctions_d_analyse import pxsl_pow
+from pyxiscience.Mes_fctions_generalistes_bis import pxsl_latex_avec_formatage
+from pyxiscience.Mes_fctions_probabilistes_bis import pxsl_res_num
+
+from pyxiscience.Mes_fctions_generalistes_bis import  pxs_config
+
+config_standard = pxs_config()
+
+x = symbols('x')
+a,b,c,d = rd.sample(range(1, 11), 4)
+p = rd.randint(2, 6)
+q = Rational(1,rd.randint(2, 6))
+f = 1/(a*x+b)
+
+x0 = Rational(-b,a)
+
+l = f.subs(x,x0)
+```
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Pour quelle raison la fonction`{en}`Why is the function` $\ds f(x) = {{latex(f)}}$ {fr}`est-elle discontinue en`{en}`discontinuous at` $\ds a = {{latex(x0)}}$ ?
+::::
+
+::::{questionHint}
+{fr}`Évaluer le dénominateur de la fonction au point indiqué.`{en}`Evaluate the denominator of the function at the given point.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{fr}`Car $\ds f\left({{latex(x0)}}\right)$ n'est pas définie : le dénominateur s'annule en $\ds {{latex(x0)}}$.`{en}`Because $\ds f\left({{latex(x0)}}\right)$ is undefined: the denominator vanishes at $\ds {{latex(x0)}}$.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Car le numérateur s'annule en $\ds {{latex(x0)}}$.`{en}`Because the numerator vanishes at $\ds {{latex(x0)}}$.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Car $\ds \lim_{x \to {{latex(x0)}}} f(x) = 0$.`{en}`Because $\ds \lim_{x \to {{latex(x0)}}} f(x) = 0$.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Car $f$ n'est pas dérivable en $\ds {{latex(x0)}}$, bien qu'elle y soit continue.`{en}`Because $f$ is not differentiable at $\ds {{latex(x0)}}$, although it is continuous there.`
+::::
+
+::::{detailedSolution}
+{fr}`La fonction est discontinue en`{en}`The function is discontinuous at` $\ds a = {{latex(x0)}}$ {fr}`car`{en}`because` $\ds f\left({{latex(x0)}}\right)$ {fr}`n'est pas définie (le dénominateur devient zéro).`{en}`is undefined (the denominator becomes zero).`
+::::
+
+::::{weightDistribution}
+:reasoning: 35
+:logic: 25
+:abstraction: 20
+:calculation: 20
+::::
+:::::
+`````

app/knowledge/fewshots/declinaisons/{fr}`Formule générale du seuil de rentabilité`{en}`General Break-Even Point Formula`.md

@@ -0,0 +1,261 @@
+`````{exercise}
+:title: {fr}`Formule générale du seuil de rentabilité`{en}`General Break-Even Point Formula`
+:modules: 
+:recommendedExecutionTime: 15
+:level: Elementary
+:chap: chap_lines_Systems_economicEquilibriumBreakeven_ESCP
+:involvedConcepts: 
+:originalSource: Session 4 — Erwan Lamy, ESCP Business School
+:visibility: All
+:variations: 
+:comment: Synthèse (gestion) : établissement de la formule q* = yFC/(p - c), condition p > c, application numérique et analyse de sensibilité aux coûts fixes.
+:id: 60088df7-74c0-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 27f935cf-64e3-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+# --- Helpers PyxiScience (definis inline, autonomes : aucun import externe) ---
+def pxs_config():
+    return {}
+def pxsl_format_number(n):
+    f = float(n)
+    if abs(f - round(f)) < 1e-9:
+        return "%d" % round(f)
+    s = ("%.10f" % f).rstrip("0").rstrip(".")
+    return s.replace(".", "{,}")
+def pxsl_latex_coefficient(coef, ones=False, sign=False):
+    coef = int(coef)
+    if coef == 0:
+        return "+0" if sign else "0"
+    if not ones:
+        if coef == 1:
+            return "+" if sign else ""
+        if coef == -1:
+            return "-"
+    if sign:
+        return ("+%d" % coef) if coef > 0 else ("%d" % coef)
+    return "%d" % coef
+lc = pxsl_latex_coefficient
+config_standard = pxs_config()
+
+# Contraintes : p > c (marge strictement positive, et p - c >= 2 pour eviter un
+# denominateur d'affichage egal a 1) ; yFc et yFcNouv multiples de (p - c) pour
+# des seuils entiers ; yFcNouv > yFc.
+for _ in range(2000):
+    p = rd.randint(15, 25)
+    c = rd.randint(4, 10)
+    diff = p - c
+    if diff < 2:
+        continue
+    multFc = [k * diff for k in range(1, 200) if 240 <= k * diff <= 480]
+    multFcNouv = [k * diff for k in range(1, 200) if 480 <= k * diff <= 720]
+    if not (multFc and multFcNouv):
+        continue
+    yFc = rd.choice(multFc)
+    candNouv = [x for x in multFcNouv if x > yFc]
+    if not candNouv:
+        continue
+    yFcNouv = rd.choice(candNouv)
+    break
+
+qStarNum = yFc // diff
+qStarNouv = yFcNouv // diff
+augmentation = qStarNouv - qStarNum
+
+# --- Affichage precalcule ---
+qStarAff = r"\dfrac{y_{FC}}{p - c}"
+yFcAff = pxsl_format_number(yFc)
+yFcNouvAff = pxsl_format_number(yFcNouv)
+pMinusCAff = str(diff)
+qStarNumAff = str(qStarNum)
+qStarNouvAff = str(qStarNouv)
+augmentationAff = str(augmentation)
+
+globals()
+````
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Une entreprise vend un produit au prix unitaire`{en}`A company sells a product at unit price` $p${fr}`, avec un coût variable unitaire`{en}`, with a unit variable cost` $c$ {fr}`(avec`{en}`(with` $c < p${fr}`) et des coûts fixes`{en}`) and fixed costs` $y_{FC}${fr}`. Écrire le revenu total`{en}`. Write the total revenue` $y_{TR}(q)$ {fr}`et le coût total`{en}`and the total cost` $y_{TC}(q)${fr}`.`{en}`.`
+::::
+
+::::{questionHint}
+{fr}`Reprendre les définitions générales du revenu et du coût total.`{en}`Use the general definitions of revenue and total cost.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+$y_{TR}(q) = p\,q$ {fr}`et`{en}`and` $y_{TC}(q) = c\,q + y_{FC}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$y_{TR}(q) = p\,q + y_{FC}$ {fr}`et`{en}`and` $y_{TC}(q) = c\,q$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$y_{TR}(q) = (p-c)\,q$ {fr}`et`{en}`and` $y_{TC}(q) = c\,q + y_{FC}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$y_{TR}(q) = p\,q$ {fr}`et`{en}`and` $y_{TC}(q) = c\,q$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`Par définition :`{en}`By definition:`
+
+\begin{equation*}
+y_{TR}(q) = p\,q, \qquad y_{TC}(q) = c\,q + y_{FC}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 30
+:reasoning: 30
+:calculation: 20
+::::
+:::::
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`En résolvant`{en}`By solving` $y_{TR}(q) = y_{TC}(q)${fr}`, établir la formule générale du seuil`{en}`, establish the general break-even formula` $q^{*} = \dfrac{y_{FC}}{p - c}${fr}`. Justifier pourquoi la condition`{en}`. Justify why the condition` $p > c$ {fr}`est nécessaire.`{en}`is necessary.`
+::::
+
+::::{questionHint}
+{fr}`Regrouper les termes en`{en}`Group the terms in` $q${fr}`, factoriser par`{en}`, factor by` $q${fr}`, puis diviser par`{en}`, then divide by` $p - c${fr}`.`{en}`.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+$q^{*} = \dfrac{y_{FC}}{p-c}$, {fr}`valable si`{en}`valid if` $p > c$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$q^{*} = \dfrac{y_{FC}}{p+c}$, {fr}`valable si`{en}`valid if` $p > c$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$q^{*} = \dfrac{y_{FC}}{c-p}$, {fr}`valable si`{en}`valid if` $c > p$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$q^{*} = \dfrac{p-c}{y_{FC}}$, {fr}`valable si`{en}`valid if` $p > c$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`On résout`{en}`We solve` $y_{TR}(q) = y_{TC}(q)$ {fr}`:`{en}`:`
+
+\begin{equation*}
+p\,q = c\,q + y_{FC} \implies (p - c)\,q = y_{FC}.
+\end{equation*}
+
+{fr}`Comme`{en}`Since` $p > c${fr}`, on a`{en}`, we have` $p - c > 0${fr}`, et la division est licite :`{en}`, and the division is valid:`
+
+\begin{equation*}
+q^{*} = {{qStarAff}}.
+\end{equation*}
+
+{fr}`La condition`{en}`The condition` $p > c$ {fr}`est nécessaire : si`{en}`is necessary: if` $p \leq c${fr}`, alors`{en}`, then` $p - c \leq 0$ {fr}`et l'équation`{en}`and the equation` $(p - c)\,q = y_{FC}$ {fr}`n'a pas de solution positive (car`{en}`has no positive solution (since` $y_{FC} > 0${fr}`). L'entreprise ne pourrait jamais couvrir ses coûts fixes.`{en}`). The company could never cover its fixed costs.`
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 30
+:reasoning: 35
+:calculation: 10
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ qStarNumAff }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`Une boutique d'accessoires vend des coques de téléphone à`{en}`An accessories shop sells phone cases at` $p = {{p}}$ {fr}`€, avec`{en}`€, with` $c = {{c}}$ {fr}`€ et`{en}`€ and` $y_{FC} = {{yFcAff}}$ {fr}`€/mois. Appliquer la formule pour trouver`{en}`€/month. Apply the formula to find` $q^{*}${fr}`.`{en}`.`\
+\
+$q^{*}$ = {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Remplacer directement dans`{en}`Substitute directly into` $q^{*} = \dfrac{y_{FC}}{p - c}${fr}`.`{en}`.`
+::::
+
+::::{displayedSolution}
+$q^{*} = {{ qStarNumAff }}$
+::::
+
+::::{detailedSolution}
+{fr}`On applique la formule :`{en}`We apply the formula:`
+
+\begin{equation*}
+q^{*} = \dfrac{ {{yFcAff}} }{ {{p}} - {{c}} } = \dfrac{ {{yFcAff}} }{ {{pMinusCAff}} } = {{qStarNumAff}} \text{ {fr}`unités/mois`{en}`units/month`}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 25
+:calculation: 40
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 3
+:questionIndex: 3
+:solution: [["ord","${{ augmentationAff }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`Si les coûts fixes passent à`{en}`If the fixed costs increase to` $y_{FC} = {{yFcNouvAff}}$ {fr}`€ (nouveau bail), de combien d'unités le seuil augmente-t-il ? Interpréter le résultat.`{en}`€ (new lease), by how many units does the break-even point increase? Interpret the result.`\
+\
+{fr}`Augmentation du seuil (unités/mois) :`{en}`Increase in break-even (units/month):` {input}`||80`.
+::::
+
+::::{questionHint}
+{fr}`Recalculer`{en}`Recalculate` $q^{*}$ {fr}`avec le nouveau`{en}`with the new` $y_{FC}${fr}`, puis faire la différence.`{en}`, then compute the difference.`
+::::
+
+::::{displayedSolution}
+{fr}`Augmentation :`{en}`Increase:` ${{ augmentationAff }}$
+::::
+
+::::{detailedSolution}
+{fr}`Avec`{en}`With` $y_{FC} = {{yFcNouvAff}}$ {fr}`€ :`{en}`€:`
+
+\begin{equation*}
+q^{*} = \dfrac{ {{yFcNouvAff}} }{ {{pMinusCAff}} } = {{qStarNouvAff}} \text{ {fr}`unités/mois`{en}`units/month`}.
+\end{equation*}
+
+{fr}`Le seuil augmente de`{en}`The break-even point increases by` ${{qStarNouvAff}} - {{qStarNumAff}} = {{augmentationAff}}$ {fr}`unités : la boutique doit vendre`{en}`units: the shop must sell` {{augmentationAff}} {fr}`coques de plus chaque mois uniquement pour absorber le loyer plus élevé, sans gagner de profit supplémentaire.`{en}`more cases each month just to absorb the higher rent, without earning any additional profit.`
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 25
+:reasoning: 30
+:calculation: 25
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Intérêts composés _ calcul d'un capital futur`{en}`Compound Interest_ Future Capital Calculation`.md

@@ -0,0 +1,196 @@
+`````{exercise}
+:title: {fr}`Intérêts composés : calcul d'un capital futur`{en}`Compound Interest: Future Capital Calculation`
+:modules: 
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: chap_expLogFunctions_exponentialFunctions_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Appliqué (économie & gestion) : capitalisation annuelle S(n)=P(1+r)^n, évaluation à plusieurs dates et monotonie (base 1,03>1).
+:id: 9378268f-74d9-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 7265a5b6-6597-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from fractions import Fraction
+from decimal import Decimal, ROUND_HALF_UP
+
+def _grp(ip):
+    neg = ip.startswith('-'); ip = ip.lstrip('-'); g = []
+    while len(ip) > 3:
+        g.insert(0, ip[-3:]); ip = ip[:-3]
+    g.insert(0, ip)
+    return ('-' if neg else '') + '\\,'.join(g)
+
+def money_fr(v, dec=2):
+    f = Fraction(v)
+    d = (Decimal(f.numerator) / Decimal(f.denominator)).quantize(Decimal(1).scaleb(-dec), rounding=ROUND_HALF_UP)
+    s = format(abs(d), 'f'); ip, _, fp = s.partition('.')
+    return ('-' if d < 0 else '') + _grp(ip) + (('{,}' + fp) if dec > 0 else '')
+
+def num_fr(v, maxdec=4):
+    f = Fraction(v)
+    d = (Decimal(f.numerator) / Decimal(f.denominator)).quantize(Decimal(1).scaleb(-maxdec), rounding=ROUND_HALF_UP)
+    s = format(abs(d), 'f'); ip, _, fp = s.partition('.'); fp = fp.rstrip('0')
+    return ('-' if d < 0 else '') + _grp(ip) + (('{,}' + fp) if fp else '')
+
+# Construction déterministe, arithmétique exacte (Fraction)
+P = rd.choice([3000, 4000, 5000, 6000, 7000, 8000, 10000])
+rPourcent = rd.choice([Fraction(2), Fraction(5, 2), Fraction(3), Fraction(7, 2),
+                       Fraction(4), Fraction(9, 2), Fraction(5)])
+base = 1 + rPourcent / 100
+nLong = rd.randint(8, 15)
+
+S0 = Fraction(P)
+S1 = P * base
+S2 = P * base**2
+SNLong = P * base**nLong
+
+# Rendus
+PAff = money_fr(P, 0)
+rPourcentAff = num_fr(rPourcent, 2)
+baseAff = num_fr(base, 4)
+baseMonoAff = num_fr(base, 2)
+nLongAff = str(nLong)
+baseCarreAff = num_fr(base**2, 4)
+basePuissNLongAff = num_fr(base**nLong, 4)
+s0Aff = money_fr(S0, 2)
+s1Aff = money_fr(S1, 2)
+s2Aff = money_fr(S2, 2)
+sNLongAff = money_fr(SNLong, 2)
+
+# === Ajouts conversion FGQ ===
+def _solnum(s):
+    return s.replace("\\,", "").replace("{,}", ".")
+PSol = _solnum(PAff)
+s1Sol = _solnum(s1Aff)
+s2Sol = _solnum(s2Aff)
+sNLongSol = _solnum(sNLongAff)
+globals()
+````
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["ord","${{ PSol }}$","${{ s1Sol }}$","${{ s2Sol }}$"],["0","0","0"]]
+
+::::{questionStatement}
+{fr}`Un épargnant place`{en}`A saver invests` ${{ PAff }}$ € {fr}`à un taux annuel de`{en}`at an annual rate of` ${{ rPourcentAff }}\,\%$, {fr}`capitalisation annuelle :`{en}`annual compounding:` $S(n)={{ PAff }}\times({{ baseAff }})^{n}$. {fr}`Calculer`{en}`Calculate` $S(0)$, $S(1)$ {fr}`et`{en}`and` $S(2)$, {fr}`puis interpréter`{en}`then interpret` $S(0)$.
+
+$S(0) =$ {input}`||80` $\qquad S(1) =$ {input}`||80` $\qquad S(2) =$ {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Appliquer la formule avec`{en}`Apply the formula with` $n=0,1,2$ ; {fr}`rappeler que toute base élevée à la puissance`{en}`recall that any base raised to the power` $0$ {fr}`vaut`{en}`equals` $1$.
+::::
+
+::::{displayedSolution}
+$S(0) = {{ PAff }}$ € $\qquad S(1) = {{ s1Aff }}$ € $\qquad S(2) = {{ s2Aff }}$ €
+::::
+
+::::{detailedSolution}
+{fr}`On applique la formule. Pour`{en}`We apply the formula. For` $n=0$, {fr}`la base élevée à la puissance`{en}`the base raised to the power` $0$ {fr}`vaut`{en}`equals` $1$, {fr}`donc`{en}`so` $S(0)={{ PAff }}$.
+
+\begin{equation*}
+S(1) &= {{ PAff }} \times {{ baseAff }} \\
+&= {{ s1Aff }}.
+\end{equation*}
+
+\begin{equation*}
+S(2) &= {{ PAff }} \times ({{ baseAff }})^{2} \\
+&= {{ PAff }} \times {{ baseCarreAff }} \\
+&= {{ s2Aff }}.
+\end{equation*}
+
+$S(0)={{ PAff }}$ € {fr}`est le capital initial : aucun intérêt n'a encore été versé.`{en}`is the initial capital: no interest has been paid yet.`
+::::
+
+::::{weightDistribution}
+:logic: 10
+:abstraction: 20
+:reasoning: 25
+:calculation: 45
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 1
+:questionIndex: 1
+:solution: [["ord","${{ sNLongSol }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`Calculer`{en}`Calculate` $S({{ nLongAff }})$. {fr}`On donne`{en}`We are given` $({{ baseAff }})^{ {{ nLongAff }} }\approx {{ basePuissNLongAff }}$.
+
+$S({{ nLongAff }}) =$ {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Multiplier`{en}`Multiply` ${{ PAff }}$ {fr}`par la valeur fournie.`{en}`by the provided value.`
+::::
+
+::::{displayedSolution}
+$S({{ nLongAff }}) = {{ sNLongAff }}$ €
+::::
+
+::::{detailedSolution}
+{fr}`En utilisant la valeur fournie :`{en}`Using the provided value:`
+
+\begin{equation*}
+S({{ nLongAff }}) &= {{ PAff }} \times ({{ baseAff }})^{ {{ nLongAff }} } \approx {{ PAff }} \times {{ basePuissNLongAff }} \\
+&= {{ sNLongAff }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 10
+:abstraction: 15
+:reasoning: 25
+:calculation: 50
+::::
+:::::
+
+:::::{question}
+:questionType: MCQ
+:questionId: 2
+:questionIndex: 2
+
+::::{questionStatement}
+{fr}`Déterminer si`{en}`Determine whether` $S$ {fr}`est croissante ou décroissante, et justifier à partir de la base.`{en}`is increasing or decreasing, and justify from the base.`
+::::
+
+::::{questionHint}
+{fr}`La base est`{en}`The base is` ${{ baseMonoAff }}>1$.
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{fr}`Strictement croissante (base $> 1$)`{en}`Strictly increasing (base $> 1$)`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Strictement décroissante (base $< 1$)`{en}`Strictly decreasing (base $< 1$)`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Constante`{en}`Constant`
+::::
+
+::::{detailedSolution}
+{fr}`La base est`{en}`The base is` $b={{ baseMonoAff }}>1$, {fr}`donc`{en}`so` $S$ {fr}`est strictement croissante : le capital augmente chaque année. C'est cohérent avec`{en}`is strictly increasing: the capital increases each year. This is consistent with` ${{ s0Aff }}<{{ s1Aff }}<{{ s2Aff }}<\dots<{{ sNLongAff }}$.
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 35
+:reasoning: 30
+:calculation: 10
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Inéquation linéaire en deux étapes`{en}`Linear Inequality in Two Steps`.md

@@ -0,0 +1,94 @@
+`````{exercise}
+:title: {fr}`Inéquation linéaire en deux étapes`{en}`Linear Inequality in Two Steps`
+:modules: 
+:recommendedExecutionTime: 6
+:level: Elementary
+:chap: chap_equations_Inequalities_linearInequalitiesIntervals_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Échauffement : résolution en deux étapes (addition puis division par un réel positif), ensemble solution en intervalle, borne exclue.
+:originalExerciseId: d40ec55f-633f-11f1-a8a1-0ed8d3b012a9
+:id: e8a23848-7098-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from sympy import oo
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_latex_coefficient as lc
+from pyxiscience.Classes_Extensions import pxs_Interval
+
+config_standard = pxs_config()
+
+# Contrainte : (c - b) divisible par a pour une solution entière
+a = rd.randint(2, 9)
+k = rd.randint(2, 9)
+somme  = k * a
+b = rd.randint(-15, -1)
+c = somme + b
+
+x_sol = somme // a
+x_test_exclu = x_sol
+x_test_inclus = x_sol + 1
+verif_exclu = a * x_test_exclu + b
+verif_inclus = a * x_test_inclus + b
+intervalAff = pxs_Interval(x_sol, oo, True, True).print()
+
+# Rendus
+aAff = lc(a)
+bSignAff = lc(b, ones=True, sign=True)
+negBAff = str(-b)
+xSol = x_sol
+xTestExclu = x_test_exclu
+xTestInclus = x_test_inclus
+verifExclu = verif_exclu
+verifInclus = verif_inclus
+
+globals()
+````
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ xSol }}$","$+\infty$"],["0","0"]]
+
+::::{questionStatement}
+{fr}`Résoudre l'inéquation`{en}`Solve the inequality` ${{ aAff }}x {{ bSignAff }} > {{ c }}$ {fr}`et soit`{en}`and let` $S$ {fr}`son ensemble solution. Écrire`{en}`be its solution set. Write` $S$ {fr}`sous forme d'intervalle (choisir le crochet adapté au caractère strict ou large de l'inégalité) :`{en}`as an interval (choose the bracket matching the strict or non-strict nature of the inequality):`
+
+$S =$ {select}`[|]||]||45` {input}`||120` $;$ {input}`||120` {select}`]|[||[||45`
+::::
+
+::::{questionHint}
+{fr}`Isoler`{en}`Isolate` $x$ {fr}`en deux étapes : ajouter`{en}`in two steps: add` ${{ negBAff }}${fr}`, puis diviser par`{en}`, then divide by` ${{ a }} > 0$ {fr}`(le sens est conservé).`{en}`(the inequality sign is preserved).`
+::::
+
+::::{displayedSolution}
+$S = \left] {{ xSol }} ;\ +\infty \right[$
+::::
+
+::::{detailedSolution}
+{fr}`L'addition puis la division par un réel strictement positif conserve le sens de l'inégalité.`{en}`Addition followed by division by a strictly positive real number preserves the inequality sign.`
+
+\begin{equation*}
+{{ aAff }}x {{ bSignAff }} + {{ negBAff }} > {{ c }} + {{ negBAff }} &\implies {{ aAff }}x > {{ somme }}\\[10pt]
+&\implies \frac{ {{ aAff }}x }{ {{ a }} } > \frac{ {{ somme }} }{ {{ a }} } \\[10pt]
+&\implies x > {{ xSol }}.
+\end{equation*}
+
+{fr}`L'ensemble des solutions est donc`{en}`The solution set is therefore`
+
+\begin{equation*}
+S = {{ intervalAff }}.
+\end{equation*}
+
+{fr}`La borne`{en}`The bound` ${{ xSol }}$ {fr}`est exclue (inégalité stricte`{en}`is excluded (strict inequality` $>${fr}`), d'où la parenthèse ouverte.`{en}`), hence the open parenthesis.`
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 30
+:calculation: 35
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Inéquation linéaire en une étape et notation intervalle`{en}`One-step linear inequality and interval notation`.md

@@ -0,0 +1,150 @@
+`````{exercise}
+:title: {fr}`Inéquation linéaire en une étape et notation intervalle`{en}`One-step linear inequality and interval notation`
+:modules: 
+:recommendedExecutionTime: 5
+:level: Elementary
+:chap: 
+:involvedConcepts: Interval_Notation, Solving_inequalities
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Échauffement : résolution d'une inéquation en une étape (règle d'addition), écriture de l'ensemble solution en notation intervalle et statut de la borne.
+:originalExerciseId: cdbe79e9-633f-11f1-a8a1-0ed8d3b012a9
+:id: 6fef6add-6e40-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from sympy import oo
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_latex_coefficient as lc
+from pyxiscience.Classes_Extensions import pxs_Interval
+
+config_standard = pxs_config()
+
+# Tirage des paramètres
+a = rd.choice([i for i in range(-10, 11) if i != 0])
+b = rd.randint(-20, 20)
+signe = rd.choice(['\\leq', '\\geq', '<', '>'])
+
+# Solution de x + a (signe) b  ->  x (signe) b - a
+sol = b - a
+stricte = signe in ['<', '>']
+
+if signe == '\\leq':
+    intervalAff = pxs_Interval(-oo, sol, True, False).print()
+    valVraie, valFausse = sol, sol + 1
+elif signe == '\\geq':
+    intervalAff = pxs_Interval(sol, oo, False, True).print()
+    valVraie, valFausse = sol, sol - 1
+elif signe == '<':
+    intervalAff = pxs_Interval(-oo, sol, True, True).print()
+    valVraie, valFausse = sol - 1, sol
+else:  # '>'
+    intervalAff = pxs_Interval(sol, oo, True, True).print()
+    valVraie, valFausse = sol + 1, sol
+
+
+if pxs_lang == "fr":
+    borneStatutAff = "exclue" if stricte else "incluse"
+    inegaliteTypeAff = "stricte" if stricte else "large"
+    crochetAff = "ouvert" if stricte else "fermé"
+else:
+    borneStatutAff = "excluded" if stricte else "included"
+    inegaliteTypeAff = "strict" if stricte else "non-strict"
+    crochetAff = "open" if stricte else "closed"
+
+infiniAff = "-\\infty" if signe in ['\\leq', '<'] else "+\\infty"
+
+# Rendus
+aSignAff = lc(a, ones=True, sign=True)
+negASignAff = lc(-a, ones=True, sign=True)
+verifVraieGauche = valVraie + a
+verifFausseGauche = valFausse + a
+solLineAff = f"x {aSignAff} {negASignAff} {signe} {b} {negASignAff} \\implies x {signe} {sol}"
+
+globals()
+
+
+# ═══════════════ Ajouts conversion QCM (distracteurs) ═══════════════
+from sympy import oo as _oo
+_sol2 = b + a   # erreur arithmétique : b + a au lieu de b - a
+if signe == '\\leq':
+    distInt1 = pxs_Interval(-_oo, sol, True, True).print()
+    distInt2 = pxs_Interval(sol, _oo, False, True).print()
+    distInt3 = pxs_Interval(-_oo, _sol2, True, False).print()
+elif signe == '\\geq':
+    distInt1 = pxs_Interval(sol, _oo, True, True).print()
+    distInt2 = pxs_Interval(-_oo, sol, True, False).print()
+    distInt3 = pxs_Interval(_sol2, _oo, False, True).print()
+elif signe == '<':
+    distInt1 = pxs_Interval(-_oo, sol, True, False).print()
+    distInt2 = pxs_Interval(sol, _oo, True, True).print()
+    distInt3 = pxs_Interval(-_oo, _sol2, True, True).print()
+else:
+    distInt1 = pxs_Interval(sol, _oo, False, True).print()
+    distInt2 = pxs_Interval(-_oo, sol, True, True).print()
+    distInt3 = pxs_Interval(_sol2, _oo, True, True).print()
+````
+
+:::::{question}
+:questionType: MCQ
+:questionId: 0
+:questionIndex: 0
+
+::::{questionStatement}
+{fr}`Résoudre l'inéquation`{en}`Solve the inequality` $x{{ aSignAff }} {{ signe }} {{ b }}$, {fr}`écrire l'ensemble solution en notation intervalle et préciser si la borne obtenue est incluse ou exclue.`{en}`write the solution set in interval notation and specify whether the obtained bound is included or excluded.`
+::::
+
+::::{questionHint}
+{fr}`Soustraire`{en}`Subtract` ${{ a }}$ {fr}`des deux membres : ajouter ou soustraire un même réel conserve le sens de l'inégalité (règle d'addition).`{en}`from both sides: adding or subtracting the same real number preserves the direction of the inequality (addition rule).`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+$S = {{ intervalAff }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ distInt1 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ distInt2 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ distInt3 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`Additionner ou soustraire ne change pas le sens de l'inégalité.`{en}`Adding or subtracting does not change the direction of the inequality.`
+
+\begin{equation*}
+{{ solLineAff }}.
+\end{equation*}
+
+{fr}`L'ensemble des solutions est`{en}`The solution set is`
+
+\begin{equation*}
+S = {{ intervalAff }}.
+\end{equation*}
+
+{fr}`La borne`{en}`The bound` ${{ sol }}$ {fr}`est`{en}`is` {{ borneStatutAff }} ({fr}`inégalité`{en}`inequality` {{ inegaliteTypeAff }} ${{ signe }}$), {fr}`d'où le crochet`{en}`hence the bracket is` {{ crochetAff }}. {fr}`Le symbole`{en}`The symbol` ${{ infiniAff }}$ {fr}`n'est pas un réel donc la parenthèse ouverte est obligatoire.`{en}`is not a real number so the open parenthesis is mandatory.`
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 30
+:calculation: 35
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Lecture graphique du sens de variation et des extremums`{en}`Graphical reading of monotonicity and extrema`.md

@@ -0,0 +1,218 @@
+`````{exercise}
+:originalExerciseId: a6a3c85d-689a-11f1-a8a1-0ed8d3b012a9
+:title: {fr}`Lecture graphique du sens de variation et des extremums`{en}`Graphical reading of monotonicity and extrema`
+:modules: fund_of_math_I_ESCP
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: chap_extremaCurveSketching_monotonicityRelativeExtrema_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Échauffement (thème pur) : lecture sur une courbe des intervalles de croissance/décroissance, du minimum et du maximum, et comparaison de deux images par la monotonie. Aucune dérivée.
+:id: e2835bb5-74b2-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+# ──────────────────────────────────────────────────────────────────────────
+# MÉTHODE CONSTRUCTIVE — partir de la réponse (les extremums et la structure)
+# ──────────────────────────────────────────────────────────────────────────
+# On veut une fonction continue sur [xMin, xMax] avec :
+#   - un minimum global en (x2, y2)
+#   - un maximum global en (x3, y3)
+#   - décroissante sur [xMin, x2], croissante sur [x2, x3], décroissante sur [x3, xMax]
+#
+# On tire d'abord les extremums (la réponse), puis on place les points de départ
+# et d'arrivée de manière cohérente (y1 et y4 entre le min et le max).
+
+xMin = rd.randint(-6, -3)
+xMax = rd.randint(4, 7)
+
+# Abscisses des extremums : x2 < x3
+x2 = rd.randint(xMin + 2, xMin + 4)
+x3 = rd.randint(x2 + 2, xMax - 2) if xMax - 2 >= x2 + 2 else x2 + 2
+
+# Valeurs des extremums (la réponse)
+y2 = rd.randint(-3, -1)  # minimum
+y3 = rd.randint(3, 5)    # maximum
+
+minVal = y2
+maxVal = y3
+
+# Points de départ et d'arrivée : ordonnées entre min et max
+y1 = rd.randint(2, 4)  # au-dessus du min, en dessous du max
+y4 = rd.randint(0, 2)  # idem
+
+# Points remarquables pour le tracé
+x1 = xMin
+x4 = xMax
+
+# Question 3 : comparaison par monotonie sur l'intervalle de croissance [x2, x3]
+# On tire xComp1 < xComp2 dans cet intervalle -> f(xComp1) < f(xComp2)
+xComp1 = rd.randint(x2 + 1, x3 - 2) if x3 - x2 > 2 else x2 + 1
+xComp2 = x3
+# ──────────────────────────────────────────────────────────────────────────
+# MÉTHODE CONSTRUCTIVE — partir de la réponse (la comparaison par monotonie)
+# ──────────────────────────────────────────────────────────────────────────
+# La réponse attendue est : f(xComp1) < f(xComp2) car f est croissante sur [x2, x3]
+# et xComp1 < xComp2 appartiennent à cet intervalle.
+#
+# Les variables xMin, xMax, x2, x3, y2, y3, minVal, maxVal, xComp1, xComp2
+# sont déjà définies dans le bloc précédent. On les réutilise pour construire
+# l'énoncé de cette question.
+
+# === Ajouts conversion FGQ ===
+minValSolAff = str(minVal)
+x2SolAff = str(x2)
+maxValSolAff = str(maxVal)
+x3SolAff = str(x3)
+globals()
+````
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`La figure ci-dessous représente la courbe d'une fonction`{en}`The figure below represents the curve of a function` $f$ {fr}`définie sur`{en}`defined on` $[{{ xMin }}\,;\,{{ xMax }}]$. {fr}`Lire les intervalles sur lesquels`{en}`Read the intervals on which` $f$ {fr}`est croissante, puis ceux sur lesquels`{en}`is increasing, then those on which` $f$ {fr}`est décroissante.`{en}`is decreasing.`
+
+```{python}
+import matplotlib.pyplot as plt
+import numpy as np
+
+def bez(p0, p1, p2, p3, t):
+    return (1-t)**3*p0 + 3*(1-t)**2*t*p1 + 3*(1-t)*t**2*p2 + t**3*p3
+
+t = np.linspace(0, 1, 60)
+fig, ax = plt.subplots(figsize=(6, 4.5))
+segments = [((x1, y1), (x1+1, (y1+y2)/2), (x2-1, y2+0.5), (x2, y2)),
+            ((x2, y2), ((x2+x3)/2, (y2+y3)/2), (x3-1, y3-0.5), (x3, y3)),
+            ((x3, y3), (x3+1, (y3+y4)/2), (x4-1, y4+0.5), (x4, y4))]
+for P0, C1, C2, P1 in segments:
+    ax.plot(bez(P0[0], C1[0], C2[0], P1[0], t), bez(P0[1], C1[1], C2[1], P1[1], t),
+            color="#1f77b4", linewidth=2)
+pts = [(x1, y1, "right", "bottom"), (x2, y2, "left", "top"),
+       (x3, y3, "left", "bottom"), (x4, y4, "left", "top")]
+for px, py, ha, va in pts:
+    ax.plot(px, py, "o", color="red", markersize=5)
+    ax.annotate(f"$({px}\\,;\\,{py})$", (px, py), textcoords="offset points",
+                xytext=(6 if ha == "left" else -6, 6 if va == "bottom" else -10),
+                ha=ha, fontsize=9)
+ax.axhline(0, color="k", linewidth=0.8)
+ax.axvline(0, color="k", linewidth=0.8)
+ax.set_xticks(range(xMin, xMax+1))
+ax.set_yticks(range(y2, y3+1))
+ax.set_xlabel("$x$")
+ax.set_ylabel("$y$")
+ax.grid(True, alpha=0.3)
+plt.show()
+```
+::::
+
+::::{questionHint}
+{fr}`Lire les intervalles de croissance (courbe montante) et de décroissance (courbe descendante) directement sur la courbe.`{en}`Read the intervals of increase (rising curve) and decrease (falling curve) directly from the curve.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{fr}`Croissante sur`{en}`Increasing on` $[{{ x2 }}\,;\,{{ x3 }}]$ {fr}`; décroissante sur`{en}`; decreasing on` $[{{ xMin }}\,;\,{{ x2 }}]$ {fr}`et`{en}`and` $[{{ x3 }}\,;\,{{ xMax }}]$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Décroissante sur`{en}`Decreasing on` $[{{ x2 }}\,;\,{{ x3 }}]$ {fr}`; croissante sur`{en}`; increasing on` $[{{ xMin }}\,;\,{{ x2 }}]$ {fr}`et`{en}`and` $[{{ x3 }}\,;\,{{ xMax }}]$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Croissante sur tout`{en}`Increasing on the whole` $[{{ xMin }}\,;\,{{ xMax }}]$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`La courbe descend de`{en}`The curve falls from` $x={{ xMin }}$ {fr}`à`{en}`to` $x={{ x2 }}$ : $f$ {fr}`est décroissante sur`{en}`is decreasing on` $[{{ xMin }}\,;\,{{ x2 }}]$. {fr}`Elle monte de`{en}`It rises from` $x={{ x2 }}$ {fr}`à`{en}`to` $x={{ x3 }}$ : $f$ {fr}`est croissante sur`{en}`is increasing on` $[{{ x2 }}\,;\,{{ x3 }}]$. {fr}`Elle redescend de`{en}`It falls again from` $x={{ x3 }}$ {fr}`à`{en}`to` $x={{ xMax }}$ : $f$ {fr}`est décroissante sur`{en}`is decreasing on` $[{{ x3 }}\,;\,{{ xMax }}]$.
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 25
+:reasoning: 35
+:calculation: 25
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ minValSolAff }}$","${{ x2SolAff }}$","${{ maxValSolAff }}$","${{ x3SolAff }}$"],["0","0","0","0"]]
+
+::::{questionStatement}
+{fr}`Lire le minimum et le maximum de`{en}`Read the minimum and maximum of` $f$ {fr}`sur`{en}`on` $[{{ xMin }}\,;\,{{ xMax }}]$, {fr}`et préciser les abscisses où ils sont atteints.`{en}`and specify the abscissas where they are attained.`
+
+{fr}`minimum`{en}`minimum` $=$ {input}`||60` {fr}`atteint en`{en}`attained at` $x =$ {input}`||60` {fr}`; maximum`{en}`; maximum` $=$ {input}`||60` {fr}`atteint en`{en}`attained at` $x =$ {input}`||60`
+::::
+
+::::{questionHint}
+{fr}`Repérer le point le plus bas et le point le plus haut de la courbe.`{en}`Identify the lowest point and the highest point of the curve.`
+::::
+
+::::{displayedSolution}
+{fr}`minimum`{en}`minimum` $= {{ minVal }}$ {fr}`atteint en`{en}`attained at` $x = {{ x2 }}$ ; {fr}`maximum`{en}`maximum` $= {{ maxVal }}$ {fr}`atteint en`{en}`attained at` $x = {{ x3 }}$
+::::
+
+::::{detailedSolution}
+{fr}`Le point le plus bas est`{en}`The lowest point is` $({{ x2 }}\,;\,{{ minVal }})$ : {fr}`le minimum de`{en}`the minimum of` $f$ {fr}`sur`{en}`on` $[{{ xMin }}\,;\,{{ xMax }}]$ {fr}`est`{en}`is` ${{ minVal }}$, {fr}`atteint en`{en}`attained at` $x={{ x2 }}$. {fr}`Le point le plus haut est`{en}`The highest point is` $({{ x3 }}\,;\,{{ maxVal }})$ : {fr}`le maximum est`{en}`the maximum is` ${{ maxVal }}$, {fr}`atteint en`{en}`attained at` $x={{ x3 }}$.
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 25
+:reasoning: 35
+:calculation: 25
+::::
+:::::
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Justifier, à partir du sens de variation, que`{en}`Justify, from the monotonicity, that` $f({{ xComp1 }}) < f({{ xComp2 }})$.
+::::
+
+::::{questionHint}
+{fr}`Observer que`{en}`Observe that` ${{ xComp1 }}$ {fr}`et`{en}`and` ${{ xComp2 }}$ {fr}`appartiennent au même intervalle de croissance.`{en}`belong to the same interval of increase.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{fr}`$f$ est croissante sur`{en}`$f$ is increasing on` $[{{ x2 }}\,;\,{{ x3 }}]$ {fr}`qui contient`{en}`which contains` ${{ xComp1 }}$ {fr}`et`{en}`and` ${{ xComp2 }}$, {fr}`et`{en}`and` ${{ xComp1 }}<{{ xComp2 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`$f$ est décroissante sur cet intervalle`{en}`$f$ is decreasing on this interval`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`$f$ est constante sur cet intervalle`{en}`$f$ is constant on this interval`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`On a`{en}`We have` ${{ xComp1 }}<{{ xComp2 }}$, {fr}`et`{en}`and` $f$ {fr}`est croissante sur`{en}`is increasing on` $[{{ x2 }}\,;\,{{ x3 }}]$, {fr}`intervalle qui contient`{en}`an interval that contains` ${{ xComp1 }}$ {fr}`et`{en}`and` ${{ xComp2 }}$. {fr}`Par définition de la croissance,`{en}`By definition of increasing function,` ${{ xComp1 }}<{{ xComp2 }}$ {fr}`entraîne`{en}`implies` $f({{ xComp1 }})<f({{ xComp2 }})$.
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 30
+:reasoning: 35
+:calculation: 10
+::::
+:::::
+`````

app/knowledge/fewshots/declinaisons/{fr}`Monotonie selon la base et comparaison de valeurs`{en}`Monotonicity according to base and comparison of values`.md

@@ -0,0 +1,157 @@
+`````{exercise}
+:title: {fr}`Monotonie selon la base et comparaison de valeurs`{en}`Monotonicity according to base and comparison of values`
+:modules: 
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: chap_expLogFunctions_exponentialFunctions_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Échauffement (thème pur) : reconnaissance de la monotonie de quatre fonctions b^x d'après la base, et comparaison de valeurs par la monotonie (sans calcul exact).
+:id: 73274236-74d8-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 699e40c5-6597-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from fractions import Fraction
+
+def frac_latex(fr):
+    fr = Fraction(fr)
+    if fr.denominator == 1:
+        return str(fr.numerator)
+    sign = '-' if fr.numerator < 0 else ''
+    return sign + r'\dfrac{%d}{%d}' % (abs(fr.numerator), fr.denominator)
+
+# Construction déterministe : monotonies garanties par les intervalles des bases.
+b1 = rd.randint(2, 5)                       # base entière > 1 -> croissante
+b2Den = rd.randint(2, 5)
+b2 = Fraction(1, b2Den)                     # base dans (0,1) -> décroissante
+b3Den = rd.randint(2, 5)
+b3Num = rd.randint(b3Den + 1, 9)
+b3 = Fraction(b3Num, b3Den)                 # base > 1 -> croissante
+b4Dec = rd.randint(6, 9)
+b4 = Fraction(b4Dec, 10)                    # base décimale dans (0,1) -> décroissante
+
+# Exposants pour Q2 (>= 2 pour éviter les exposants 0 et 1)
+x1 = rd.randint(2, 4)
+x2 = rd.randint(x1 + 2, x1 + 4)
+
+# Rendus
+b1Aff = str(b1)
+b2Aff = frac_latex(b2)
+b3Aff = frac_latex(b3)
+b4Aff = '0{,}%d' % b4Dec
+x1Aff = str(x1)
+x2Aff = str(x2)
+f1x1Aff = frac_latex(b1**x1)
+f1x2Aff = frac_latex(b1**x2)
+f2x1Aff = frac_latex(b2**x1)
+f2x2Aff = frac_latex(b2**x2)
+
+globals()
+````
+
+:::::{question}
+:questionType: MCQ
+:questionId: 0
+:questionIndex: 0
+
+::::{questionStatement}
+{fr}`On considère`{en}`Consider` $f_{1}(x)={{ b1Aff }}^{x}$, $f_{2}(x)=\left({{ b2Aff }}\right)^{x}$, $f_{3}(x)=\left({{ b3Aff }}\right)^{x}$ {fr}`et`{en}`and` $f_{4}(x)=({{ b4Aff }})^{x}$. {fr}`Reconnaître lesquelles sont strictement croissantes et lesquelles sont strictement décroissantes, en justifiant à partir de la base.`{en}`Identify which are strictly increasing and which are strictly decreasing, justifying from the base.`
+::::
+
+::::{questionHint}
+{fr}`Si`{en}`If` $b>1$ {fr}`: croissante ; si`{en}`: increasing; if` $0<b<1$ {fr}`: décroissante.`{en}`: decreasing.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{fr}`$f_{1}$ et $f_{3}$ strictement croissantes ; $f_{2}$ et $f_{4}$ strictement décroissantes`{en}`$f_{1}$ and $f_{3}$ strictly increasing; $f_{2}$ and $f_{4}$ strictly decreasing`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`$f_{1}$ et $f_{2}$ strictement croissantes ; $f_{3}$ et $f_{4}$ strictement décroissantes`{en}`$f_{1}$ and $f_{2}$ strictly increasing; $f_{3}$ and $f_{4}$ strictly decreasing`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`$f_{2}$ et $f_{4}$ strictement croissantes ; $f_{1}$ et $f_{3}$ strictement décroissantes`{en}`$f_{2}$ and $f_{4}$ strictly increasing; $f_{1}$ and $f_{3}$ strictly decreasing`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Les quatre fonctions sont strictement croissantes`{en}`All four functions are strictly increasing`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+$f_{1}$ {fr}`: base`{en}`: base` ${{ b1Aff }}>1$, {fr}`strictement croissante.`{en}`strictly increasing.` $f_{2}$ {fr}`: base`{en}`: base` ${{ b2Aff }}\in(0,1)$, {fr}`strictement décroissante.`{en}`strictly decreasing.` $f_{3}$ {fr}`: base`{en}`: base` ${{ b3Aff }}>1$, {fr}`strictement croissante.`{en}`strictly increasing.` $f_{4}$ {fr}`: base`{en}`: base` ${{ b4Aff }}\in(0,1)$, {fr}`strictement décroissante.`{en}`strictly decreasing.`
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 35
+:reasoning: 30
+:calculation: 10
+::::
+:::::
+
+:::::{question}
+:questionType: MCQ
+:questionId: 1
+:questionIndex: 1
+
+::::{questionStatement}
+{fr}`Comparer`{en}`Compare` $f_{1}({{ x1Aff }})$ {fr}`et`{en}`and` $f_{1}({{ x2Aff }})$, {fr}`puis`{en}`then` $f_{2}({{ x1Aff }})$ {fr}`et`{en}`and` $f_{2}({{ x2Aff }})$, {fr}`sans calculer les valeurs exactes.`{en}`without calculating the exact values.`
+::::
+
+::::{questionHint}
+{fr}`Utiliser la monotonie :`{en}`Use monotonicity:` ${{ x1Aff }}<{{ x2Aff }}$.
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+$f_{1}({{ x1Aff }}) < f_{1}({{ x2Aff }})$ {fr}`et`{en}`and` $f_{2}({{ x1Aff }}) > f_{2}({{ x2Aff }})$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$f_{1}({{ x1Aff }}) > f_{1}({{ x2Aff }})$ {fr}`et`{en}`and` $f_{2}({{ x1Aff }}) < f_{2}({{ x2Aff }})$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$f_{1}({{ x1Aff }}) < f_{1}({{ x2Aff }})$ {fr}`et`{en}`and` $f_{2}({{ x1Aff }}) < f_{2}({{ x2Aff }})$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$f_{1}({{ x1Aff }}) > f_{1}({{ x2Aff }})$ {fr}`et`{en}`and` $f_{2}({{ x1Aff }}) > f_{2}({{ x2Aff }})$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+$f_{1}$ {fr}`est strictement croissante et`{en}`is strictly increasing and` ${{ x1Aff }}<{{ x2Aff }}$, {fr}`donc`{en}`so` $f_{1}({{ x1Aff }})<f_{1}({{ x2Aff }})$ ({fr}`soit`{en}`i.e.` ${{ b1Aff }}^{ {{ x1Aff }} }<{{ b1Aff }}^{ {{ x2Aff }} }$, {fr}`c'est-à-dire`{en}`that is` ${{ f1x1Aff }}<{{ f1x2Aff }}$).\
+\
+$f_{2}$ {fr}`est strictement décroissante et`{en}`is strictly decreasing and` ${{ x1Aff }}<{{ x2Aff }}$, {fr}`donc`{en}`so` $f_{2}({{ x1Aff }})>f_{2}({{ x2Aff }})$ ({fr}`soit`{en}`i.e.` $\left({{ b2Aff }}\right)^{ {{ x1Aff }} }>\left({{ b2Aff }}\right)^{ {{ x2Aff }} }$, {fr}`c'est-à-dire`{en}`that is` ${{ f2x1Aff }}>{{ f2x2Aff }}$).
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 30
+:reasoning: 35
+:calculation: 10
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Objectif de revenu`{en}`Income Target`.md

@@ -0,0 +1,163 @@
+`````{exercise}
+:originalExerciseId: 3fb67117-634b-11f1-a8a1-0ed8d3b012a9
+:title: {fr}`Objectif de revenu`{en}`Income Target`
+:modules: 
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: 
+:involvedConcepts: Solving_inequalities, Modeling_with_Functions  
+:originalSource: Session 2: Equations and Inequalities - Applications of Linear Inequalities (Erwan Lamy, ESCP Business School)
+:visibility: All
+:variations: 
+:comment: Version QCM — inéquation « au moins », résolution et intervalle.
+:id: b3ceb29c-6e47-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_format_number
+from pyxiscience.Classes_Extensions import pxs_Interval
+
+config_standard = pxs_config()
+
+# Tarif horaire (multiple de 5) et heures cibles ; revenu = rate * hMin (entier)
+rate = rd.choice([50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 110, 120, 125, 150])
+hMin = rd.randint(15, 50)
+target = rate * hMin
+
+# Précalcul de l'affichage
+rateAff = pxsl_format_number(rate)
+hMinAff = pxsl_format_number(hMin)
+targetAff = pxsl_format_number(target)
+
+inter = pxs_Interval(hMin, 168, False, False)
+
+# === Distracteurs MCQ (ajouts ; le code ci-dessus est inchangé) ===
+from sympy import oo
+interCorrect = inter.print()
+interD1 = pxs_Interval(hMin, 168, True, True).print()
+interD2 = pxs_Interval(0, hMin, False, False).print()
+interD3 = pxs_Interval(hMin, oo, False, True).print()
+
+globals()
+````
+
+{fr}`Une consultante indépendante facture`{en}`An independent consultant charges` ${{rateAff}}$ € {fr}`de l'heure. Elle souhaite que son revenu hebdomadaire soit d'au moins`{en}`per hour. She wants her weekly income to be at least` ${{targetAff}}$ €. {fr}`On note`{en}`Let` $h$ {fr}`le nombre d'heures travaillées par semaine.`{en}`be the number of hours worked per week.`
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Quelle inéquation traduit son objectif de revenu ?`{en}`Which inequality represents her income target?`
+::::
+
+::::{questionHint}
+{fr}`« Au moins » se traduit par`{en}`"At least" translates to` $\geq$. {fr}`Son revenu hebdomadaire est`{en}`Her weekly income is` ${{rateAff}}\,h$.
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+${{rateAff}}\,h \geq {{targetAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{rateAff}}\,h \leq {{targetAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{rateAff}}\,h = {{targetAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{targetAff}}\,h \geq {{rateAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{targetAff}}\,h \leq {{rateAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`Le revenu hebdomadaire est`{en}`The weekly income is` ${{rateAff}}\,h$ {fr}`euros. L'objectif « revenu`{en}`euros. The target "income` $\geq {{targetAff}}$ {fr}`» donne :`{en}`" gives:`
+
+\begin{equation*}
+{{rateAff}}\,h \geq {{targetAff}}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 30
+:reasoning: 35
+:calculation: 20
+::::
+:::::
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Résoudre l'inéquation`{en}`Solve the inequality` ${{rateAff}}\,h \geq {{targetAff}}$ {fr}`(sachant qu'une semaine compte 168 heures). Quel est l'ensemble des solutions sous forme d'intervalle ?`{en}`(knowing a week has 168 hours). What is the solution set in interval form?`
+::::
+
+::::{questionHint}
+{fr}`Diviser les deux membres par`{en}`Divide both sides by` ${{rateAff}}$, {fr}`qui est positif : le sens de l'inégalité est conservé.`{en}`which is positive: the inequality sign is preserved.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+${{interCorrect}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{interD1}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{interD2}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{interD3}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`On divise les deux membres par`{en}`We divide both sides by` ${{rateAff}} > 0$ {fr}`(sens conservé) :`{en}`(sign preserved):`
+
+\begin{equation*}
+h \geq \dfrac{ {{targetAff}} }{ {{rateAff}} } = {{hMinAff}}.
+\end{equation*}
+
+{fr}`L'ensemble des solutions est :`{en}`The solution set is:`
+
+\begin{equation*}
+h \in {{inter.print()}}.
+\end{equation*}
+
+{fr}`**Conclusion.** La consultante doit travailler au moins`{en}`**Conclusion.** The consultant must work at least` ${{hMinAff}}$ {fr}`heures par semaine pour atteindre son objectif de revenu. Elle ne peut pas travailler plus de 168 heures car cela correspond au nombre d'heures dans une semaine.`{en}`hours per week to reach her income target. She cannot work more than 168 hours as this corresponds to the number of hours in a week.`
+::::
+
+::::{weightDistribution}
+:logic: 10
+:abstraction: 15
+:reasoning: 25
+:calculation: 50
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Plafond budgétaire`{en}`Budget cap`.md

@@ -0,0 +1,154 @@
+`````{exercise}
+:originalExerciseId: ccace217-633f-11f1-a8a1-0ed8d3b012a9
+:title: {fr}`Plafond budgétaire`{en}`Budget cap`
+:modules: 
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: 
+:involvedConcepts: Solving_inequalities
+:originalSource: Session 2: Equations and Inequalities - Applications of Linear Inequalities (Erwan Lamy, ESCP Business School)
+:visibility: All
+:variations: 
+:comment: Version QCM — contrainte « ne pas dépasser », résolution et intervalle.
+:id: c8218be2-6e47-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config
+from pyxiscience.Classes_Extensions import pxs_Interval
+
+config_standard = pxs_config()
+
+# Tirage aléatoire des paramètres
+for _ in range(200):
+    budget = rd.randint(80, 200)
+    spent = rd.randint(20, budget - 10)
+    if spent < budget:
+        break
+
+# Calcul de la solution
+xMax = budget - spent
+
+# === Distracteurs MCQ (ajouts ; le code ci-dessus est inchangé) ===
+from sympy import oo
+interCorrect = pxs_Interval(0, xMax, False, False).print()
+interD1 = pxs_Interval(0, xMax, True, True).print()
+interD2 = pxs_Interval(0, budget, False, False).print()
+interD3 = pxs_Interval(xMax, oo, False, True).print()
+
+globals()
+````
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Une étudiante dispose d'un budget hebdomadaire de {{budget}} € pour son alimentation. Elle a déjà dépensé {{spent}} € cette semaine. On note $x$ le montant supplémentaire (en euros) qu'elle peut encore dépenser. Quelle inéquation traduit que sa dépense totale ne doit pas dépasser {{budget}} € ?`{en}`A student has a weekly budget of €{{budget}} for food. She has already spent €{{spent}} this week. Let $x$ denote the additional amount (in euros) she may still spend. Which inequality expresses that her total spending must not exceed €{{budget}}?`
+::::
+
+::::{questionHint}
+{fr}`« Ne doit pas dépasser » se traduit par $\leq$. La dépense totale est ${{spent}} + x$.`{en}`"Must not exceed" translates to $\leq$. The total spending is ${{spent}} + x$.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+${{spent}} + x \leq {{budget}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{spent}} + x \geq {{budget}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{spent}} + x = {{budget}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{budget}} + x \leq {{spent}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`La dépense totale est ${{spent}} + x$ euros. La contrainte « dépense totale $\leq {{budget}}$ » donne :`{en}`The total spending is ${{spent}} + x$ euros. The constraint "total spending $\leq {{budget}}$" gives:`
+
+\begin{equation*}
+{{spent}} + x \leq {{budget}}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 30
+:reasoning: 35
+:calculation: 20
+::::
+:::::
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Résoudre l'inéquation ${{spent}} + x \leq {{budget}}$ (on rappelle que $x \geq 0$ puisque $x$ est un montant). Quel est l'ensemble des solutions sous forme d'intervalle ?`{en}`Solve the inequality ${{spent}} + x \leq {{budget}}$ (recall that $x \geq 0$ since $x$ is an amount of money). What is the solution set as an interval?`
+::::
+
+::::{questionHint}
+{fr}`Soustraire {{spent}} aux deux membres : ajouter ou retrancher une constante ne change pas le sens de l'inégalité.`{en}`Subtract {{spent}} from both sides: adding or subtracting a constant does not change the direction of the inequality.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+${{interCorrect}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{interD1}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{interD2}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{interD3}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`On soustrait {{spent}} aux deux membres (le sens est conservé) :`{en}`Subtract {{spent}} from both sides (the direction is preserved):`
+
+\begin{equation*}
+x \leq {{budget}} - {{spent}} = {{xMax}}.
+\end{equation*}
+
+{fr}`Comme $x \geq 0$, l'ensemble des solutions est :`{en}`Since $x \geq 0$, the solution set is:`
+
+\begin{equation*}
+x \in {{pxs_Interval(0, xMax, False, False).print()}}.
+\end{equation*}
+
+{fr}`**Conclusion.** L'étudiante peut encore dépenser au plus {{xMax}} € cette semaine.`{en}`**Conclusion.** The student may spend at most €{{xMax}} more this week.`
+::::
+
+::::{weightDistribution}
+:logic: 10
+:abstraction: 15
+:reasoning: 25
+:calculation: 50
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Prix admissible entre marge minimale et plafond réglementaire`{en}`Admissible price between minimum margin and regulatory ceiling`.md

@@ -0,0 +1,213 @@
+`````{exercise}
+:originalExerciseId: 95586bb6-6340-11f1-a8a1-0ed8d3b012a9
+:title: {fr}`Prix admissible entre marge minimale et plafond réglementaire`{en}`Admissible price between minimum margin and regulatory ceiling`
+:modules: 
+:recommendedExecutionTime: 20
+:level: Elementary
+:chap: 
+:involvedConcepts: upp_and_low, Interval_Notation, Solving_inequalities
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Version QCM — borne inférieure (marge) puis encadrement/intervalle semi-ouvert.
+:id: e5eb824f-6e47-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+import math
+from sympy import Rational
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxs_nvirgzero
+from pyxiscience.Classes_Extensions import pxs_Interval
+
+config_standard = pxs_config()
+
+def rat_fr(r):
+    r = Rational(r)
+    if r.q == 1:
+        return str(r.p)
+    d, twos, fives = r.q, 0, 0
+    while d % 2 == 0:
+        d //= 2; twos += 1
+    while d % 5 == 0:
+        d //= 5; fives += 1
+    assert d == 1, f"décimale non finie : {r}"
+    k = max(twos, fives)
+    scaled = (r.p * 10**k) // r.q
+    sign = '-' if scaled < 0 else ''
+    s = str(abs(scaled)).rjust(k + 1, '0')
+    intpart, frac = s[:-k], s[-k:].rstrip('0')
+    return sign + intpart + ('{,}' + frac if frac else '')
+
+# Coût d'achat et taux de marge (rationnels exacts)
+for _ in range(2000):
+    c = rd.randint(20, 100)
+    pct = rd.choice([15, 20, 25, 30, 35, 40, 45, 50])
+    taux_marge = Rational(pct, 100)
+    coeff_marge = 1 + taux_marge
+    borneInf = c * coeff_marge
+    lo = math.ceil(borneInf)
+    if lo + 5 <= 150:
+        plafond = rd.randint(lo + 5, 150)
+        break
+
+p_exemple = (lo + plafond) // 2
+
+# Rendus
+tauxPct = pct
+tauxMargeAff = rat_fr(taux_marge)
+coeffMargeAff = rat_fr(coeff_marge)
+borneInfAff = rat_fr(borneInf)
+pExemple = p_exemple
+encadrAff = f"{borneInfAff} \\leq p < {plafond}"
+if pxs_lang == "fr":
+    SAff = pxs_Interval(pxs_nvirgzero(float(borneInf)), plafond, False, True).print().replace(".",",")
+else:
+    SAff = pxs_Interval(pxs_nvirgzero(float(borneInf)), plafond, False, True).print()
+
+# === Distracteurs MCQ (ajouts ; le code ci-dessus est inchangé) ===
+def _dedl(correct_l, cands, n=3):
+    seen = {correct_l}; out = []
+    for s in cands:
+        if s not in seen:
+            seen.add(s); out.append(s)
+        if len(out) == n:
+            break
+    return out
+
+# Q0 : borne inférieure
+repBI = borneInfAff
+_cand = [Rational(c), c * taux_marge, c + coeff_marge, 2 * c * coeff_marge, c * (1 - taux_marge)]
+_cs = [rat_fr(v) for v in _cand]
+_d = _dedl(repBI, _cs)
+bi1, bi2, bi3 = _d[0], _d[1], _d[2]
+
+# Q1 : intervalle semi-ouvert (ouverture/fermeture des bornes)
+def _iv(ol, oh):
+    s = pxs_Interval(pxs_nvirgzero(float(borneInf)), plafond, ol, oh).print()
+    if pxs_lang == "fr":
+        s = s.replace(".", ",")
+    return s
+
+SCorrect = SAff
+SD1 = _iv(True, False)
+SD2 = _iv(False, False)
+SD3 = _iv(True, True)
+
+globals()
+````
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Une entreprise de distribution fixe le prix de vente unitaire`{en}`A distribution company sets the unit selling price` $p$ {fr}`(en euros) de sorte que la marge soit au moins`{en}`(in euros) so that the margin is at least` ${{ tauxPct }}\,\%$ {fr}`du coût d'achat`{en}`of the purchase cost` $c={{ c }}$ €, {fr}`et que le prix reste inférieur au plafond réglementaire de`{en}`and that the price remains below the regulatory ceiling of` ${{ plafond }}$ €. {fr}`Quelle est la borne inférieure issue de la contrainte de marge,`{en}`What is the lower bound from the margin constraint,` $p\geq {{ coeffMargeAff }}\times {{ c }}$ ?
+::::
+
+::::{questionHint}
+{fr}`Une marge d'au moins`{en}`A margin of at least` ${{ tauxPct }}\,\%$ {fr}`sur le coût d'achat signifie`{en}`on the purchase cost means` $p\geq c+{{ tauxMargeAff }}\,c={{ coeffMargeAff }}\,c$.
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+${{ repBI }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{ bi1 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{ bi2 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{ bi3 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`On traduit la contrainte de marge en borne inférieure sur le prix.`{en}`We translate the margin constraint into a lower bound on the price.`
+
+\begin{equation*}
+p \geq {{ coeffMargeAff }} \times {{ c }} = {{ borneInfAff }}.
+\end{equation*}
+
+{fr}`La borne inférieure est`{en}`The lower bound is` ${{ borneInfAff }}$ €.
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 30
+:calculation: 35
+::::
+:::::
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`On combine la double contrainte (marge et plafond). Quel est l'ensemble des prix admissibles en notation intervalle (en tenant compte du type de chaque borne) ?`{en}`We combine the double constraint (margin and ceiling). What is the set of admissible prices in interval notation (taking into account the type of each bound)?`
+::::
+
+::::{questionHint}
+{fr}`Combiner`{en}`Combine` $p\geq {{ borneInfAff }}$ {fr}`(marge, borne incluse) et`{en}`(margin, included bound) and` $p<{{ plafond }}$ {fr}`(plafond, borne exclue).`{en}`(ceiling, excluded bound).`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+$S = {{ SCorrect }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ SD1 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ SD2 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ SD3 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`On rassemble les deux conditions en un encadrement ; aucune opération supplémentaire n'est nécessaire car`{en}`We combine the two conditions into an inequality; no additional operation is necessary since` $p$ {fr}`est déjà isolée.`{en}`is already isolated.`
+
+\begin{equation*}
+{{ encadrAff }}.
+\end{equation*}
+
+{fr}`L'ensemble des solutions est`{en}`The solution set is`
+
+\begin{equation*}
+S = {{ SAff }}.
+\end{equation*}
+
+{fr}`La borne`{en}`The bound` ${{ borneInfAff }}$ {fr}`est incluse (un prix de`{en}`is included (a price of` ${{ borneInfAff }}$ € {fr}`satisfait exactement la marge). La borne`{en}`exactly satisfies the margin). The bound` ${{ plafond }}$ {fr}`est exclue (un prix de`{en}`is excluded (a price of` ${{ plafond }}$ € {fr}`violerait le plafond).`{en}`would violate the ceiling).`
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 30
+:reasoning: 30
+:calculation: 20
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Prix plafond et demande décroissante`{en}`Price ceiling and decreasing demand`.md

@@ -0,0 +1,127 @@
+`````{exercise}
+:originalExerciseId: 84168f40-6340-11f1-a8a1-0ed8d3b012a9
+:title: {fr}`Prix plafond et demande décroissante`{en}`Price ceiling and decreasing demand`
+:modules: 
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: 
+:involvedConcepts: Solving_inequalities
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Version QCM — division par un coefficient négatif (inversion du sens), ensemble en intervalle.
+:id: f2cc923d-6e47-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from sympy import oo
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_latex_coefficient as lc, pxsl_format_number
+from pyxiscience.Classes_Extensions import pxs_Interval
+
+config_standard = pxs_config()
+
+# Tirage contraint : a divise (p_max - p_plafond)
+for _ in range(2000):
+    p_max = rd.randint(80, 200)
+    p_plafond = rd.randint(max(40, p_max // 3), p_max - 20)
+    diviseurs = [d for d in range(2, 11) if (p_max - p_plafond) % d == 0]
+    if diviseurs:
+        a = rd.choice(diviseurs)
+        break
+
+q_min = (p_max - p_plafond) // a
+intermediaire = p_plafond - p_max
+
+q_verif_ok = q_min
+q_verif_ko = q_min - 1
+p_verif_ko = p_max - a * q_verif_ko
+intervalAff = pxs_Interval(q_min, oo, False, True).print()
+
+# Rendus
+negASignAff = lc(-a, sign=True)
+pMax = p_max
+pPlafond = p_plafond
+negAAff = lc(-a)
+qMinAff = pxsl_format_number(q_min)
+qVerifOk = q_verif_ok
+qVerifKo = q_verif_ko
+pVerifKo = p_verif_ko
+
+# === Distracteurs MCQ (ajouts ; le code ci-dessus est inchangé) ===
+intervalCorrect = intervalAff
+intD1 = pxs_Interval(q_min, oo, True, True).print()
+intD2 = pxs_Interval(-oo, q_min, True, False).print()
+intD3 = pxs_Interval(0, q_min, False, False).print()
+
+globals()
+````
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Sur un marché, la fonction de demande inverse est`{en}`In a market, the inverse demand function is` 
+\begin{equation*}
+p(q) = {{ pMax }} {{ negASignAff }}q
+\end{equation*}
+{fr}`Le prix est en euros,`{en}`The price is in euros,` $q$ {fr}`en milliers d'unités. Un régulateur impose un prix plafond`{en}`in thousands of units. A regulator imposes a price ceiling` $p \leq {{ pPlafond }}$ €.\
+\
+{fr}`En traduisant cette contrainte par une inéquation sur`{en}`Translating this constraint into an inequality involving` $q$ {fr}`et en la résolvant, quel est l'ensemble des quantités compatibles ?`{en}`and solving it, what is the set of compatible quantities?`
+::::
+
+::::{questionHint}
+{fr}`Substituer`{en}`Substitute` $p(q)$ {fr}`dans`{en}`into` $p \leq {{ pPlafond }}${fr}`, puis isoler`{en}`, then isolate` $q$ {fr}`en divisant par`{en}`by dividing by` ${{ negAAff }} < 0$ {fr}`: le sens s'inverse.`{en}`: the direction reverses.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+$S = {{ intervalCorrect }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ intD1 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ intD2 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$S = {{ intD3 }}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`On soustrait d'abord une quantité, le sens de l'inégalité est alors conservé, puis on divise par un réel strictement négatif, qui inverse le sens de l'inégalité.`{en}`We first subtract a quantity, the direction of the inequality is then preserved, then we divide by a strictly negative real number, which reverses the direction of the inequality.`
+
+\begin{equation*}
+{{ pMax }} {{ negASignAff }}q \leq {{ pPlafond }} &\implies {{ negAAff }}q \leq {{ intermediaire }}\\[10pt]
+&\implies \frac{ {{ negAAff }}q }{ {{ negAAff }} } \geq \frac{ {{ intermediaire }} }{ {{ negAAff }} }\\[10pt]
+&\implies q \geq {{ qMinAff }}.
+\end{equation*}
+
+{fr}`L'ensemble des solutions est donc`{en}`The solution set is therefore`
+
+\begin{equation*}
+S = {{ intervalAff }}.
+\end{equation*}
+
+{fr}`Pour que le prix soit au plus`{en}`For the price to be at most` ${{ pPlafond }}$ €{fr}`, la quantité offerte doit être d'au moins`{en}`, the quantity supplied must be at least` ${{ qMinAff }}$ {fr}`milliers d'unités. Ceci est cohérent car la demande étant décroissante, un prix plus bas correspond à une quantité plus grande.`{en}`thousands of units. This is consistent because since demand is decreasing, a lower price corresponds to a larger quantity.`
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 25
+:reasoning: 35
+:calculation: 20
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Règle des exposants _ simplification et calcul`{en}`Exponent Rules_ Simplification and Calculation`.md

@@ -0,0 +1,162 @@
+`````{exercise}
+:title: {fr}`Règle des exposants : simplification et calcul`{en}`Exponent Rules: Simplification and Calculation`
+:modules: 
+:recommendedExecutionTime: 8
+:level: Elementary
+:chap: chap_expLogFunctions_exponentialFunctions_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Échauffement (thème pur) : application de la règle b^(x+y)=b^x·b^y et b^(x−y)=b^x/b^y, en simplification littérale et en vérification numérique.
+:id: 7dff868d-74d9-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 6da31517-6597-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from fractions import Fraction
+from decimal import Decimal, ROUND_HALF_UP
+
+def _grp(ip):
+    neg = ip.startswith('-'); ip = ip.lstrip('-'); g = []
+    while len(ip) > 3:
+        g.insert(0, ip[-3:]); ip = ip[:-3]
+    g.insert(0, ip)
+    return ('-' if neg else '') + '\\,'.join(g)
+
+def num_fr(v, maxdec=5):
+    f = Fraction(v)
+    d = (Decimal(f.numerator) / Decimal(f.denominator)).quantize(Decimal(1).scaleb(-maxdec), rounding=ROUND_HALF_UP)
+    s = format(abs(d), 'f'); ip, _, fp = s.partition('.'); fp = fp.rstrip('0')
+    return ('-' if d < 0 else '') + _grp(ip) + (('{,}' + fp) if fp else '')
+
+# Q1 : simplification symbolique (exposants >= 2 partout)
+sommeA = rd.randint(5, 10)
+diffB = rd.randint(3, 6)
+exp1 = rd.randint(2, sommeA - 2)
+exp2 = sommeA - exp1
+exp4 = rd.randint(2, 5)
+exp3 = exp4 + diffB
+aAff = 'b^{%d}' % sommeA
+bAff = 'b^{%d}' % diffB
+
+# Q2 : vérification numérique
+baseC = rd.choice([2, 3])
+sommeC = rd.randint(5, 8)
+exp5 = rd.randint(2, sommeC - 2)
+exp6 = sommeC - exp5
+baseDNum = rd.choice([3, 5])               # base_D = 3/2 ou 5/2
+baseD = Fraction(baseDNum, 2)
+diffD = rd.randint(2, 4)
+exp8 = rd.randint(2, 4)
+exp7 = exp8 + diffD
+
+cVal = baseC ** sommeC
+dVal = baseD ** diffD
+
+# Rendus
+baseDAff = '%d{,}5' % (baseDNum // 2)       # 3/2 -> 1{,}5 ; 5/2 -> 2{,}5
+dValAff = num_fr(dVal, 5)
+
+# === Ajouts conversion FGQ ===
+def _solnum(x):
+    return x.replace("\\,", "").replace("{,}", ".")
+dValSol = _solnum(dValAff)
+globals()
+````
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["ord","$b^{ {{ sommeA }} }$","$b^{ {{ diffB }} }$"],["0","0"]]
+
+::::{questionStatement}
+{fr}`Soit`{en}`Let` $b>0$, $b\neq 1$. {fr}`Simplifier`{en}`Simplify` $A=b^{ {{exp1}} }\cdot b^{ {{exp2}} }$ {fr}`et`{en}`and` $B=\dfrac{b^{ {{exp3}} }}{b^{ {{exp4}} }}$ {fr}`à l'aide de la règle des exposants.`{en}`using the exponent rules.`
+
+{fr}`$A$ se simplifie en`{en}`$A$ simplifies to` {input}`||110` {fr}`et $B$ en`{en}`and $B$ to` {input}`||110`
+::::
+
+::::{questionHint}
+$b^{x}\cdot b^{y}=b^{x+y}$ {fr}`et`{en}`and` $\dfrac{b^{x}}{b^{y}}=b^{x-y}$.
+::::
+
+::::{displayedSolution}
+$A = b^{ {{ sommeA }} }$ $\qquad B = b^{ {{ diffB }} }$
+::::
+
+::::{detailedSolution}
+{fr}`Par addition des exposants pour le produit, et soustraction pour le quotient :`{en}`By adding exponents for the product, and subtracting for the quotient:`
+
+\begin{equation*}
+A &= b^{ {{exp1}} }\cdot b^{ {{exp2}} } \\
+&= b^{ {{exp1}} + {{exp2}} } \\
+&= {{ aAff }}.
+\end{equation*}
+
+\begin{equation*}
+B &= \frac{b^{ {{exp3}} }}{b^{ {{exp4}} }} \\
+&= b^{ {{exp3}} - {{exp4}} } \\
+&= {{ bAff }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 30
+:reasoning: 25
+:calculation: 25
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 1
+:questionIndex: 1
+:solution: [["ord","${{ cVal }}$","${{ dValSol }}$"],["0","0"]]
+
+::::{questionStatement}
+{fr}`Calculer numériquement`{en}`Compute numerically` $C={{ baseC }}^{ {{exp5}} }\cdot {{ baseC }}^{ {{exp6}} }$ {fr}`et vérifier que`{en}`and verify that` $C={{ baseC }}^{ {{sommeC}} }$, {fr}`puis`{en}`then` $D=\dfrac{({{ baseDAff }})^{ {{exp7}} }}{({{ baseDAff }})^{ {{exp8}} }}$ {fr}`et vérifier que`{en}`and verify that` $D=({{ baseDAff }})^{ {{diffD}} }$.
+
+$C =$ {input}`||80` $\qquad D =$ {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Calculer chaque puissance, puis comparer au résultat attendu par la règle des exposants.`{en}`Compute each power, then compare to the expected result using the exponent rules.`
+::::
+
+::::{displayedSolution}
+$C = {{ cVal }}$ $\qquad D = {{ dValAff }}$
+::::
+
+::::{detailedSolution}
+{fr}`Pour`{en}`For` $C$ :
+
+\begin{equation*}
+C &= {{ baseC }}^{ {{exp5}} }\cdot {{ baseC }}^{ {{exp6}} } \\
+&= {{ baseC }}^{ {{exp5}} + {{exp6}} } \\
+&= {{ baseC }}^{ {{sommeC}} } \\
+&= {{ cVal }}.
+\end{equation*}
+
+{fr}`Pour`{en}`For` $D$ :
+
+\begin{equation*}
+D &= \frac{({{ baseDAff }})^{ {{exp7}} }}{({{ baseDAff }})^{ {{exp8}} }} \\
+&= ({{ baseDAff }})^{ {{exp7}} - {{exp8}} } \\
+&= ({{ baseDAff }})^{ {{diffD}} } \\
+&= {{ dValAff }}.
+\end{equation*}
+
+{fr}`Les deux vérifications sont cohérentes avec la règle des exposants.`{en}`Both verifications are consistent with the exponent rules.`
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 25
+:reasoning: 25
+:calculation: 35
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Résolution de`{en}`Resolution of` $_ax+b_ = k$ {fr}`avec`{en}`with` $k _ 0$.md

@@ -0,0 +1,151 @@
+`````{exercise}
+:title: {fr}`Résolution de`{en}`Resolution of` $|ax+b| = k$ {fr}`avec`{en}`with` $k > 0$
+:modules: 
+:recommendedExecutionTime: 5
+:level: Elementary
+:chap: chap_equations_Inequalities_absoluteValue_ESCP
+:involvedConcepts: Abs_Val, Simplifying_Algebraic_Expressions, Solving_equalities
+:originalSource: Erwan Lamy, ESCP Business School
+:visibility: All
+:variations: 
+:comment: Échauffement 2/10 — résolution d'une équation à valeur absolue, cas k > 0 (deux cas).
+:id: dafee084-70aa-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 004ee5bb-634d-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from math import gcd
+from sympy import Rational, latex
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_latex_coefficient as lc
+config_standard = pxs_config()
+
+# Équation |b - a x| = k, k > 0.
+#   Cas 1 : b - a x =  k  ->  x = (b - k)/a   (fraction irréductible, dénominateur >= 2)
+#   Cas 2 : b - a x = -k  ->  x = (b + k)/a   (entier par construction)
+for _ in range(200):
+    a = rd.randint(2, 9)
+    b = rd.randint(5, 15)
+    k = rd.randint(2, min(10, b - 1))
+    if (b + k) % a == 0 and (b - k) != 0 and gcd(b - k, a) == 1:
+        break
+
+sol1 = Rational(b - k, a)              # exact, irréductible, q >= 2
+sol2 = (b + k) // a                    # entier
+
+aAff = str(a)
+bAff = str(b)
+kAff = str(k)
+negKAff = str(-k)
+coefAff = lc(-a, sign=True)            # coefficient signé du terme en x : "- a"
+sol1Aff = latex(sol1)                  # fraction irréductible
+sol1NumAff = str(b - k)
+sol1DenAff = str(a)
+sol2Aff = str(sol2)
+bPlusKAff = str(b + k)                 # = a * sol2
+aTimesSol1Aff = str(b - k)             # a * sol1
+bMinusASol2Aff = str(b - a * sol2)     # = -k
+
+globals()
+````
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["notord","${{ sol1Aff }}$","${{ sol2Aff }}$"],["0","0"]]
+
+::::{questionStatement}
+{fr}`**Résolution d'une équation $|ax + b| = k$ avec $k > 0$.**` {en}`**Solving an equation $|ax + b| = k$ with $k > 0$.**`
+
+{fr}`Résoudre l'équation suivante et donner ses deux solutions :` {en}`Solve the following equation and give its two solutions:`
+
+\begin{equation*}
+|{{ bAff }} {{ coefAff }}x| = {{ kAff }}.
+\end{equation*}
+
+$x =$ {input}`||120` {fr}`ou`{en}`or` $x =$ {input}`||120`
+::::
+
+::::{questionHint}
+{fr}`Lorsque $k > 0$, l'équation $|f(x)| = k$ se scinde en deux cas : $f(x) = k$ ou $f(x) = -k$.`
+
+{en}`When $k > 0$, the equation $|f(x)| = k$ splits into two cases: $f(x) = k$ or $f(x) = -k$.`
+::::
+
+::::{displayedSolution}
+$\ds x = {{ sol1Aff }}$ {fr}`ou`{en}`or` $\ds x = {{ sol2Aff }}$
+::::
+
+::::{detailedSolution}
+{fr}`L'équation proposée est $|{{bAff}} {{coefAff}}x| = {{kAff}}$ avec ${{kAff}} > 0$.`
+
+{en}`The given equation is $|{{bAff}} {{coefAff}}x| = {{kAff}}$ with ${{kAff}} > 0$.`
+
+{fr}`Par définition de la valeur absolue, cette équation se décompose en deux situations distinctes :`{en}`By definition of absolute value, this equation splits into two distinct cases:`
+
+$\phantom{-}$
+
+{fr}`$\bullet$ **Premier cas :** ${{bAff}} {{coefAff}}x = {{kAff}}$`
+
+{en}`$\bullet$ **First case:** ${{bAff}} {{coefAff}}x = {{kAff}}$`
+
+{fr}`On isole $x$ en regroupant les termes constants :`
+{en}`We isolate $x$ by grouping the constant terms:`
+
+\begin{equation*}
+{{bAff}} {{coefAff}}x = {{kAff}} \quad &\Longleftrightarrow \quad {{aAff}}x = {{sol1NumAff}} \quad \\[6pt]
+&\Longleftrightarrow \quad x = \frac{{{sol1NumAff}}}{{{sol1DenAff}}}.
+\end{equation*}
+
+{fr}`$\bullet$ **Deuxième cas :** ${{bAff}} {{coefAff}}x = {{negKAff}}$`
+
+{en}`$\bullet$ **Second case:** ${{bAff}} {{coefAff}}x = {{negKAff}}$`
+
+{fr}`On isole $x$ de la même façon :`
+{en}`We isolate $x$ in the same way:`
+
+\begin{equation*}
+{{bAff}} {{coefAff}}x = {{negKAff}} \quad &\Longleftrightarrow \quad {{aAff}}x = {{bPlusKAff}} \quad \\[6pt]
+&\Longleftrightarrow \quad x = {{sol2Aff}}.
+\end{equation*}
+
+{fr}`**Vérification des deux solutions.**`
+
+{en}`**Verification of both solutions.**`
+
+{fr}`Pour $x = \dfrac{{{sol1NumAff}}}{{{sol1DenAff}}}$ :`
+{en}`For $x = \dfrac{{{sol1NumAff}}}{{{sol1DenAff}}}$:`
+
+\begin{equation*}
+\left|{{bAff}} {{coefAff}}\times\frac{{{sol1NumAff}}}{{{sol1DenAff}}}\right| &= \left|{{bAff}} - {{aAff}}\times\frac{{{sol1NumAff}}}{{{sol1DenAff}}}\right| \\[10pt]
+&= \left|{{bAff}} - {{aTimesSol1Aff}}\right| \\[10pt]
+&= {{kAff}}.
+\end{equation*}
+
+{fr}`Pour $x = {{sol2Aff}}$ :`
+{en}`For $x = {{sol2Aff}}$:`
+
+\begin{equation*}
+\left|{{bAff}} {{coefAff}}\times{{sol2Aff}}\right| &= \left|{{bAff}} - {{aAff}}\times{{sol2Aff}}\right| \\[10pt]
+&= \left|{{bMinusASol2Aff}}\right| \\[10pt]
+&= {{kAff}}.
+\end{equation*}
+
+{fr}`Les deux valeurs vérifient l'équation initiale.`
+
+{en}`Both values satisfy the original equation.`
+
+{fr}`**Conclusion :** L'ensemble des solutions est $\boxed{\left\{\dfrac{{{sol1NumAff}}}{{{sol1DenAff}}},\, {{sol2Aff}}\right\}}$.`
+
+{en}`**Conclusion:** The solution set is $\boxed{\left\{\dfrac{{{sol1NumAff}}}{{{sol1DenAff}}},\, {{sol2Aff}}\right\}}$.`
+::::
+
+::::{weightDistribution}
+:logic: 10
+:abstraction: 15
+:reasoning: 25
+:calculation: 50
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Seuil de rentabilité d'une boutique`{en}`Break-Even Point of a Store`.md

@@ -0,0 +1,198 @@
+`````{exercise}
+:title: {fr}`Seuil de rentabilité d'une boutique`{en}`Break-Even Point of a Store`
+:modules: 
+:recommendedExecutionTime: 15
+:level: Elementary
+:chap: chap_lines_Systems_economicEquilibriumBreakeven_ESCP
+:involvedConcepts: 
+:originalSource: Session 4 — Erwan Lamy, ESCP Business School
+:visibility: All
+:variations: 
+:comment: Appliqué (gestion) : revenu total, coût total, profit, seuil de rentabilité, marge sur coût variable.
+:id: 33724a3b-74c0-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 10e7b53f-64e3-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_latex_coefficient as lc, pxsl_format_number
+# --- Helpers PyxiScience (definis inline, autonomes : aucun import externe) ---
+
+config_standard = pxs_config()
+
+# p > c (marge positive) ; y_FC multiple de 50 divisible par la marge (seuil entier)
+for _ in range(300):
+    p = rd.randint(20, 50)
+    c = rd.randint(5, 15)
+    if p <= c:
+        continue
+    marge = p - c
+    yFc = rd.randint(6, 16) * 50
+    if yFc % marge == 0:
+        break
+
+qStar = yFc // marge
+qTest = qStar + rd.randint(5, 20)
+profitQtest = marge * qTest - yFc
+
+# Affichage
+yFcAff = pxsl_format_number(yFc)
+profitQtestAff = pxsl_format_number(profitQtest)
+
+globals()
+````
+
+{fr}`Une boutique vend des écharpes faites main au prix unitaire `{en}`A shop sells handmade scarves at the unit price `$p = {{p}}${fr}` €. Le coût variable unitaire est `{en}` €. The unit variable cost is `$c = {{c}}${fr}` € et le coût fixe mensuel `{en}` € and the monthly fixed cost `$y_{FC} = {{yFcAff}}$ €.
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["ord","${{ p }}$","${{ c }}$","${{ yFcAff }}$"],["0","0","0"]]
+
+::::{questionStatement}
+{fr}`Écrire le revenu total `{en}`Write the total revenue `$y_{TR}(q)${fr}` et le coût total `{en}` and the total cost `$y_{TC}(q)$.
+- $y_{TR}(q) =$ {input}`||80` $q$ 
+- $y_{TC}(q) =$ {input}`||80` $q +$ {input}`||80`
+::::
+
+::::{questionHint}
+$y_{TR} = p\,q${fr}` et `{en}` and `$y_{TC} = c\,q + y_{FC}$.
+::::
+
+::::{displayedSolution}
+$y_{TR}(q) = {{ p }}q$ — $y_{TC}(q) = {{ c }}q + {{ yFcAff }}$
+::::
+
+::::{detailedSolution}
+{fr}`On applique les définitions :`{en}`We apply the definitions:`
+
+\begin{equation*}
+y_{TR}(q) = {{p}}\,q, \qquad y_{TC}(q) = {{c}}\,q + {{yFcAff}}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 10
+:abstraction: 25
+:reasoning: 30
+:calculation: 35
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 1
+:questionIndex: 1
+:solution: [["ord","${{ marge }}$","${{ yFcAff }}$"],["0","0"]]
+
+::::{questionStatement}
+{fr}`Calculer le profit `{en}`Compute the profit `$\Pi(q) = y_{TR}(q) - y_{TC}(q)${fr}` et simplifier.`{en}` and simplify.`\
+\
+$\Pi(q) =$ {input}`||80` $q -$ {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Soustraire le coût total du revenu total, puis regrouper les termes en `{en}`Subtract the total cost from the total revenue, then group the terms in `$q$.
+::::
+
+::::{displayedSolution}
+$\Pi(q) = {{ marge }}q - {{ yFcAff }}$
+::::
+
+::::{detailedSolution}
+{fr}`On développe :`{en}`We expand:`
+
+\begin{equation*}
+\Pi(q) = {{p}}\,q - ({{c}}\,q + {{yFcAff}}) = {{marge}}\,q - {{yFcAff}}.
+\end{equation*}
+
+{fr}`Le profit est affine, de coefficient directeur `{en}`The profit is affine, with slope `${{marge}}${fr}` : c'est la marge sur coût variable `{en}`: it is the contribution margin `$p - c = {{p}} - {{c}} = {{marge}}${fr}` € par écharpe.`{en}` € per scarf.`
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 25
+:reasoning: 25
+:calculation: 35
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 2
+:questionIndex: 2
+:solution: [["ord","${{ qStar }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`Déterminer la quantité de seuil de rentabilité `{en}`Determine the break-even quantity `$q^{*}${fr}` en résolvant `{en}` by solving `$y_{TR}(q) = y_{TC}(q)$.\
+\
+$q^*$ = {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Au seuil de rentabilité, le profit est nul : `{en}`At the break-even point, the profit is zero: `$\Pi(q) = 0$.
+::::
+
+::::{displayedSolution}
+$q^* = {{ qStar }}$
+::::
+
+::::{detailedSolution}
+{fr}`On résout `{en}`We solve `$\Pi(q) = 0$ :
+
+\begin{equation*}
+{{marge}}\,q - {{yFcAff}} = 0 \implies {{marge}}\,q = {{yFcAff}} \implies q^{*} = {{qStar}}.
+\end{equation*}
+
+{fr}`La boutique doit vendre au moins `{en}`The shop must sell at least `${{qStar}}${fr}` écharpes par mois pour couvrir ses coûts.`{en}` scarves per month to cover its costs.`
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 30
+:calculation: 35
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 3
+:questionIndex: 3
+:solution: [["ord","${{ profitQtestAff }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`Calculer le profit pour `{en}`Compute the profit for `$q = {{qTest}}${fr}` écharpes vendues. La boutique est-elle rentable à ce niveau ?`{en}` scarves sold. Is the shop profitable at this level?`\
+\
+$\Pi({{ qTest }})$ = {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Évaluer `{en}`Evaluate `$\Pi({{qTest}})${fr}` et comparer `{en}` and compare `${{qTest}}${fr}` au seuil `{en}` with the break-even `$q^{*}$.
+::::
+
+::::{displayedSolution}
+$\Pi({{ qTest }}) = {{ profitQtestAff }}$
+::::
+
+::::{detailedSolution}
+{fr}`On évalue le profit en `{en}`We evaluate the profit at `$q = {{qTest}}$ :
+
+\begin{equation*}
+\Pi({{qTest}}) = {{marge}} \times {{qTest}} - {{yFcAff}} = {{profitQtestAff}}.
+\end{equation*}
+
+{fr}`soit`{en}`i.e.` ${{ profitQtestAff }}$ {fr}`€.`{en}`€.`
+
+{fr}`Comme `{en}`Since `${{qTest}} > q^{*} = {{qStar}}${fr}`, la boutique est rentable et dégage un profit mensuel de `{en}`, the shop is profitable and earns a monthly profit of `${{profitQtestAff}}$ €.
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 30
+:calculation: 35
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Simplifier des expressions avec exponentielle et logarithme`{en}`Simplify expressions with exponential and logarithm`.md

@@ -0,0 +1,119 @@
+`````{exercise}
+:title: {fr}`Simplifier des expressions avec exponentielle et logarithme`{en}`Simplify expressions with exponential and logarithm`
+:modules: 
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: chap_expLogFunctions_logarithmicFunctions_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Échauffement (thème pur) : simplification via les relations réciproques e^(ln y)=y, ln(e^x)=x, b^(log_b y)=y, log_b(b^x)=x, y compris en composition. Aucune loi algébrique du logarithme.
+:originalExerciseId: 2f1a6101-6599-11f1-a8a1-0ed8d3b012a9
+:id: 07721958-74bf-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+
+# Q1 : e^(ln y1)=y1, ln(e^x1)=x1, b1^(log_b1 y2)=y2
+y1 = rd.randint(2, 20)
+x1 = rd.randint(2, 15)
+b1 = rd.choice([2, 3, 4, 5, 6, 7, 8, 9])
+y2 = rd.randint(2, 20)
+r1, r2, r3 = y1, x1, y2
+
+# Q2 : log_b2(b2^x2)=x2 (x2 != 0, 1 pour éviter ^1), e^(ln(e^x3))=e^x3
+b2 = rd.choice([2, 3, 4, 5, 6, 7, 8, 9])
+x2 = rd.choice(list(range(-10, 0)) + list(range(2, 11)))
+x3 = rd.randint(2, 10)
+r4 = x2
+r5Aff = "e^{%d}" % x3
+
+globals()
+````
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","{{ r1 }}","{{ r2 }}","{{ r3 }}"],["0","0","0"]]
+
+::::{questionStatement}
+{fr}`Simplifier`{en}`Simplify` $e^{\ln {{ y1 }}}$, $\ln(e^{ {{ x1 }} })$ {fr}`et`{en}`and` ${{ b1 }}^{\log_{ {{ b1 }} }({{ y2 }})}$.
+
+$e^{\ln {{ y1 }}} =$ {input}`||70`
+
+$\ln(e^{ {{ x1 }} }) =$ {input}`||70`
+
+${{ b1 }}^{\log_{ {{ b1 }} }({{ y2 }})} =$ {input}`||70`
+::::
+
+::::{questionHint}
+$e^{\ln y}=y$, $\ln(e^{x})=x$, $b^{\log_{b} y}=y$.
+::::
+
+::::{displayedSolution}
+$e^{\ln {{ y1 }}} = {{ r1 }}$
+
+$\ln(e^{ {{ x1 }} }) = {{ r2 }}$
+
+${{ b1 }}^{\log_{ {{ b1 }} }({{ y2 }})} = {{ r3 }}$
+::::
+
+::::{detailedSolution}
+{fr}`Par les relations réciproques :`{en}`By the reciprocal relations:` $e^{\ln {{ y1 }}}={{ r1 }}$, $\quad \ln(e^{ {{ x1 }} })={{ r2 }}$, $\quad {{ b1 }}^{\log_{ {{ b1 }} }({{ y2 }})}={{ r3 }}$.
+
+{fr}`(respectivement`{en}`(respectively` $e^{\ln y}=y$ {fr}`avec`{en}`with` $y={{ y1 }}$ ; $\ln(e^{x})=x$ {fr}`avec`{en}`with` $x={{ x1 }}$ ; $b^{\log_{b} y}=y$ {fr}`avec`{en}`with` $b={{ b1 }}$, $y={{ y2 }}$.)
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 30
+:reasoning: 30
+:calculation: 20
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","{{ r4 }}","${{ r5Aff }}$"],["0","0"]]
+
+::::{questionStatement}
+{fr}`Simplifier`{en}`Simplify` $\log_{ {{ b2 }} }({{ b2 }}^{ {{ x2 }} })$ {fr}`et`{en}`and` $e^{\ln(e^{ {{ x3 }} })}$.
+
+$\log_{ {{ b2 }} }({{ b2 }}^{ {{ x2 }} }) =$ {input}`||70`
+
+$e^{\ln(e^{ {{ x3 }} })} =$ {input}`||90`
+::::
+
+::::{questionHint}
+{fr}`Pour la seconde, simplifier de l'intérieur vers l'extérieur : d'abord`{en}`For the second, simplify from the inside out: first` $\ln(e^{ {{ x3 }} })$.
+::::
+
+::::{displayedSolution}
+$\log_{ {{ b2 }} }({{ b2 }}^{ {{ x2 }} }) = {{ r4 }}$
+
+$e^{\ln(e^{ {{ x3 }} })} = {{ r5Aff }}$
+::::
+
+::::{detailedSolution}
+{fr}`Par`{en}`By` $\log_{b}(b^{x})=x$ :
+
+\begin{equation*}
+\log_{ {{ b2 }} }({{ b2 }}^{ {{ x2 }} }) = {{ r4 }}.
+\end{equation*}
+
+{fr}`Pour la seconde,`{en}`For the second,` $\ln(e^{ {{ x3 }} })={{ x3 }}$, {fr}`puis`{en}`then` $e^{\ln(e^{ {{ x3 }} })}=e^{ {{ x3 }} }$ {fr}`(relation`{en}`(relation` $e^{\ln y}=y$ {fr}`avec`{en}`with` $y=e^{ {{ x3 }} }>0$) :
+
+\begin{equation*}
+e^{\ln(e^{ {{ x3 }} })} = {{ r5Aff }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 35
+:reasoning: 30
+:calculation: 15
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Symétries d'une courbe de demande et restriction économique`{en}`Symmetries of a demand curve and economic restriction`.md

@@ -0,0 +1,192 @@
+`````{exercise}
+:title: {fr}`Symétries d'une courbe de demande et restriction économique`{en}`Symmetries of a demand curve and economic restriction`
+:modules: 
+:recommendedExecutionTime: 18
+:level: Elementary
+:chap: chap_realFunctions_Graphs_graphSymmetries_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Appliqué (économie & gestion) : quatre tests de symétrie sur une courbe de demande implicite (cercle), puis restriction au premier quadrant et identification de la seule symétrie pertinente (y=x), en reconnaissance uniquement.
+:id: 64470bcd-74b4-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: e6ac5c47-6409-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config
+
+config_standard = pxs_config()
+
+rayon = rd.randint(3, 10)
+rayon_carre = rayon**2
+
+if pxs_lang == "fr":
+    unite_demande = rd.choice(["centaines d'unités", "milliers d'unités", "dizaines d'unités"])
+    unite_prix = rd.choice(["dizaines d'euros", "centaines d'euros", "euros"])
+    type_produit = rd.choice(["produit de luxe", "produit technologique", "bien de consommation", "service premium"])
+else:
+    unite_demande = rd.choice(["hundreds of units", "thousands of units", "tens of units"])
+    unite_prix = rd.choice(["tens of dollars", "hundreds of dollars", "dollars"])
+    type_produit = rd.choice(["luxury product", "technological product", "consumer good", "premium service"])
+
+# Rendus
+rayonCarre = rayon_carre
+uniteDemande = unite_demande
+unitePrix = unite_prix
+typeProduit = type_produit
+
+globals()
+````
+
+:::::{question}
+:questionType: MCQ
+:questionId: 0
+:questionIndex: 0
+
+::::{questionStatement}
+{fr}`Un directeur commercial étudie la courbe de demande d'un`{en}`A sales director studies the demand curve of a` {{ typeProduit }} {fr}`: la demande`{en}`: the demand` $D>0$ {fr}`(en`{en}`(in` {{ uniteDemande }}) {fr}`et le prix`{en}`and the price` $p>0$ {fr}`(en`{en}`(in` {{ unitePrix }}) {fr}`vérifient`{en}`satisfy` $p^2+D^2={{ rayonCarre }}$. {fr}`Appliquer les quatre tests algébriques de symétrie (par rapport à l'axe`{en}`Apply the four algebraic symmetry tests (with respect to the axis` $Op$, {fr}`à l'axe`{en}`to the axis` $OD$, {fr}`à l'origine, à la droite`{en}`to the origin, to the line` $D=p$) {fr}`à la courbe complète et conclure pour chacun.`{en}`to the complete curve and conclude for each.`
+::::
+
+::::{questionHint}
+{fr}`Substituer dans l'équation : les carrés rendent`{en}`Substitute in the equation: the squares make` $p^2$ {fr}`et`{en}`and` $D^2$ {fr}`inchangés par changement de signe ; échanger`{en}`unchanged by sign change; exchanging` $p$ {fr}`et`{en}`and` $D$ {fr}`ne change pas une somme.`{en}`does not change a sum.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{fr}`Les quatre :`{en}`All four:` $Op$, $OD$, {fr}`l'origine et la droite`{en}`the origin, and the line` $D=p$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Seulement les axes`{en}`Only the axes` $Op$ {fr}`et`{en}`and` $OD$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Seulement la droite`{en}`Only the line` $D=p$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Seulement l'origine`{en}`Only the origin`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`La courbe complète`{en}`The complete curve` $p^2+D^2={{ rayonCarre }}$ {fr}`est un cercle de centre`{en}`is a circle with center` $O$ {fr}`et de rayon`{en}`and radius` ${{ rayon }}$.
+
+\begin{equation*}
+p^2 + D^2 = {{ rayonCarre }}.
+\end{equation*}
+
+{fr}`**Test axe**`{en}`**Axis test**` $Op$ ($D \to -D$) : {fr}`on remplace`{en}`we replace` $D$ {fr}`par`{en}`by` $-D$ {fr}`dans l'équation :`{en}`in the equation:`
+
+\begin{equation*}
+p^2 + (-D)^2 = p^2 + D^2 = {{ rayonCarre }}.
+\end{equation*}
+
+{fr}`L'équation est inchangée : la courbe est symétrique par rapport à l'axe`{en}`The equation is unchanged: the curve is symmetric with respect to the axis` $Op$.
+
+{fr}`**Test axe**`{en}`**Axis test**` $OD$ ($p \to -p$) : {fr}`on remplace`{en}`we replace` $p$ {fr}`par`{en}`by` $-p$ {fr}`dans l'équation :`{en}`in the equation:`
+
+\begin{equation*}
+(-p)^2 + D^2 = p^2 + D^2 = {{ rayonCarre }}.
+\end{equation*}
+
+{fr}`L'équation est inchangée : la courbe est symétrique par rapport à l'axe`{en}`The equation is unchanged: the curve is symmetric with respect to the axis` $OD$.
+
+{fr}`**Test origine** (`{en}`**Origin test** (` $p \to -p$, $D \to -D$) : {fr}`on remplace`{en}`we replace` $p$ {fr}`par`{en}`by` $-p$ {fr}`et`{en}`and` $D$ {fr}`par`{en}`by` $-D$ :
+
+\begin{equation*}
+(-p)^2 + (-D)^2 = p^2 + D^2 = {{ rayonCarre }}.
+\end{equation*}
+
+{fr}`L'équation est inchangée : la courbe est symétrique par rapport à l'origine.`{en}`The equation is unchanged: the curve is symmetric with respect to the origin.`
+
+{fr}`**Test droite**`{en}`**Line test**` $D=p$ {fr}`(échanger`{en}`(exchange` $p$ {fr}`et`{en}`and` $D$) : {fr}`on échange`{en}`we exchange` $p$ {fr}`et`{en}`and` $D$ {fr}`dans l'équation :`{en}`in the equation:`
+
+\begin{equation*}
+D^2 + p^2 = {{ rayonCarre }}.
+\end{equation*}
+
+{fr}`Cette équation est identique à l'équation initiale : la courbe est symétrique par rapport à la droite`{en}`This equation is identical to the initial equation: the curve is symmetric with respect to the line` $D=p$.
+
+{fr}`**Conclusion** : la courbe complète possède les quatre symétries.`{en}`**Conclusion**: the complete curve has all four symmetries.`
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 35
+:reasoning: 30
+:calculation: 10
+::::
+:::::
+
+:::::{question}
+:questionType: MCQ
+:questionId: 1
+:questionIndex: 1
+
+::::{questionStatement}
+{fr}`Justifier pourquoi, dans le contexte économique (`{en}`Justify why, in the economic context (` $p>0$ {fr}`et`{en}`and` $D>0$), {fr}`la courbe de demande n'est définie que sur un quart de cercle. En déduire la seule symétrie pertinente pour ce modèle, et l'interpréter.`{en}`the demand curve is only defined on a quarter circle. Deduce the only relevant symmetry for this model, and interpret it.`
+::::
+
+::::{questionHint}
+{fr}`Une symétrie n'est pertinente que si elle renvoie un point du premier quadrant dans le premier quadrant.`{en}`A symmetry is relevant only if it maps a point from the first quadrant to the first quadrant.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+{fr}`La droite`{en}`The line` $D=p$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`L'axe`{en}`The axis` $Op$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`L'axe`{en}`The axis` $OD$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`L'origine`{en}`The origin`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`**Restriction au premier quadrant** : dans le contexte économique, le prix`{en}`**Restriction to the first quadrant**: in the economic context, the price` $p$ {fr}`et la demande`{en}`and the demand` $D$ {fr}`sont des grandeurs strictement positives. On a donc`{en}`are strictly positive quantities. We therefore have` $p>0$ {fr}`et`{en}`and` $D>0$, {fr}`ce qui signifie que seuls les points du premier quadrant sont économiquement pertinents. La courbe de demande se réduit donc à un quart de cercle de rayon`{en}`which means that only points in the first quadrant are economically relevant. The demand curve is therefore reduced to a quarter circle of radius` ${{ rayon }}$ {fr}`situé dans le premier quadrant.`{en}`located in the first quadrant.`
+
+{fr}`**Analyse des symétries** :`{en}`**Analysis of symmetries**:`
+
+- {fr}`**Symétrie par rapport à l'axe**`{en}`**Symmetry with respect to the axis**` $Op$ ($D \to -D$) : {fr}`cette transformation envoie un point`{en}`this transformation maps a point` $(p_0, D_0)$ {fr}`avec`{en}`with` $p_0>0$ {fr}`et`{en}`and` $D_0>0$ {fr}`sur le point`{en}`to the point` $(p_0, -D_0)$ {fr}`avec`{en}`with` $-D_0<0$. {fr}`Ce point sort du premier quadrant : cette symétrie n'est pas pertinente dans le contexte économique.`{en}`This point leaves the first quadrant: this symmetry is not relevant in the economic context.`
+
+- {fr}`**Symétrie par rapport à l'axe**`{en}`**Symmetry with respect to the axis**` $OD$ ($p \to -p$) : {fr}`cette transformation envoie un point`{en}`this transformation maps a point` $(p_0, D_0)$ {fr}`avec`{en}`with` $p_0>0$ {fr}`et`{en}`and` $D_0>0$ {fr}`sur le point`{en}`to the point` $(-p_0, D_0)$ {fr}`avec`{en}`with` $-p_0<0$. {fr}`Ce point sort du premier quadrant : cette symétrie n'est pas pertinente dans le contexte économique.`{en}`This point leaves the first quadrant: this symmetry is not relevant in the economic context.`
+
+- {fr}`**Symétrie par rapport à l'origine** (`{en}`**Symmetry with respect to the origin** (` $p \to -p$, $D \to -D$) : {fr}`cette transformation envoie un point`{en}`this transformation maps a point` $(p_0, D_0)$ {fr}`avec`{en}`with` $p_0>0$ {fr}`et`{en}`and` $D_0>0$ {fr}`sur le point`{en}`to the point` $(-p_0, -D_0)$ {fr}`avec`{en}`with` $-p_0<0$ {fr}`et`{en}`and` $-D_0<0$. {fr}`Ce point sort du premier quadrant : cette symétrie n'est pas pertinente dans le contexte économique.`{en}`This point leaves the first quadrant: this symmetry is not relevant in the economic context.`
+
+- {fr}`**Symétrie par rapport à la droite**`{en}`**Symmetry with respect to the line**` $D=p$ {fr}`(échanger`{en}`(exchange` $p$ {fr}`et`{en}`and` $D$) : {fr}`cette transformation envoie un point`{en}`this transformation maps a point` $(p_0, D_0)$ {fr}`avec`{en}`with` $p_0>0$ {fr}`et`{en}`and` $D_0>0$ {fr}`sur le point`{en}`to the point` $(D_0, p_0)$ {fr}`avec`{en}`with` $D_0>0$ {fr}`et`{en}`and` $p_0>0$. {fr}`Ce point reste dans le premier quadrant : c'est la seule symétrie pertinente dans le contexte économique.`{en}`This point remains in the first quadrant: this is the only relevant symmetry in the economic context.`
+
+{fr}`**Interprétation** : la symétrie par rapport à la droite`{en}`**Interpretation**: the symmetry with respect to the line` $D=p$ {fr}`signifie que si à un prix`{en}`means that if at a price` $p_0$ {fr}`correspond une demande`{en}`corresponds a demand` $D_0$ {fr}`(le point`{en}`(the point` $(p_0, D_0)$ {fr}`est sur la courbe), alors le point`{en}`is on the curve), then the point` $(D_0, p_0)$ {fr}`est également sur la courbe. Autrement dit, si la demande vaut`{en}`is also on the curve. In other words, if the demand equals` $D_0$ {fr}`unités au prix`{en}`units at price` $p_0$, {fr}`alors elle vaudra`{en}`then it will equal` $p_0$ {fr}`unités au prix`{en}`units at price` $D_0$. {fr}`Le modèle est donc réversible vis-à-vis de l'échange entre prix et demande : la relation entre`{en}`The model is therefore reversible with respect to the exchange between price and demand: the relationship between` $p$ {fr}`et`{en}`and` $D$ {fr}`est symétrique.`{en}`is symmetric.`
+::::
+
+::::{weightDistribution}
+:logic: 30
+:abstraction: 35
+:reasoning: 30
+:calculation: 5
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Unités minimales pour couvrir les coûts fixes`{en}`Minimum units to cover fixed costs`.md

@@ -0,0 +1,242 @@
+`````{exercise}
+:originalExerciseId: 7629a255-634b-11f1-a8a1-0ed8d3b012a9
+:title: {fr}`Unités minimales pour couvrir les coûts fixes`{en}`Minimum units to cover fixed costs`
+:modules: 
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: 
+:involvedConcepts: Solving_inequalities, Modeling_with_Functions  
+:originalSource: Session 2: Equations and Inequalities - Applications of Linear Inequalities (Erwan Lamy, ESCP Business School)
+:visibility: All
+:variations: 
+:comment: Version QCM — condition de non-perte, résolution et arrondi entier.
+:id: a3e299b2-6e47-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from sympy import Rational, ceiling, oo, Integer
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_format_number, pxsl_num
+from pyxiscience.Classes_Extensions import pxs_Interval
+
+config_standard = pxs_config()
+
+# Coûts fixes entiers, marge unitaire décimale (k/10), quotient non entier -> arrondi utile
+for _ in range(300):
+    fixedCost = rd.randint(400, 1000)
+    k = rd.randint(5, 30)
+    if (10 * fixedCost) % k != 0:
+        break
+
+margin = Rational(k, 10)
+qExact = Rational(fixedCost * 10, k)
+qMin = int(ceiling(qExact))
+
+# Précalcul de l'affichage
+marginAff = pxsl_num(margin, dec=2)
+fixedCostAff = pxsl_format_number(fixedCost)
+qApproxAff = pxsl_num(qExact, dec=2)
+qMinAff = pxsl_format_number(qMin)
+margeFoisQminAff = pxsl_num(margin * qMin, dec=2)
+
+# === Distracteurs MCQ (ajouts ; le code ci-dessus est inchangé) ===
+def _dedl(correct_l, cands, n=3):
+    seen = {correct_l}; out = []
+    for s in cands:
+        if s not in seen:
+            seen.add(s); out.append(s)
+        if len(out) == n:
+            break
+    return out
+
+if isinstance(qExact, Integer):
+    borne = qExact
+else:
+    borne = int(qExact) + 1
+
+# Q2 : entier minimal
+repBorne = pxsl_format_number(int(borne))
+_cB = [pxsl_format_number(int(borne) - 1),
+       pxsl_format_number(int(ceiling(Rational(fixedCost, k)))),
+       pxsl_format_number(int(borne) + 1),
+       pxsl_format_number(int(2 * borne))]
+_d = _dedl(repBorne, _cB)
+b1, b2, b3 = _d[0], _d[1], _d[2]
+
+# Q1 : intervalles
+def _ival(lo, hi, ol, oh):
+    s = pxs_Interval(lo, hi, ol, oh).print()
+    if pxs_lang == "fr":
+        s = s.replace(".", ",")
+    return s
+
+_qa = round(float(qExact), 2)
+interCorrect = _ival(_qa, oo, False, True)
+interD1 = _ival(_qa, oo, True, True)
+interD2 = _ival(-oo, _qa, True, False)
+interD3 = _ival(0, _qa, False, False)
+
+globals()
+````
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Une petite boulangerie a des coûts fixes hebdomadaires de`{en}`A small bakery has weekly fixed costs of` ${{fixedCostAff}}$ {fr}`€ (loyer, salaires, etc.). Chaque pain vendu génère une marge de contribution de`{en}`€ (rent, salaries, etc.). Each loaf of bread sold generates a contribution margin of` ${{marginAff}}$ {fr}`€ (prix de vente moins coût variable unitaire). On note`{en}`€ (selling price minus unit variable cost). Let` $q$ {fr}`le nombre de pains vendus par semaine. Quelle inéquation traduit que la marge de contribution totale couvre les coûts fixes (la boulangerie ne fait pas de perte) ?`{en}`be the number of loaves sold per week. Which inequality expresses that the total contribution margin covers the fixed costs (the bakery does not make a loss)?`
+::::
+
+::::{questionHint}
+{fr}`La marge de contribution totale est égale à`{en}`The total contribution margin is equal to` ${{marginAff}}\,q$. {fr}`La condition de non-perte correspond à une marge au moins égale aux coûts fixes.`{en}`The break-even condition corresponds to a margin at least equal to the fixed costs.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+${{marginAff}}\,q \geq {{fixedCostAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{marginAff}}\,q \leq {{fixedCostAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{marginAff}}\,q = {{fixedCostAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{fixedCostAff}}\,q \geq {{marginAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{fixedCostAff}}\,q \leq {{marginAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`La marge de contribution totale est`{en}`The total contribution margin is` ${{marginAff}}\,q$. {fr}`La condition de non-perte s'écrit :`{en}`The break-even condition is written as:`
+
+\begin{equation*}
+{{marginAff}}\,q \geq {{fixedCostAff}}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 30
+:reasoning: 35
+:calculation: 20
+::::
+:::::
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Résoudre l'inéquation`{en}`Solve the inequality` ${{marginAff}}\,q \geq {{fixedCostAff}}$ {fr}`(pour`{en}`(for` $q \geq 0${fr}`). Quel est l'ensemble des solutions sous forme d'intervalle ?`{en}`). What is the solution set in interval form?`
+::::
+
+::::{questionHint}
+{fr}`Diviser les deux membres par la marge unitaire, qui est positive : le sens est conservé.`{en}`Divide both sides by the unit margin, which is positive: the direction is preserved.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+${{interCorrect}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{interD1}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{interD2}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{interD3}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`On divise les deux membres par`{en}`We divide both sides by` ${{marginAff}} > 0$, {fr}`le sens est conservé :`{en}`the direction is preserved:`
+
+\begin{equation*}
+q \geq \dfrac{ {{fixedCostAff}} }{ {{marginAff}} } \approx {{qApproxAff}}.
+\end{equation*}
+
+{fr}`L'ensemble des solutions (pour`{en}`The solution set (for` $q \geq 0${fr}`) est`{en}`) is` ${{interCorrect}}$.
+::::
+
+::::{weightDistribution}
+:logic: 10
+:abstraction: 15
+:reasoning: 25
+:calculation: 50
+::::
+:::::
+
+:::::{question}
+:questionType: MCQ
+
+::::{questionStatement}
+{fr}`Quel est le nombre minimal de pains entiers que la boulangerie doit vendre pour atteindre le seuil de rentabilité ?`{en}`What is the minimum number of whole loaves that the bakery must sell to reach the break-even point?`
+::::
+
+::::{questionHint}
+{fr}`Le nombre de pains est un entier. Arrondir la solution à l'entier supérieur.`{en}`The number of loaves is an integer. Round the solution up to the next integer.`
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+${{repBorne}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{b1}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{b2}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${{b3}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`La quantité`{en}`The quantity` $q$ {fr}`doit être un entier. Comme`{en}`must be an integer. Since` $\dfrac{ {{fixedCostAff}} }{ {{marginAff}} } \approx {{qApproxAff}}$, {fr}`on arrondit à l'entier supérieur :`{en}`we round up to the next integer:` $q = {{borne}}$.
+
+{fr}`La boulangerie doit vendre au moins`{en}`The bakery must sell at least` ${{borne}}$ {fr}`pains par semaine pour ne pas faire de perte.`{en}`loaves per week to avoid making a loss.`
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 20
+:reasoning: 35
+:calculation: 25
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Valeurs absolues élémentaires 2`{en}`Elementary Absolute Values 2`.md

@@ -0,0 +1,215 @@
+`````{exercise}
+:id: 73dd633c-70a7-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: d140e232-68cb-11f1-a8a1-0ed8d3b012a9
+:title: {fr}`Valeurs absolues élémentaires 2`{en}`Elementary Absolute Values 2`
+:modules: fund_of_math_I_ESCP
+:recommendedExecutionTime: 20
+:level: Elementary
+:chap: chap_equations_Inequalities_absoluteValue_ESCP
+:involvedConcepts: Abs_Val
+:originalSource: ESCP
+:visibility: All
+:variations: 
+:comment: 
+
+```{python}
+
+import random as rd
+from sympy import *
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config
+from pyxiscience.Classes_Extensions import pxs_Interval
+from pyxiscience.Mes_fctions_d_analyse import pxsl_pow
+from pyxiscience.Mes_fctions_generalistes_bis import pxsl_latex_avec_formatage
+from pyxiscience.Mes_fctions_probabilistes_bis import pxsl_res_num
+
+from pyxiscience.Mes_fctions_generalistes_bis import  pxs_config
+
+config_standard = pxs_config()
+
+n, x, u = symbols('n x u')
+
+e1 = rd.randint(-10,-1)
+
+e2 = rd.randint(1,11)
+
+e31, e32 = rd.randint(1,11), rd.randint(-10,-1)
+e3 = Add(e31, e32, evaluate = False)
+e3_eval = Add(e31, e32, evaluate = True)
+
+e41 = rd.randint(1,11)
+e42 = rd.randint(-10,-1)
+e43 = rd.randint(2, 11)
+e4 = Mul(Rational(1,e43), Add(e41, e42, evaluate = False), evaluate = False) 
+e4_eval = Mul(Rational(1,e43), Add(e41, e42, evaluate = True), evaluate = True) 
+
+e51 = rd.choice([3, 5, 7])
+e52 = rd.choice([-2, -4, -8])
+e5 = Mul(e51, Rational(e52, e51), evaluate = False)
+e5_eval = Mul(e51, Rational(e52, e51), evaluate = True)
+
+e611, e612 = rd.randint(1,11), rd.randint(-10,-1)
+e61 = Add(e611, e612, evaluate = False)
+e621, e622 = rd.randint(1,11), rd.randint(-10,-1)
+e62 = Add(e621, e622, evaluate = False)
+e61_eval = Add(e611, e612, evaluate = True)
+e62_eval = Add(e621, e622, evaluate = True)
+
+e7 = rd.randint(1,11)
+
+e8 = rd.randint(1,11)
+
+a9 = rd.choice([2, 3, 5])
+if a9 == 2:
+    b9 = rd.choice([5, 7, 10])
+elif a9 == 3:
+    b9 = rd.choice([10, 11, 13])
+else:
+    b9 = rd.choice([26, 29, 31])
+
+a9, b9 = Min(a9, b9), Max(a9, b9)
+e9 = a9 - sqrt(b9)
+
+a10, b10 = Max(a9, b9), Min(a9, b9)
+e10 = sqrt(b10) - a10
+
+```
+
+{en}`Evaluate the absolute value expressions:`{fr}`Evaluer les valeurs abolues suivantes :`
+
+
+
+:::::{question}
+:questionType: FGQ
+:questionId: 5
+:questionIndex: 5
+:solution: [["ord","${{ latex(Abs(e61_eval) - Abs(e62_eval)) }}$"],["0"]]
+
+::::{questionStatement}
+\begin{equation*}
+\Big|{{ latex(e61) }}\Big| - \Big|{{ latex(e62) }}\Big| 
+\end{equation*}
+
+{fr}`Cette expression vaut :` {en}`This expression equals:` {input}`||120`
+::::
+
+::::{questionHint}
+{fr}`Calculez chaque valeur absolue séparément avant de soustraire.`{en}`Compute each absolute value separately before subtracting.`
+::::
+
+::::{displayedSolution}
+${{ latex(Abs(e61_eval) - Abs(e62_eval)) }}$
+::::
+
+::::{detailedSolution}
+{fr}`On calcule chaque valeur absolue séparément :`{en}`Compute each absolute value separately:`
+
+\begin{equation*}
+|{{ latex(e61) }}| &= |{{ e61_eval }}| \\[6pt]
+&= {{ Abs(e61_eval) }}
+\end{equation*}
+
+{fr}`et`{en}`and`
+
+\begin{equation*}
+|{{ latex(e62) }}| &= |{{ e62_eval }}| \\[6pt]
+&= {{ Abs(e62_eval) }}.
+\end{equation*}
+
+{fr}`La soustraction donne`{en}`Subtracting gives`
+
+\begin{equation*}
+|{{ latex(e61) }}| - |{{ latex(e62) }}| &= {{ Abs(e61_eval) }} - {{ Abs(e62_eval) }} \\[6pt]
+&={{ latex(Abs(e61_eval) - Abs(e62_eval)) }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 25
+:logic: 25
+:abstraction: 15
+:calculation: 35
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 8
+:questionIndex: 8
+:solution: [["ord","${{ latex(Abs(e9)) }}$"],["0"]]
+
+::::{questionStatement}
+\begin{equation*}
+|{{ latex(e9) }}|
+\end{equation*}
+
+{fr}`Cette expression vaut :` {en}`This expression equals:` {input}`||120`
+::::
+
+::::{questionHint}
+{fr}`Comparez l'entier avec $\sqrt{b}$ pour déterminer le signe de l'expression à l'intérieur de la valeur absolue.`{en}`Compare the integer with $\sqrt{b}$ to decide the sign of the expression inside the absolute value.`
+::::
+
+::::{displayedSolution}
+${{ latex(Abs(e9)) }}$
+::::
+
+::::{detailedSolution}
+{fr}`L'expression à l'intérieur de la valeur absolue est`{en}`The expression inside the absolute value is` ${{ latex(e9) }}$.\
+{fr}`Puisque`{en}`Since` ${{ a9 }} < \sqrt{{{ b9 }}}$, {fr}`la quantité`{en}`the quantity` ${{ latex(e9) }}$ {fr}`est négative.`{en}`is negative.`\
+{fr}`Par conséquent`{en}`Therefore`
+
+\begin{equation*}
+|{{ latex(e9) }}| &= -\big({{ latex(e9) }}\big) \\[6pt]
+&= {{ latex(Abs(e9)) }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 25
+:logic: 25
+:abstraction: 25
+:calculation: 25
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 9
+:questionIndex: 9
+:solution: [["ord","${{ latex(Abs(e10)) }}$"],["0"]]
+
+::::{questionStatement}
+\begin{equation*}
+|{{ latex(e10) }}|
+\end{equation*}
+
+{fr}`Cette expression vaut :` {en}`This expression equals:` {input}`||120`
+::::
+
+::::{questionHint}
+{fr}`Déterminez si $\sqrt{b}$ est plus petit ou plus grand que l'entier devant lui.`{en}`Determine whether $\sqrt{b}$ is smaller or larger than the integer in front of it.`
+::::
+
+::::{displayedSolution}
+${{ latex(Abs(e10)) }}$
+::::
+
+::::{detailedSolution}
+{fr}`À l'intérieur de la valeur absolue on a`{en}`Inside the absolute value one has` ${{ latex(e10) }}$.\
+{fr}`Puisque`{en}`Because` ${{ a10 }} > \sqrt{{{ b10 }}}$, {fr}`l'expression`{en}`the expression` ${{ latex(e10) }}$ {fr}`est négative.`{en}`is negative.`\
+{fr}`En conséquence`{en}`Consequently`
+
+\begin{equation*}
+|{{ latex(e10) }}| &= -\big({{ latex(e10) }}\big) \\[6pt]
+&= {{ latex(Abs(e10)) }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 25
+:logic: 25
+:abstraction: 25
+:calculation: 25
+::::
+:::::
+`````

app/knowledge/fewshots/declinaisons/{fr}`Valeurs absolues élémentaires 3`{en}`Elementary Absolute Values 3`.md

@@ -0,0 +1,163 @@
+`````{exercise}
+:id: 9af8828d-70a7-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 2ce83c2b-68cc-11f1-a8a1-0ed8d3b012a9
+:title: {fr}`Valeurs absolues élémentaires 3`{en}`Elementary Absolute Values 3`
+:modules: fund_of_math_I_ESCP
+:recommendedExecutionTime: 5
+:level: Elementary
+:chap: chap_equations_Inequalities_absoluteValue_ESCP
+:involvedConcepts: Abs_Val
+:originalSource: ESCP
+:visibility: All
+:variations: 
+:comment: 
+
+```{python}
+
+import random as rd
+from sympy import *
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config
+from pyxiscience.Classes_Extensions import pxs_Interval
+from pyxiscience.Mes_fctions_d_analyse import pxsl_pow
+from pyxiscience.Mes_fctions_generalistes_bis import pxsl_latex_avec_formatage
+from pyxiscience.Mes_fctions_probabilistes_bis import pxsl_res_num
+
+from pyxiscience.Mes_fctions_generalistes_bis import  pxs_config
+
+config_standard = pxs_config()
+
+n, x, u = symbols('n x u')
+
+e1 = rd.randint(-10,-1)
+
+e2 = rd.randint(1,11)
+
+e31, e32 = rd.randint(1,11), rd.randint(-10,-1)
+e3 = Add(e31, e32, evaluate = False)
+e3_eval = Add(e31, e32, evaluate = True)
+
+e41 = rd.randint(1,11)
+e42 = rd.randint(-10,-1)
+e43 = rd.randint(2, 11)
+e4 = Mul(Rational(1,e43), Add(e41, e42, evaluate = False), evaluate = False) 
+e4_eval = Mul(Rational(1,e43), Add(e41, e42, evaluate = True), evaluate = True) 
+
+e51 = rd.choice([3, 5, 7])
+e52 = rd.choice([-2, -4, -8])
+e5 = Mul(e51, Rational(e52, e51), evaluate = False)
+e5_eval = Mul(e51, Rational(e52, e51), evaluate = True)
+
+e611, e612 = rd.randint(1,11), rd.randint(-10,-1)
+e61 = Add(e611, e612, evaluate = False)
+e621, e622 = rd.randint(1,11), rd.randint(-10,-1)
+e62 = Add(e621, e622, evaluate = False)
+e61_eval = Add(e611, e612, evaluate = True)
+e62_eval = Add(e621, e622, evaluate = True)
+
+e7 = rd.randint(1,11)
+
+e8 = rd.randint(1,11)
+
+a9 = rd.choice([2, 3, 5])
+if a9 == 2:
+    b9 = rd.choice([5, 7, 10])
+elif a9 == 3:
+    b9 = rd.choice([10, 11, 13])
+else:
+    b9 = rd.choice([26, 29, 31])
+
+a9, b9 = Min(a9, b9), Max(a9, b9)
+e9 = a9 - sqrt(b9)
+
+a10, b10 = Max(a9, b9), Min(a9, b9)
+e10 = sqrt(b10) - a10
+
+```
+
+{en}`Evaluate the absolute value expressions:`{fr}`Evaluer les valeurs abolues suivantes :`
+
+
+
+:::::{question}
+:questionType: FGQ
+:questionId: 6
+:questionIndex: 6
+:solution: [["ord","${{ -e7 }}$","${{ e7 }}$"],["0","0"]]
+
+::::{questionStatement}
+\begin{equation*}
+|x| < {{ e7 }}
+\end{equation*}
+
+{fr}`Compléter l'encadrement donnant l'ensemble des solutions :` {en}`Complete the bounds giving the solution set:`\
+\
+{input}`||80` $< x <$ {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`$|x|<a$ signifie que $x$ se trouve strictement entre $-a$ et $a$.`{en}`$|x|<a$ means $x$ lies strictly between $-a$ and $a$.`
+::::
+
+::::{displayedSolution}
+$-{{ e7 }} < x < {{ e7 }}$
+::::
+
+::::{detailedSolution}
+{fr}`L'inéquation`{en}`The inequality` $|x| < {{ e7 }}$ {fr}`signifie que`{en}`states that` $x$ {fr}`se trouve strictement entre`{en}`lies strictly between` $-{{ e7 }}$ {fr}`et`{en}`and` ${{ e7 }}$.\
+{fr}`Ainsi`{en}`Thus`
+
+\begin{equation*}
+-{{ e7 }} < x < {{ e7 }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 30
+:logic: 30
+:abstraction: 30
+:calculation: 10
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 7
+:questionIndex: 7
+:solution: [["ord","${{ -e8 }}$","${{ e8 }}$"],["0","0"]]
+
+::::{questionStatement}
+\begin{equation*}
+|x| \leq {{ e8 }}
+\end{equation*}
+
+{fr}`Compléter l'encadrement donnant l'ensemble des solutions :` {en}`Complete the bounds giving the solution set:`\
+\
+{input}`||80` $\leq x \leq$ {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`$|x|\le a$ permet à $x$ d'être égal à $-a$ ou $a$.`{en}`$|x|\le a$ allows $x$ to equal $-a$ or $a$.`
+::::
+
+::::{displayedSolution}
+$-{{ e8 }} \leq x \leq {{ e8 }}$
+::::
+
+::::{detailedSolution}
+{fr}`L'inéquation large`{en}`The non-strict inequality` $|x| \leq {{ e8 }}$ {fr}`inclut les bornes, donc`{en}`includes the endpoints, hence`
+
+\begin{equation*}
+-{{ e8 }} \leq x \leq {{ e8 }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 30
+:logic: 30
+:abstraction: 30
+:calculation: 10
+::::
+:::::
+
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Valeurs absolues élémentaires`{en}`Elementary Absolute Values`.md

@@ -0,0 +1,283 @@
+`````{exercise}
+:id: c84654fa-70a6-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 834b79ee-fc00-47e7-921b-83e4524d24b0
+:title: {fr}`Valeurs absolues élémentaires`{en}`Elementary Absolute Values`
+:modules: fund_of_math_I_ESCP
+:recommendedExecutionTime: 20
+:level: Elementary
+:chap: chap_equations_Inequalities_absoluteValue_ESCP
+:involvedConcepts: Solving_inequalities, Abs_Val
+:originalSource: ESCP
+:visibility: All
+:variations: 
+:comment: 
+
+```{python}
+
+import random as rd
+from sympy import *
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config
+from pyxiscience.Classes_Extensions import pxs_Interval
+from pyxiscience.Mes_fctions_d_analyse import pxsl_pow
+from pyxiscience.Mes_fctions_generalistes_bis import pxsl_latex_avec_formatage
+from pyxiscience.Mes_fctions_probabilistes_bis import pxsl_res_num
+
+from pyxiscience.Mes_fctions_generalistes_bis import  pxs_config
+
+config_standard = pxs_config()
+
+n, x, u = symbols('n x u')
+
+e1 = rd.randint(-10,-1)
+
+e2 = rd.randint(1,11)
+
+e31, e32 = rd.randint(1,11), rd.randint(-10,-1)
+e3 = Add(e31, e32, evaluate = False)
+e3_eval = Add(e31, e32, evaluate = True)
+
+e41 = rd.randint(1,11)
+e42 = rd.randint(-10,-1)
+e43 = rd.randint(2, 11)
+e4 = Mul(Rational(1,e43), Add(e41, e42, evaluate = False), evaluate = False) 
+e4_eval = Mul(Rational(1,e43), Add(e41, e42, evaluate = True), evaluate = True) 
+
+e51 = rd.choice([3, 5, 7])
+e52 = rd.choice([-2, -4, -8])
+e5 = Mul(e51, Rational(e52, e51), evaluate = False)
+e5_eval = Mul(e51, Rational(e52, e51), evaluate = True)
+
+e611, e612 = rd.randint(1,11), rd.randint(-10,-1)
+e61 = Add(e611, e612, evaluate = False)
+e621, e622 = rd.randint(1,11), rd.randint(-10,-1)
+e62 = Add(e621, e622, evaluate = False)
+e61_eval = Add(e611, e612, evaluate = True)
+e62_eval = Add(e621, e622, evaluate = True)
+
+e7 = rd.randint(1,11)
+
+e8 = rd.randint(1,11)
+
+a9 = rd.choice([2, 3, 5])
+if a9 == 2:
+    b9 = rd.choice([5, 7, 10])
+elif a9 == 3:
+    b9 = rd.choice([10, 11, 13])
+else:
+    b9 = rd.choice([26, 29, 31])
+
+a9, b9 = Min(a9, b9), Max(a9, b9)
+e9 = a9 - sqrt(b9)
+
+a10, b10 = Max(a9, b9), Min(a9, b9)
+e10 = sqrt(b10) - a10
+
+```
+
+{en}`Evaluate the absolute value expressions:`{fr}`Evaluer les valeurs abolues suivantes :`
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ Abs(e1) }}$"],["0"]]
+
+::::{questionStatement}
+\begin{equation*}
+|{{ e1 }}|
+\end{equation*}
+
+{fr}`Cette expression vaut :` {en}`This expression equals:` {input}`||120`
+::::
+
+::::{questionHint}
+{fr}`Rappel : la valeur absolue d'un nombre négatif est son opposé.`{en}`Remember: the absolute value of a negative number is its opposite.`
+::::
+
+::::{displayedSolution}
+${{ Abs(e1) }}$
+::::
+
+::::{detailedSolution}
+{fr}`La valeur absolue d'un nombre réel est sa distance à zéro sur la droite réelle, elle est donc toujours positive ou nulle.`{en}`The absolute value of a real number is its distance from zero on the real line, hence it is always non–negative.`\
+{fr}`Puisque`{en}`Since` ${{e1}}$ {fr}`est négatif, on change son signe :`{en}`is negative, one changes its sign:`
+
+\begin{equation*}
+|{{e1}}| &= -({{e1}}) \\[6pt]
+&=  {{ Abs(e1) }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 10
+:logic: 20
+:abstraction: 10
+:calculation: 60
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ Abs(e2) }}$"],["0"]]
+
+::::{questionStatement}
+\begin{equation*}
+|{{ e2 }}|
+\end{equation*}
+
+{fr}`Cette expression vaut :` {en}`This expression equals:` {input}`||120`
+::::
+
+::::{questionHint}
+{fr}`La valeur absolue d'un nombre positif est le nombre lui-même.`{en}`The absolute value of a positive number is the number itself.`
+::::
+
+::::{displayedSolution}
+${{ Abs(e2) }}$
+::::
+
+::::{detailedSolution}
+{fr}`Le nombre`{en}`The number` ${{e2}}$ {fr}`est positif, donc sa valeur absolue est égale à lui-même :`{en}`is positive, therefore its absolute value equals itself:`
+
+\begin{equation*}
+|{{e2}}| = {{ Abs(e2) }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 10
+:logic: 20
+:abstraction: 10
+:calculation: 60
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ Abs(e3) }}$"],["0"]]
+
+::::{questionStatement}
+\begin{equation*}
+|{{ e3 }}|
+\end{equation*}
+
+{fr}`Cette expression vaut :` {en}`This expression equals:` {input}`||120`
+::::
+
+::::{questionHint}
+{fr}`Additionnez d'abord les deux entiers, puis prenez la valeur absolue du résultat.`{en}`First add the two integers, then take the absolute value of the result.`
+::::
+
+::::{displayedSolution}
+$\ds {{ Abs(e3) }}$
+::::
+
+::::{detailedSolution}
+{fr}`On calcule d'abord la somme à l'intérieur de la valeur absolue :`{en}`First one computes the sum inside the absolute value:`
+
+\begin{equation*}
+{{ e3 }} = {{ e3_eval }}.
+\end{equation*}
+
+{fr}`La valeur absolue de ce résultat est donc`{en}`The absolute value of this result is therefore`
+
+\begin{equation*}
+\left|{{ e3_eval }}\right| = {{ Abs(e3) }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 15
+:logic: 15
+:abstraction: 15
+:calculation: 55
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ latex(Abs(e4)) }}$"],["0"]]
+
+::::{questionStatement}
+\begin{equation*}
+\left|{{ latex(e4) }}\right|
+\end{equation*}
+
+{fr}`Cette expression vaut :` {en}`This expression equals:` {input}`||120`
+::::
+
+::::{questionHint}
+{fr}`Calculez la somme entre parenthèses avant de diviser par le dénominateur, puis appliquez la valeur absolue.`{en}`Compute the sum in parentheses before dividing by the denominator, then apply the absolute value.`
+::::
+
+::::{displayedSolution}
+$\ds {{ latex(Abs(e4)) }}$
+::::
+
+::::{detailedSolution}
+{fr}`On commence par évaluer l'expression à l'intérieur de la valeur absolue :`{en}`Begin by evaluating the expression inside the absolute value:`
+
+\begin{equation*}
+\frac{1}{{{ e43 }}}\big({{ e42 }}+{{ e41 }}\big) &= \frac{1}{{{ e43 }}}\cdot {{ pxsl_pow(e41+e42) }} \\[10pt]
+&= {{ latex(e4_eval) }}.
+\end{equation*}
+
+{fr}`La valeur absolue est alors`{en}`The absolute value is then`
+
+\begin{equation*}
+\Big|\frac{1}{{{ e43 }}}\big({{ e42 }}+{{ e41 }}\big)\Big| &= \left|{{ latex(e4_eval) }}\right| \\[10pt]
+&= {{ latex(Abs(e4)) }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 20
+:logic: 20
+:abstraction: 20
+:calculation: 40
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ latex(Abs(e5)) }}$"],["0"]]
+
+::::{questionStatement}
+\begin{equation*}
+\Big|{{ latex(e5) }}\Big|
+\end{equation*}
+
+{fr}`Cette expression vaut :` {en}`This expression equals:` {input}`||120`
+::::
+
+::::{questionHint}
+{fr}`Le facteur commun au numérateur et au dénominateur se simplifie complètement.`{en}`The common factor in numerator and denominator cancels out completely.`
+::::
+
+::::{displayedSolution}
+${{ latex(Abs(e5)) }}$
+::::
+
+::::{detailedSolution}
+{fr}`La fraction se simplifie d'abord :`{en}`The fraction simplifies first:`
+
+\begin{equation*}
+\frac{{{ e51 }}\cdot {{ pxsl_pow(e52) }}}{{{ e51 }}} = {{ e5_eval }}.
+\end{equation*}
+
+{fr}`La valeur absolue devient donc`{en}`Hence the absolute value becomes`
+
+\begin{equation*}
+\Big|\frac{{{ e51 }}\cdot {{ pxsl_pow(e52) }}}{{{ e51 }}}\Big| &= \left|{{ e5_eval }}\right| \\[10pt]
+&= {{ latex(Abs(e5)) }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:reasoning: 20
+:logic: 20
+:abstraction: 20
+:calculation: 40
+::::
+:::::
+
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Zone de rentabilité symétrique autour de l'optimum`{en}`Symmetric profitability zone around the optimum`.md

@@ -0,0 +1,236 @@
+`````{exercise}
+:title: {fr}`Zone de rentabilité symétrique autour de l'optimum`{en}`Symmetric profitability zone around the optimum`
+:modules: 
+:recommendedExecutionTime: 15
+:level: Elementary
+:chap: chap_realFunctions_Graphs_graphSymmetries_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Appliqué (économie & gestion) : axe de symétrie et maximum d'une parabole de profit, seuils de rentabilité par factorisation, et symétrie des seuils par rapport à l'optimum (sans discriminant ni Viète).
+:id: df8f8e47-7480-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: e1c9656e-6409-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from sympy import symbols, latex
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_latex_coefficient as lc
+
+config_standard = pxs_config()
+q = symbols('q')
+
+# qStar entier, q1 < qStar < q2 symétriques, a<0, racines q1,q2
+# coefficient négatif
+a = rd.choice([-5, -4, -3, -2, -1])
+
+# choisir q_star directement compatible avec 20 <= b <= 60
+# b = -2 a q_star
+# donc q_star = b / (-2a)
+
+possible_qstars = []
+
+for q in range(3, 16):
+    b = -2 * a * q
+    if 20 <= b <= 60:
+        possible_qstars.append(q)
+
+qStar = rd.choice(possible_qstars)
+
+# construction des racines symétriques
+q1 = rd.randint(1, qStar - 2)
+q2 = 2 * qStar - q1
+
+# coefficients
+b = -2 * a * qStar
+c = a * q1 * q2
+
+Pi = a*q**2 + b*q + c
+profitMax = a * qStar**2 + b * qStar + c
+somme_racines = q1 + q2
+produit_racines = q1 * q2
+factAff = f"(q-{q1})(q-{q2})"
+distance = qStar - q1
+
+# Rendus
+aLcAff = lc(a)
+aMulAff = lc(a, ones=True)
+bSignAff = lc(b, sign=True)
+cSignAff = lc(c, ones=True, sign=True)
+twoAAff = latex(2*a)
+aQStarSqAff = latex(a*qStar**2)
+bQStarSignAff = lc(b*qStar, ones=True, sign=True)
+sommeRacines = somme_racines
+produitRacines = produit_racines
+negSommeSignAff = lc(-somme_racines, sign=True)
+produitSignAff = lc(produit_racines, ones=True, sign=True)
+q1PlusQ2 = q1 + q2
+
+globals()
+````
+
+{fr}`Une entreprise modélise son profit (en milliers d'euros) par`{en}`A company models its profit (in thousands of euros) by` $\Pi(q)={{ aLcAff }}q^2{{ bSignAff }}q{{ cSignAff }}$, $q\geq 0$ {fr}`(quantité en centaines d'unités).`{en}`(quantity in hundreds of units).`
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ qStar }}$"],["0"]]
+:questionId: 0
+:questionIndex: 0
+
+::::{questionStatement}
+{fr}`Déterminer l'axe de symétrie`{en}`Determine the axis of symmetry` $q^*$ {fr}`de la parabole.`{en}`of the parabola.`
+
+$q^* =$ {input}`||90`
+::::
+
+::::{questionHint}
+{fr}`Appliquer`{en}`Apply` $q^*=-\dfrac{b}{2a}$ {fr}`avec`{en}`with` $a={{ a }}$, $b={{ b }}$.
+::::
+
+::::{displayedSolution}
+$q^* = {{ qStar }}$
+::::
+
+::::{detailedSolution}
+{fr}`Règle utilisée : axe de symétrie`{en}`Rule used: axis of symmetry` $q^*=-\dfrac{b}{2a}$.
+
+\begin{equation*}
+q^* &= -\frac{ {{ b }} }{2\times({{ a }})} \\
+&= -\frac{ {{ b }} }{ {{ twoAAff }} } \\
+&= {{ qStar }}.
+\end{equation*}
+
+{fr}`L'axe de symétrie est`{en}`The axis of symmetry is` $q={{ qStar }}$.
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 25
+:reasoning: 30
+:calculation: 30
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ profitMax }}$"],["0"]]
+:questionId: 1
+:questionIndex: 1
+
+::::{questionStatement}
+{fr}`Calculer le profit maximal`{en}`Calculate the maximum profit` $\Pi(q^*)$.
+
+$\Pi(q^*) =$ {input}`||90`
+::::
+
+::::{questionHint}
+{fr}`Substituer`{en}`Substitute` $q={{ qStar }}$ {fr}`dans`{en}`in` $\Pi(q)$ ; {fr}`comme`{en}`since` $a<0$, {fr}`c'est un maximum.`{en}`it is a maximum.`
+::::
+
+::::{displayedSolution}
+$\Pi(q^*) = {{ profitMax }}$
+::::
+
+::::{detailedSolution}
+{fr}`On évalue`{en}`We evaluate` $\Pi$ {fr}`au sommet.`{en}`at the vertex.`
+
+\begin{equation*}
+\Pi({{ qStar }}) &= {{ aMulAff }}\times {{ qStar }}^2 {{ bSignAff }}\times {{ qStar }} {{ cSignAff }} \\
+&= {{ aQStarSqAff }} {{ bQStarSignAff }} {{ cSignAff }} \\
+&= {{ profitMax }}.
+\end{equation*}
+
+{fr}`Le profit maximal est de`{en}`The maximum profit is` ${{ profitMax }}$ {fr}`milliers d'euros.`{en}`thousands of euros.`
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 25
+:reasoning: 30
+:calculation: 30
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["notord","${{ q1 }}$","${{ q2 }}$"],["0","0"]]
+:questionId: 2
+:questionIndex: 2
+
+::::{questionStatement}
+{fr}`Déterminer les deux seuils de rentabilité`{en}`Determine the two break-even thresholds` $q_1$ {fr}`et`{en}`and` $q_2$ ($\Pi(q)=0$) {fr}`par factorisation.`{en}`by factorization.`
+
+$q_1 =$ {input}`||90` {fr}`et`{en}`and` $q_2 =$ {input}`||90`
+::::
+
+::::{questionHint}
+{fr}`Diviser par`{en}`Divide by` ${{ a }}$ {fr}`pour obtenir`{en}`to obtain` $q^2{{ negSommeSignAff }}q{{ produitSignAff }}=0$, {fr}`puis factoriser (deux nombres de produit`{en}`then factor (two numbers with product` ${{ produitRacines }}$ {fr}`et de somme`{en}`and sum` ${{ sommeRacines }}$).
+::::
+
+::::{displayedSolution}
+$q_1 = {{ q1 }}$ {fr}`et`{en}`and` $q_2 = {{ q2 }}$
+::::
+
+::::{detailedSolution}
+{fr}`On résout`{en}`We solve` $\Pi(q)=0$ {fr}`par factorisation (sans discriminant).`{en}`by factorization (without discriminant).`
+
+\begin{equation*}
+{{ aLcAff }}q^2 {{ bSignAff }}q {{ cSignAff }} &= 0 \\
+q^2 {{ negSommeSignAff }}q {{ produitSignAff }} &= 0 \\
+{{ factAff }} &= 0.
+\end{equation*}
+
+\begin{equation*}
+q_1 &= {{ q1 }} \quad\text{{fr}`et`{en}`and`}\quad q_2 = {{ q2 }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 25
+:reasoning: 30
+:calculation: 25
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ qStar }}$"],["0"]]
+:questionId: 3
+:questionIndex: 3
+
+::::{questionStatement}
+{fr}`Montrer que`{en}`Show that` $q_1$ {fr}`et`{en}`and` $q_2$ {fr}`sont symétriques par rapport à`{en}`are symmetric with respect to` $q^*$, {fr}`puis interpréter : que peut-on dire de la zone de rentabilité de l'entreprise ?`{en}`then interpret: what can be said about the company's profitability zone?`
+
+$\dfrac{q_1+q_2}{2} =$ {input}`||90`
+::::
+
+::::{questionHint}
+{fr}`Calculer la moyenne`{en}`Calculate the average` $\dfrac{q_1+q_2}{2}$ {fr}`et la comparer à`{en}`and compare it to` $q^*$.
+::::
+
+::::{displayedSolution}
+$\dfrac{q_1+q_2}{2} = {{ qStar }}$
+::::
+
+::::{detailedSolution}
+{fr}`Règle utilisée : l'axe de symétrie d'une parabole passe par le milieu de ses deux zéros.`{en}`Rule used: the axis of symmetry of a parabola passes through the midpoint of its two zeros.`
+
+\begin{equation*}
+\frac{q_1 + q_2}{2} &= \frac{ {{ q1 }} + {{ q2 }} }{2} \\
+&= \frac{ {{ q1PlusQ2 }} }{2} \\
+&= {{ qStar }}.
+\end{equation*}
+
+{fr}`Les deux seuils sont symétriques par rapport à`{en}`The two thresholds are symmetric with respect to` $q^*={{ qStar }}$. {fr}`L'entreprise est rentable`{en}`The company is profitable` ($\Pi>0$) {fr}`pour`{en}`for` $q$ {fr}`entre`{en}`between` ${{ q1 }}$ {fr}`et`{en}`and` ${{ q2 }}$. {fr}`La zone de rentabilité est symétrique autour de l'optimum : les deux seuils sont à égale distance`{en}`The profitability zone is symmetric around the optimum: the two thresholds are at equal distance` (${{ distance }}$ {fr}`centaines d'unités) de la quantité optimale, donc l'entreprise dispose de la même marge de manœuvre en sous-production ou en surproduction.`{en}`hundreds of units) from the optimal quantity, so the company has the same margin of maneuver in underproduction or overproduction.`
+::::
+
+::::{weightDistribution}
+:logic: 30
+:abstraction: 30
+:reasoning: 35
+:calculation: 5
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Équations exponentielles et logarithmiques`{en}`Exponential and Logarithmic Equations`.md

@@ -0,0 +1,302 @@
+`````{exercise}
+:title: {fr}`Équations exponentielles et logarithmiques`{en}`Exponential and Logarithmic Equations`
+:modules: 
+:recommendedExecutionTime: 15
+:level: Elementary
+:chap: chap_expLogFunctions_solvingExpLogEquations_ESCP
+:involvedConcepts: Domain_of_function, solving_equ_with_ln, propers_of_log_and_exp
+:originalSource: % Exercise source
+:visibility: All
+:comment: % Exercise comment (optional)
+:originalExerciseId: b41f6b56-65a4-11f1-a8a1-0ed8d3b012a9
+:id: 91f28cdc-74bf-11f1-a8a1-0ed8d3b012a9
+
+```{python}
+import random as rd
+from sympy import Symbol, Rational, ln, exp, latex, simplify
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_latex_coefficient as lc
+config_standard = pxs_config()
+
+# ═══════════════════════════════════════════════════════════════════════════
+# MÉTHODE CONSTRUCTIVE — partir de la réponse
+# ═══════════════════════════════════════════════════════════════════════════
+
+# Question 1 : e^x = a1
+# Réponse : x = ln(a1) avec a1 > 0, a1 ≠ 1
+# On tire d'abord la réponse (ln(a1)), puis on fabrique l'énoncé (e^x = a1)
+a1 = rd.choice([i for i in range(2, 11) if i != 1])
+sol1 = ln(a1)
+sol1Aff = latex(sol1, **config_standard)
+a1Aff = latex(a1, **config_standard)
+
+# Question 2 : e^(coef_exp·x) = a2
+# Réponse : x = ln(a2)/coef_exp avec a2 > 0, a2 ≠ 1, coef_exp ≥ 2
+# On tire d'abord coef_exp et a2, puis on calcule la réponse
+coefExp = rd.randint(2, 5)
+a2 = rd.choice([i for i in range(2, 11) if i != 1])
+sol2 = ln(a2) / coefExp
+sol2Aff = latex(sol2, **config_standard)
+a2Aff = latex(a2, **config_standard)
+coefExpAff = latex(coefExp, **config_standard)
+
+# Affichage de l'exposant dans l'énoncé (2x, 3x, etc.)
+x = Symbol('x')
+expExprAff = latex(coefExp * x, **config_standard)
+
+globals()
+```
+
+{fr}`Résoudre dans`{en}`Solve in` $\mathbb{R}$ {fr}`les équations suivantes :`{en}`the following equations:`
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ sol1Aff }}$"],["0"]]
+
+::::{questionStatement}
+$e^x = {{ a1Aff }}$
+
+$x =$ {input}`||150`
+::::
+
+::::{questionHint}
+{fr}`Appliquer l'équivalence fondamentale entre exponentielle et logarithme.`{en}`Apply the fundamental equivalence between exponential and logarithm.`
+::::
+
+::::{displayedSolution}
+$x = {{ sol1Aff }}$
+::::
+
+::::{detailedSolution}
+{fr}`On rappelle l'équivalence fondamentale : pour tout`{en}`Recall the fundamental equivalence: for all` $x \in \mathbb{R}$ {fr}`et tout`{en}`and all` $y > 0$,
+
+\begin{equation*}
+e^x = y \iff x = \ln y.
+\end{equation*}
+
+{fr}`De même, pour`{en}`Similarly, for` $u > 0$ : $\ln u = k \iff u = e^k$.
+
+{fr}`L'équation`{en}`The equation` $e^x = {{ a1Aff }}$ {fr}`est définie pour tout`{en}`is defined for all` $x \in \mathbb{R}$. {fr}`Par l'équivalence fondamentale :`{en}`By the fundamental equivalence:`
+
+\begin{equation*}
+e^x = {{ a1Aff }} \iff x = \ln {{ a1Aff }}.
+\end{equation*}
+
+{fr}`La solution est`{en}`The solution is` $x = {{ sol1Aff }}$.
+::::
+
+::::{weightDistribution}
+:reasoning: 20
+:logic: 30
+:abstraction: 20
+:calculation: 30
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ sol2Aff }}$"],["0"]]
+
+::::{questionStatement}
+$e^{ {{ expExprAff }} } = {{ a2Aff }}$
+
+$x =$ {input}`||150`
+::::
+
+::::{questionHint}
+{fr}`Isoler l'exposant en appliquant le logarithme népérien des deux côtés, puis diviser par le coefficient de`{en}`Isolate the exponent by applying the natural logarithm to both sides, then divide by the coefficient of` $x$.
+::::
+
+::::{displayedSolution}
+$x = {{ sol2Aff }}$
+::::
+
+::::{detailedSolution}
+{fr}`L'équation`{en}`The equation` $e^{ {{ expExprAff }} } = {{ a2Aff }}$ {fr}`est définie pour tout`{en}`is defined for all` $x \in \mathbb{R}$. {fr}`On applique l'équivalence fondamentale :`{en}`We apply the fundamental equivalence:`
+
+\begin{equation*}
+e^{ {{ expExprAff }} } = {{ a2Aff }} &\iff {{ expExprAff }} = \ln {{ a2Aff }} \\
+&\iff x = \dfrac{\ln {{ a2Aff }} }{ {{ coefExpAff }} }.
+\end{equation*}
+
+{fr}`La solution est`{en}`The solution is` $x = {{ sol2Aff }}$.
+::::
+
+::::{weightDistribution}
+:reasoning: 25
+:logic: 25
+:abstraction: 20
+:calculation: 30
+::::
+:::::
+
+```{python}
+import random as rd
+from sympy import Symbol, Rational, ln, exp, latex, simplify
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_latex_coefficient as lc
+config_standard = pxs_config()
+
+# ═══════════════════════════════════════════════════════════════════════════
+# MÉTHODE CONSTRUCTIVE — partir de la réponse
+# ═══════════════════════════════════════════════════════════════════════════
+
+# Question 3 : ln(x) = k
+# Réponse : x = e^k avec k entier ≥ 2
+# On tire d'abord k (qui détermine la réponse), puis on fabrique l'énoncé
+k = rd.randint(2, 6)
+sol3 = exp(k)
+sol3Aff = latex(sol3, **config_standard)
+kAff = latex(k, **config_standard)
+
+# Question 4 : ln(coefLn·x - constLn) = valLn
+# Réponse : x = (e^valLn + constLn) / coefLn
+# On tire d'abord coefLn, valLn, puis constLn tel que la solution soit > constLn/coefLn
+# (pour garantir le domaine de définition)
+coefLn = rd.randint(2, 5)
+valLn = rd.choice([0, 1, -1])
+# Pour que x > constLn/coefLn, on tire constLn puis on vérifie que la solution construite
+# satisfait automatiquement cette condition (construction directe)
+# Solution : x = (e^valLn + constLn) / coefLn
+# Domaine : coefLn·x - constLn > 0 ⟺ x > constLn/coefLn
+# On choisit constLn < coefLn·e^valLn pour garantir que la solution est dans le domaine
+constLn = rd.randint(1, min(4, coefLn - 1))
+
+# Calcul de la solution
+sol4Num = exp(valLn) + constLn
+sol4Den = coefLn
+# Simplification si possible
+from math import gcd
+g = gcd(int(sol4Num) if sol4Num == int(sol4Num) else 1, sol4Den)
+sol4NumSimp = sol4Num / g
+sol4DenSimp = sol4Den / g
+
+# Calcul de la borne du domaine
+borneNum = constLn
+borneDen = coefLn
+gBorne = gcd(borneNum, borneDen)
+borneNumSimp = borneNum // gBorne
+borneDenSimp = borneDen // gBorne
+
+# Affichage de la borne du domaine
+if borneDenSimp == 1:
+    borneAff = latex(borneNumSimp, **config_standard)
+else:
+    borneAff = latex(Rational(borneNumSimp, borneDenSimp), **config_standard)
+
+# Affichage de la solution
+if valLn == 0:
+    # e^0 = 1, donc solution = (1 + constLn) / coefLn
+    solNum = 1 + constLn
+    gSol = gcd(solNum, coefLn)
+    solNumFinal = solNum // gSol
+    solDenFinal = coefLn // gSol
+    if solDenFinal == 1:
+        sol4Aff = latex(solNumFinal, **config_standard)
+    else:
+        sol4Aff = latex(Rational(solNumFinal, solDenFinal), **config_standard)
+else:
+    # Solution générale avec e^valLn
+    sol4Aff = r"\dfrac{e^{" + latex(valLn, **config_standard) + r"} + " + latex(constLn, **config_standard) + r"}{" + latex(coefLn, **config_standard) + r"}"
+
+# Affichage de l'argument du logarithme
+x = Symbol('x')
+argLn = coefLn * x - constLn
+argLnAff = latex(argLn, **config_standard)
+
+# Affichage de valLn
+valLnAff = latex(valLn, **config_standard)
+
+# Affichage des étapes intermédiaires pour la solution 4
+# Étape 1 : coefLn·x - constLn = e^valLn
+if valLn == 0:
+    etape1Aff = latex(coefLn, **config_standard) + r" x - " + latex(constLn, **config_standard) + r" = 1"
+else:
+    etape1Aff = latex(coefLn, **config_standard) + r" x - " + latex(constLn, **config_standard) + r" = e^{" + latex(valLn, **config_standard) + r"}"
+
+# Étape 2 : coefLn·x = e^valLn + constLn
+if valLn == 0:
+    etape2Aff = latex(coefLn, **config_standard) + r" x = " + latex(1 + constLn, **config_standard)
+else:
+    etape2Aff = latex(coefLn, **config_standard) + r" x = e^{" + latex(valLn, **config_standard) + r"} + " + latex(constLn, **config_standard)
+
+# Affichage de coefLn pour l'inégalité du domaine
+coefLnAff = latex(coefLn, **config_standard)
+constLnAff = latex(constLn, **config_standard)
+
+globals()
+```
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ sol3Aff }}$"],["0"]]
+
+::::{questionStatement}
+$\ln x = {{ kAff }}$  {fr}`(on précisera le domaine de définition)`{en}`(specify the domain of definition)`
+
+$x =$ {input}`||150`
+::::
+
+::::{questionHint}
+{fr}`Utiliser la définition du logarithme népérien comme réciproque de la fonction exponentielle.`{en}`Use the definition of the natural logarithm as the inverse of the exponential function.`
+::::
+
+::::{displayedSolution}
+$x = {{ sol3Aff }}$
+::::
+
+::::{detailedSolution}
+{fr}`La fonction`{en}`The function` $\ln$ {fr}`est définie sur`{en}`is defined on` $\mathbb{R}_{+}^{*}$, {fr}`donc l'équation`{en}`so the equation` $\ln x = {{ kAff }}$ {fr}`impose`{en}`requires` $x > 0$. {fr}`Par définition du logarithme comme réciproque de l'exponentielle :`{en}`By definition of the logarithm as the inverse of the exponential:`
+
+\begin{equation*}
+\ln x = {{ kAff }} \iff x = {{ sol3Aff }}.
+\end{equation*}
+
+{fr}`La solution est`{en}`The solution is` $x = {{ sol3Aff }}$.
+::::
+
+::::{weightDistribution}
+:reasoning: 20
+:logic: 30
+:abstraction: 25
+:calculation: 25
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:solution: [["ord","${{ sol4Aff }}$"],["0"]]
+
+::::{questionStatement}
+$\ln({{ argLnAff }}) = {{ valLnAff }}$  {fr}`(on précisera le domaine de définition)`{en}`(specify the domain of definition)`
+
+$x =$ {input}`||200`
+::::
+
+::::{questionHint}
+{fr}`Déterminer le domaine de définition en résolvant une inégalité, puis appliquer l'exponentielle aux deux membres pour éliminer le logarithme.`{en}`Determine the domain of definition by solving an inequality, then apply the exponential to both sides to eliminate the logarithm.`
+::::
+
+::::{displayedSolution}
+$x = {{ sol4Aff }}$
+::::
+
+::::{detailedSolution}
+{fr}`La fonction`{en}`The function` $\ln({{ argLnAff }})$ {fr}`est définie si et seulement si`{en}`is defined if and only if` ${{ argLnAff }} > 0$, {fr}`c'est-à-dire`{en}`that is` ${{ coefLnAff }} x > {{ constLnAff }}$, {fr}`soit`{en}`i.e.` $x > {{ borneAff }}$. {fr}`Sur ce domaine :`{en}`On this domain:`
+
+\begin{equation*}
+\ln({{ argLnAff }}) = {{ valLnAff }} &\iff {{ etape1Aff }} \\
+&\iff {{ etape2Aff }} \\
+&\iff x = {{ sol4Aff }}.
+\end{equation*}
+
+{fr}`On vérifie que`{en}`We verify that` $\ds {{ sol4Aff }} > {{ borneAff }}$ : {fr}`la condition de domaine est bien satisfaite. La solution est`{en}`the domain condition is indeed satisfied. The solution is` $x = {{ sol4Aff }}$.
+::::
+
+::::{weightDistribution}
+:reasoning: 30
+:logic: 25
+:abstraction: 25
+:calculation: 20
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Équilibre de marché _ l'offre rencontre la demande`{en}`Market Equilibrium_ Supply Meets Demand`.md

@@ -0,0 +1,202 @@
+`````{exercise}
+:title: {fr}`Équilibre de marché : l'offre rencontre la demande`{en}`Market Equilibrium: Supply Meets Demand`
+:modules: 
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: chap_lines_Systems_economicEquilibriumBreakeven_ESCP
+:involvedConcepts: 
+:originalSource: Session 4 — Erwan Lamy, ESCP Business School
+:visibility: All
+:variations: 
+:comment: Appliqué (micro-économie) : sens de variation de l'offre et de la demande, point d'équilibre par résolution de S(q) = D(q), vérification.
+:id: 0924e9e6-74c0-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 0177637c-64e3-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_latex_coefficient as lc, pxsl_format_number
+# --- Helpers PyxiScience (definis inline, autonomes : aucun import externe) ---
+
+config_standard = pxs_config()
+
+# S croissante (penteS>0), D decroissante (penteD<0), ordD>ordS,
+# equilibre q* entier positif
+for _ in range(300):
+    penteS = rd.randint(1, 5)
+    ordS = rd.randint(2, 10)
+    penteD = rd.randint(-5, -1)
+    ordD = rd.randint(15, 30)
+    if ordD > ordS and (ordD - ordS) % (penteS - penteD) == 0:
+        qStar = (ordD - ordS) // (penteS - penteD)
+        if qStar > 0:
+            break
+
+pStar = penteS * qStar + ordS
+pStarVerif = penteD * qStar + ordD     # = pStar
+pots = qStar * 100
+
+# Affichage
+penteSCoefAff = lc(penteS); ordSConstAff = lc(ordS, ones=True, sign=True)
+penteDCoefAff = lc(penteD); ordDConstAff = lc(ordD, ones=True, sign=True)
+penteSAff = str(penteS); penteDAff = str(penteD)
+penteDiffAff = lc(penteS - penteD); rhsEq = ordD - ordS
+
+globals()
+````
+
+{fr}`Sur le marché du miel bio (prix `{en}`On the organic honey market (price `$p${fr}` en €/pot, quantité `{en}` in €/jar, quantity `$q${fr}` en centaines de pots par semaine), l'offre et la demande sont `{en}` in hundreds of jars per week), supply and demand are `$S(q) = {{penteSCoefAff}}q {{ordSConstAff}}${fr}` et `{en}` and `$D(q) = {{penteDCoefAff}}q {{ordDConstAff}}$.
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["ord","${{ penteS }}$","${{ ordS }}$","${{ penteD }}$","${{ ordD }}$"],["0","0","0","0"]]
+
+::::{questionStatement}
+{fr}`Vérifier que `{en}`Check that `$S${fr}` est croissante et `{en}` is increasing and `$D${fr}` décroissante, et donner leurs coefficients directeurs et ordonnées à l'origine.`{en}` decreasing, and give their slopes and y-intercepts.`
+- $S$ {fr}`: coefficient directeur`{en}`: slope` {input}`||80` {fr}`, ordonnée à l'origine`{en}`, y-intercept` {input}`||80` 
+- $D$ {fr}`: coefficient directeur`{en}`: slope` {input}`||80` {fr}`, ordonnée à l'origine`{en}`, y-intercept` {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Le signe du coefficient directeur donne le sens de variation.`{en}`The sign of the slope gives the direction of variation.`
+::::
+
+::::{displayedSolution}
+- $S$ {fr}`: pente`{en}`: slope` ${{ penteS }}$ {fr}`, ordonnée`{en}`, intercept` ${{ ordS }}$ 
+- $D$ {fr}`: pente`{en}`: slope` ${{ penteD }}$ {fr}`, ordonnée`{en}`, intercept` ${{ ordD }}$
+::::
+
+::::{detailedSolution}
+{fr}`Pour `{en}`For `$S(q) = {{penteSCoefAff}}q {{ordSConstAff}}${fr}` : coefficient directeur `{en}`: slope `${{penteS}} > 0${fr}`, donc `{en}`, so `$S${fr}` est croissante (les producteurs offrent davantage quand le prix monte) ; ordonnée à l'origine `{en}` is increasing (producers supply more as the price rises); y-intercept `${{ordS}}${fr}` (prix d'offre minimal).`{en}` (minimum supply price).`
+
+{fr}`Pour `{en}`For `$D(q) = {{penteDCoefAff}}q {{ordDConstAff}}${fr}` : coefficient directeur `{en}`: slope `${{penteD}} < 0${fr}`, donc `{en}`, so `$D${fr}` est décroissante (les consommateurs demandent moins quand le prix monte) ; ordonnée à l'origine `{en}` is decreasing (consumers demand less as the price rises); y-intercept `${{ordD}}$.
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 25
+:reasoning: 30
+:calculation: 30
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 1
+:questionIndex: 1
+:solution: [["ord","${{ qStar }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`Déterminer la quantité d'équilibre `{en}`Determine the equilibrium quantity `$q^{*}${fr}` en résolvant `{en}` by solving `$S(q) = D(q)$.\
+\
+$q^*$ = {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`À l'équilibre, le prix d'offre égale le prix de demande : `{en}`At equilibrium, the supply price equals the demand price: `${{penteSCoefAff}}q {{ordSConstAff}} = {{penteDCoefAff}}q {{ordDConstAff}}$.
+::::
+
+::::{displayedSolution}
+$q^* = {{ qStar }}$
+::::
+
+::::{detailedSolution}
+{fr}`On résout `{en}`We solve `$S(q) = D(q)$ :
+
+\begin{equation*}
+{{penteSCoefAff}}q {{ordSConstAff}} &= {{penteDCoefAff}}q {{ordDConstAff}} \\
+{{penteDiffAff}}q &= {{rhsEq}} \\
+q^{*} &= {{qStar}}.
+\end{equation*}
+
+{fr}`La quantité d'équilibre est `{en}`The equilibrium quantity is `$q^{*} = {{qStar}}${fr}` (soit `{en}` (i.e. `${{pots}}${fr}` pots par semaine).`{en}` jars per week).`
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 25
+:reasoning: 30
+:calculation: 30
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 2
+:questionIndex: 2
+:solution: [["ord","${{ pStar }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`En déduire le prix d'équilibre `{en}`Deduce the equilibrium price `$p^{*} = S(q^{*})$.\
+\
+$p^*$ = {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Remplacer `{en}`Replace `$q${fr}` par `{en}` by `$q^{*}${fr}` dans la fonction d'offre.`{en}` in the supply function.`
+::::
+
+::::{displayedSolution}
+$p^* = {{ pStar }}$
+::::
+
+::::{detailedSolution}
+{fr}`On utilise la fonction d'offre :`{en}`We use the supply function:`
+
+\begin{equation*}
+p^{*} = S({{qStar}}) = {{penteSAff}} \times {{qStar}} {{ordSConstAff}} = {{pStar}}.
+\end{equation*}
+
+{fr}`soit`{en}`i.e.` ${{ pStar }}$ {fr}`€/pot.`{en}`€/jar.`
+::::
+
+::::{weightDistribution}
+:logic: 10
+:abstraction: 20
+:reasoning: 25
+:calculation: 45
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 3
+:questionIndex: 3
+:solution: [["ord","${{ pStar }}$"],["0"]]
+
+::::{questionStatement}
+{fr}`Vérifier la réponse à l'aide de `{en}`Check the answer using `$D(q^{*})$.\
+\
+$D(q^*)$ = {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`À l'équilibre, l'offre et la demande doivent donner le même prix.`{en}`At equilibrium, supply and demand must give the same price.`
+::::
+
+::::{displayedSolution}
+$D(q^*) = {{ pStar }}$
+::::
+
+::::{detailedSolution}
+{fr}`On calcule la demande en `{en}`We compute demand at `$q^{*} = {{qStar}}$ :
+
+\begin{equation*}
+D({{qStar}}) = {{penteDAff}} \times {{qStar}} {{ordDConstAff}} = {{pStar}}.
+\end{equation*}
+
+{fr}`soit`{en}`i.e.` ${{ pStar }}$ {fr}`€/pot.`{en}`€/jar.`
+
+{fr}`On a `{en}`We have `$S({{qStar}}) = D({{qStar}}) = {{pStar}}${fr}` : le point d'équilibre est bien `{en}`: the equilibrium point is indeed `$(q^{*},\, p^{*}) = ({{qStar}},\, {{pStar}})$.
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 30
+:calculation: 35
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Équilibre offre-demande sur un marché`{en}`Supply-demand equilibrium in a market`.md

@@ -0,0 +1,237 @@
+`````{exercise}
+:title: {fr}`Équilibre offre-demande sur un marché`{en}`Supply-demand equilibrium in a market`
+:modules: 
+:recommendedExecutionTime: 15
+:level: Elementary
+:chap: chap_lines_Systems_economicEquilibriumBreakeven_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Appliqué éco/gestion — prix et quantité d'équilibre comme intersection de la droite d'offre (croissante) et de la droite de demande (décroissante).
+:id: 730a9473-74c0-11f1-a8a1-0ed8d3b012a9
+:originalExerciseId: 0582ee6e-64e4-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+from pyxiscience.Mes_fctions_generalistes_bis import pxs_config, pxsl_latex_coefficient as lc
+config_standard = pxs_config()
+
+# Offre croissante, demande décroissante, équilibre ENTIER dans le quadrant positif
+for _ in range(300):
+    a_offre = rd.randint(1, 5)
+    b_offre = rd.randint(2, 10)
+    a_demande = rd.randint(-5, -1)
+    b_demande = rd.randint(max(15, b_offre + 10), 40)
+    denom = a_offre - a_demande
+    num = b_demande - b_offre
+    if denom > 0 and num > 0 and num % denom == 0:
+        repQ = num // denom
+        repP = a_offre * repQ + b_offre
+        if 2 <= repQ <= 12 and repP > 0:
+            break
+
+# Limites pour le graphique
+q_max_graph = max(6.5, repQ * 1.3)
+p_max_graph = max(32, b_demande + 3)
+
+# Précalcul de l'affichage
+slopeOffreAff = lc(a_offre)
+interOffreAff = lc(b_offre, ones=True, sign=True)
+slopeDemAff = lc(a_demande)
+interDemAff = lc(b_demande, ones=True, sign=True)
+slopeOffreSignAff = lc(a_offre, ones=True, sign=True)
+slopeDemPlainAff = lc(a_demande, ones=True)
+coefDiffAff = lc(a_offre - a_demande)
+rhsAff = str(b_demande - b_offre)
+aOffreAff = str(a_offre)
+aDemandeAff = str(a_demande)
+repQAff = str(repQ)
+repPAff = str(repP)
+
+# Libellés multilingues pour matplotlib
+if pxs_lang == "fr":
+    label_offre_prefix = "Offre : "
+    label_demande_prefix = "Demande : "
+    label_q_axis = r"$q$ (milliers)"
+    label_p_axis = r"$p$ (euros)"
+else:
+    label_offre_prefix = "Supply: "
+    label_demande_prefix = "Demand: "
+    label_q_axis = r"$q$ (thousands)"
+    label_p_axis = r"$p$ (euros)"
+
+globals()
+````
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["ord","${{ a_offre }}$","${{ a_demande }}$"],["0","0"]]
+
+::::{questionStatement}
+{fr}`Sur le marché d'un bien de consommation, l'offre et la demande (prix`{en}`In the market for a consumer good, supply and demand (price` $p$ {fr}`en euros par unité, en fonction de la quantité`{en}`in euros per unit, as a function of quantity` $q$ {fr}`en milliers d'unités) sont`{en}`in thousands of units) are` $\ds \text{{fr}`Offre`{en}`Supply`} : p = {{slopeOffreAff}}q {{interOffreAff}}$ {fr}`et`{en}`and` $\ds \text{{fr}`Demande`{en}`Demand`} : p = {{slopeDemAff}}q {{interDemAff}}$. {fr}`Vérifier que la courbe d'offre est croissante et celle de demande décroissante, et interpréter économiquement.`{en}`Verify that the supply curve is increasing and the demand curve is decreasing, and interpret economically.`
+- {fr}`Pente de l'offre :`{en}`Slope of supply:` {input}`||80` 
+- {fr}`Pente de la demande :`{en}`Slope of demand:` {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Le signe de la pente donne le sens de variation.`{en}`The sign of the slope gives the direction of variation.`
+::::
+
+::::{displayedSolution}
+- {fr}`Pente offre`{en}`Supply slope` ${{ a_offre }}$ 
+- {fr}`Pente demande`{en}`Demand slope` ${{ a_demande }}$
+::::
+
+::::{detailedSolution}
+{fr}`La droite d'offre`{en}`The supply line` $p = {{slopeOffreAff}}q {{interOffreAff}}$ {fr}`a une pente`{en}`has a slope` ${{slopeOffreSignAff}} > 0$ : {fr}`elle est croissante. Économiquement, les producteurs offrent davantage quand le prix monte. La droite de demande`{en}`it is increasing. Economically, producers supply more when the price rises. The demand line` $p = {{slopeDemAff}}q {{interDemAff}}$ {fr}`a une pente`{en}`has a slope` ${{slopeDemPlainAff}} < 0$ : {fr}`elle est décroissante. Les consommateurs demandent moins quand le prix monte.`{en}`it is decreasing. Consumers demand less when the price rises.`
+::::
+
+::::{weightDistribution}
+:logic: 18
+:abstraction: 22
+:reasoning: 35
+:calculation: 25
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 1
+:questionIndex: 1
+:solution: [["ord","${{ repQAff }}$","${{ repPAff }}$"],["0","0"]]
+
+::::{questionStatement}
+{fr}`Déterminer la quantité d'équilibre`{en}`Determine the equilibrium quantity` $q^*$ {fr}`et le prix d'équilibre`{en}`and the equilibrium price` $p^*$ {fr}`en résolvant le système formé par les deux équations.`{en}`by solving the system formed by the two equations.`
+- $q^*$ = {input}`||80` 
+- $p^*$ = {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`À l'équilibre, offre = demande : égale les deux expressions de`{en}`At equilibrium, supply = demand: equate the two expressions of` $p$.
+::::
+
+::::{displayedSolution}
+- $q^* = {{ repQAff }}$ 
+- $p^* = {{ repPAff }}$
+::::
+
+::::{detailedSolution}
+{fr}`On égale offre et demande :`{en}`We equate supply and demand:`
+
+\begin{equation*}
+{{slopeOffreAff}}q^* {{interOffreAff}} &= {{slopeDemAff}}q^* {{interDemAff}} \\
+{{coefDiffAff}}q^* &= {{rhsAff}} \\
+q^* &= {{repQAff}}.
+\end{equation*}
+
+{fr}`En reportant dans l'offre :`{en}`Substituting into the supply:`
+
+\begin{equation*}
+p^* &= {{aOffreAff}} \times {{repQAff}} {{interOffreAff}} \\
+&= {{repPAff}}.
+\end{equation*}
+
+{fr}`Vérification par la demande :`{en}`Verification by demand:` ${{aDemandeAff}} \times {{repQAff}} {{interDemAff}} = {{repPAff}}$. {fr}`L'équilibre est`{en}`The equilibrium is` $q^* = {{repQAff}}$ {fr}`milliers d'unités au prix`{en}`thousands of units at price` $p^* = {{repPAff}}$ {fr}`€ par unité.`{en}`€ per unit.`
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 30
+:calculation: 35
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 2
+:questionIndex: 2
+:solution: [["ord","${{ repQAff }}$","${{ repPAff }}$"],["0","0"]]
+
+::::{questionStatement}
+{fr}`Représenter les deux droites sur un graphique clairement légendé et repérer le point d'équilibre.`{en}`Represent the two lines on a clearly labeled graph and identify the equilibrium point.`\
+\
+{fr}`Point d'équilibre`{en}`Equilibrium point` $E${fr}` `: 
+- {fr}`abscisse`{en}`x-coordinate`{fr}` `: {input}`||80` 
+- {fr}`ordonnée`{en}`y-coordinate`{fr}` `: {input}`||80`
+::::
+
+::::{questionHint}
+{fr}`Trace les deux droites ; leur intersection est le point d'équilibre`{en}`Draw the two lines; their intersection is the equilibrium point` $E$.
+::::
+
+::::{displayedSolution}
+{fr}`Point d'équilibre`{en}`Equilibrium point` $E${fr}` `: 
+- {fr}`abscisse`{en}`x-coordinate`{fr}` `: ${{ repQAff }}$ 
+- {fr}`ordonnée`{en}`y-coordinate`{fr}` `: ${{ repPAff }}$
+::::
+
+::::{detailedSolution}
+{fr}`Les deux droites se coupent au point d'équilibre`{en}`The two lines intersect at the equilibrium point` $E({{repQAff}}\,;\,{{repPAff}})$ :
+
+```{python}
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Libellés pour matplotlib : moteur mathtext, donc PAS de \displaystyle ni \; (non supportés).
+def slopeTerm(a):
+    if a == 1: return "q"
+    if a == -1: return "-q"
+    return f"{a}q"
+
+def interTerm(b):
+    if b == 0: return ""
+    return f" + {b}" if b > 0 else f" - {abs(b)}"
+
+q = np.linspace(0, q_max_graph, 200)
+offre = a_offre * q + b_offre
+demande = a_demande * q + b_demande
+
+fig, ax = plt.subplots(figsize=(6, 6))
+ax.plot(q, offre, color="blue", lw=2, label=f"{label_offre_prefix}$p = {slopeTerm(a_offre)}{interTerm(b_offre)}$")
+ax.plot(q, demande, color="red", lw=2, label=f"{label_demande_prefix}$p = {slopeTerm(a_demande)}{interTerm(b_demande)}$")
+
+ax.plot(repQ, repP, "ko", markersize=6)
+ax.annotate(f"$E({repQ}\\,;\\,{repP})$", xy=(repQ, repP), xytext=(repQ + 0.15, repP + 1.2), fontsize=11)
+ax.plot([repQ, repQ], [0, repP], ls="--", color="0.5", lw=1)
+ax.plot([0, repQ], [repP, repP], ls="--", color="0.5", lw=1)
+
+ax.annotate("", xy=(q_max_graph + 0.5, 0), xytext=(0, 0), arrowprops=dict(arrowstyle="->", color="black", lw=1.2))
+ax.annotate("", xy=(0, p_max_graph), xytext=(0, 0), arrowprops=dict(arrowstyle="->", color="black", lw=1.2))
+ax.text(q_max_graph + 0.6, -0.5, label_q_axis, ha="center", fontsize=11)
+ax.text(-0.4, p_max_graph, label_p_axis, ha="center", fontsize=11)
+
+q_step = max(1, int(q_max_graph / 6))
+for x in range(q_step, int(q_max_graph) + 1, q_step):
+    ax.plot([x, x], [-0.3, 0.3], color="black", lw=1)
+    ax.text(x, -1.0, str(x), ha="center", fontsize=9)
+
+p_step = max(5, int(p_max_graph / 6))
+for y in range(p_step, int(p_max_graph) + 1, p_step):
+    ax.plot([-0.1, 0.1], [y, y], color="black", lw=1)
+    ax.text(-0.35, y, str(y), ha="right", va="center", fontsize=9)
+ax.text(-0.35, 0, "0", ha="right", va="center", fontsize=9)
+
+ax.legend(loc="upper right", fontsize=10)
+ax.set_xlim(-0.5, q_max_graph + 1)
+ax.set_ylim(-2, p_max_graph + 1)
+ax.axis("off")
+plt.tight_layout()
+plt.show()
+```
+
+{fr}`L'offre (croissante) et la demande (décroissante) se croisent en`{en}`Supply (increasing) and demand (decreasing) intersect at` $E({{repQAff}}\,;\,{{repPAff}})$, {fr}`qui matérialise le prix où le marché s'équilibre.`{en}`which represents the price where the market reaches equilibrium.`
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 25
+:reasoning: 35
+:calculation: 20
+::::
+:::::
+
+`````

app/knowledge/fewshots/declinaisons/{fr}`Évaluer un logarithme en reconnaissant une puissance de la base`{en}`Evaluate a logarithm by recognizing a power of the base`.md

@@ -0,0 +1,131 @@
+`````{exercise}
+:title: {fr}`Évaluer un logarithme en reconnaissant une puissance de la base`{en}`Evaluate a logarithm by recognizing a power of the base`
+:modules: 
+:recommendedExecutionTime: 10
+:level: Elementary
+:chap: chap_expLogFunctions_logarithmicFunctions_ESCP
+:involvedConcepts: 
+:originalSource: 
+:visibility: All
+:variations: 
+:comment: Échauffement (thème pur) : évaluation de log_b(x) en reconnaissant x comme une puissance de b, via log_b(b^k)=k. Aucune loi algébrique du logarithme.
+:originalExerciseId: 1331c2a5-6599-11f1-a8a1-0ed8d3b012a9
+:id: fee348e8-74be-11f1-a8a1-0ed8d3b012a9
+
+````{python}
+import random as rd
+
+# Construction déterministe : on part des exposants (réponses) puis on bâtit les arguments.
+base1 = rd.choice([2, 3, 5, 7, 10])
+exp1 = rd.randint(2, 5)
+arg1 = base1 ** exp1
+base2 = rd.choice([b for b in [2, 3, 5, 7, 10] if b != base1])
+exp2 = rd.randint(2, 4)
+arg2 = base2 ** exp2
+base3 = rd.choice([b for b in [2, 3, 5, 7] if b not in [base1, base2]])
+exp3 = rd.randint(2, 5)
+arg3 = base3 ** exp3
+l1, l2, l3 = exp1, exp2, exp3
+
+base4 = rd.choice([2, 3, 5, 7, 10])
+base5 = rd.choice([b for b in [2, 3, 4, 5, 6, 7, 10] if b != base4])
+l4, l5 = 1, 0
+
+globals()
+````
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["ord","{{ l1 }}","{{ l2 }}","{{ l3 }}"],["0","0","0"]]
+
+::::{questionStatement}
+{fr}`Évaluer`{en}`Evaluate` $\log_{ {{ base1 }} }({{ arg1 }})$, $\log_{ {{ base2 }} }({{ arg2 }})$ {fr}`et`{en}`and` $\log_{ {{ base3 }} }({{ arg3 }})$ {fr}`en reconnaissant chaque argument comme une puissance de la base.`{en}`by recognizing each argument as a power of the base.`
+
+$\log_{ {{ base1 }} }({{ arg1 }}) =$ {input}`||70`
+
+$\log_{ {{ base2 }} }({{ arg2 }}) =$ {input}`||70`
+
+$\log_{ {{ base3 }} }({{ arg3 }}) =$ {input}`||70`
+::::
+
+::::{questionHint}
+${{ arg1 }}={{ base1 }}^{ {{ exp1 }} }$, ${{ arg2 }}={{ base2 }}^{ {{ exp2 }} }$, ${{ arg3 }}={{ base3 }}^{ {{ exp3 }} }$ ; {fr}`utiliser`{en}`use` $\log_{b}(b^{k})=k$.
+::::
+
+::::{displayedSolution}
+$\log_{ {{ base1 }} }({{ arg1 }}) = {{ l1 }}$
+
+$\log_{ {{ base2 }} }({{ arg2 }}) = {{ l2 }}$
+
+$\log_{ {{ base3 }} }({{ arg3 }}) = {{ l3 }}$
+::::
+
+::::{detailedSolution}
+{fr}`Par la relation réciproque`{en}`By the reciprocal relation` $\log_{b}(b^{k})=k$ :
+
+\begin{equation*}
+\log_{ {{ base1 }} }({{ arg1 }}) &= \log_{ {{ base1 }} }({{ base1 }}^{ {{ exp1 }} }) \\
+&= {{ l1 }}, \\
+\log_{ {{ base2 }} }({{ arg2 }}) &= \log_{ {{ base2 }} }({{ base2 }}^{ {{ exp2 }} }) \\
+&= {{ l2 }}, \\
+\log_{ {{ base3 }} }({{ arg3 }}) &= \log_{ {{ base3 }} }({{ base3 }}^{ {{ exp3 }} }) \\
+&= {{ l3 }}.
+\end{equation*}
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 25
+:reasoning: 30
+:calculation: 30
+::::
+:::::
+
+:::::{question}
+:questionType: FGQ
+:questionId: 1
+:questionIndex: 1
+:solution: [["ord","{{ l4 }}","{{ l5 }}"],["0","0"]]
+
+::::{questionStatement}
+{fr}`Évaluer`{en}`Evaluate` $\log_{ {{ base4 }} }({{ base4 }})$ {fr}`et`{en}`and` $\log_{ {{ base5 }} }(1)$, {fr}`et justifier à partir des cas`{en}`and justify from the cases` $b^1=b$ {fr}`et`{en}`and` $b^0=1$.
+
+$\log_{ {{ base4 }} }({{ base4 }}) =$ {input}`||70`
+
+$\log_{ {{ base5 }} }(1) =$ {input}`||70`
+::::
+
+::::{questionHint}
+${{ base4 }}={{ base4 }}^1$ {fr}`et`{en}`and` $1={{ base5 }}^0$.
+::::
+
+::::{displayedSolution}
+$\log_{ {{ base4 }} }({{ base4 }}) = {{ l4 }}$
+
+$\log_{ {{ base5 }} }(1) = {{ l5 }}$
+::::
+
+::::{detailedSolution}
+{fr}`On a`{en}`We have` ${{ base4 }}={{ base4 }}^1$ {fr}`et`{en}`and` $1={{ base5 }}^0$, {fr}`donc :`{en}`so:`
+
+\begin{equation*}
+\log_{ {{ base4 }} }({{ base4 }}) &= \log_{ {{ base4 }} }({{ base4 }}^1) \\
+&= {{ l4 }}, \\
+\log_{ {{ base5 }} }(1) &= \log_{ {{ base5 }} }({{ base5 }}^0) \\
+&= {{ l5 }}.
+\end{equation*}
+
+{fr}`En particulier`{en}`In particular` $\log_{b}(1)=0$ {fr}`pour toute base : le graphe d'un logarithme passe toujours par`{en}`for any base: the graph of a logarithm always passes through` $(1,0)$.
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 30
+:reasoning: 30
+:calculation: 20
+::::
+:::::
+
+`````

app/knowledge/fewshots/qat.md

@@ -0,0 +1,62 @@
+`````{exercise}
+:id:
+:title: {fr}`Exemple QAT — racines d'un trinôme`{en}`QAT example — roots of a quadratic`
+:modules:
+:recommendedExecutionTime: 4
+:level: Elementary
+:chap:
+:involvedConcepts:
+:originalSource:
+:visibility: All
+
+````{python}
+import random as rd
+from sympy import symbols, latex, Poly
+x = symbols('x')
+
+r1 = rd.randint(-6, -1)       # plus petite racine (entière)
+r2 = rd.randint(1, 6)         # plus grande racine (entière)
+p  = -(r1 + r2)
+q  = r1*r2
+polyAff = latex(Poly(x**2 + p*x + q, x).as_expr())
+r1Aff, r2Aff = str(r1), str(r2)
+
+globals()
+````
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["ord","${{r1Aff}}$","${{r2Aff}}$"],["0","0"]]
+
+::::{questionStatement}
+{fr}`Résoudre l'équation suivante, en donnant les racines de la plus petite à la plus grande :`{en}`Solve the following equation, giving the roots from smallest to largest:`
+\begin{equation*}
+{{polyAff}} = 0.
+\end{equation*}
+
+{fr}`Plus petite racine :`{en}`Smallest root:` {input}`||90` $\qquad$ {fr}`plus grande racine :`{en}`largest root:` {input}`||90`
+::::
+
+::::{questionHint}
+{fr}`Cherchez deux entiers dont la somme et le produit correspondent aux coefficients.`{en}`Look for two integers whose sum and product match the coefficients.`
+::::
+
+::::{displayedSolution}
+$x_1 = {{r1Aff}}$, $\quad x_2 = {{r2Aff}}$
+::::
+
+::::{detailedSolution}
+{fr}`On factorise`{en}`Factoring` ${{polyAff}} = (x - ({{r1Aff}}))(x - ({{r2Aff}}))$, {fr}`d'où les racines`{en}`hence the roots` ${}{{r1Aff}}$ {fr}`et`{en}`and` ${}{{r2Aff}}$.
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 15
+:reasoning: 20
+:calculation: 50
+::::
+:::::
+
+`````

app/knowledge/fewshots/qcm.md

@@ -0,0 +1,85 @@
+`````{exercise}
+:id:
+:title: {fr}`Exemple QCM — dérivée d'un monôme`{en}`MCQ example — derivative of a monomial`
+:modules:
+:recommendedExecutionTime: 3
+:level: Elementary
+:chap:
+:involvedConcepts:
+:originalSource:
+:visibility: All
+
+````{python}
+import random as rd
+from sympy import symbols, diff, latex
+x = symbols('x')
+
+a = rd.randint(2, 9)          # coefficient (>= 2, jamais 1)
+n = rd.choice([k for k in range(2, 7) if k != a])   # exposant >= 2, ET n != a
+f  = a*x**n
+fp = diff(f, x)               # bonne réponse : n a x^(n-1)
+
+fAff       = latex(f)
+correctAff = latex(fp)
+d1Aff = latex(a*x**(n-1))     # oubli du facteur n (dérivée)
+d2Aff = latex(a*n*x**n)       # exposant non décrémenté
+d3Aff = latex(n*x**(n-1))     # oubli du coefficient a
+# distincts par construction : a != n garantit d1 != d3 (sinon a x^(n-1) == n x^(n-1)),
+# a,n >= 2 garantit correct != d1/d2/d3 — collision impossible sur toute graine.
+
+globals()
+````
+
+{fr}`Soit la fonction`{en}`Let the function` $f(x) = {{fAff}}$.
+
+:::::{question}
+:questionType: MCQ
+:questionId: 0
+:questionIndex: 0
+
+::::{questionStatement}
+{fr}`Quelle est la dérivée`{en}`What is the derivative` $f'(x)$ ?
+::::
+
+::::{questionHint}
+{fr}`Règle de la puissance :`{en}`Power rule:` $\dfrac{d}{dx}\left(x^{p}\right) = p\,x^{p-1}$.
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+$f'(x) = {{correctAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$f'(x) = {{d1Aff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$f'(x) = {{d2Aff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+$f'(x) = {{d3Aff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+{fr}`Par la règle de la puissance,`{en}`By the power rule,` $\dfrac{d}{dx}\left(a x^{n}\right) = n\,a\,x^{n-1}$, {fr}`donc`{en}`so` $f'(x) = {{correctAff}}$.
+::::
+
+::::{weightDistribution}
+:logic: 20
+:abstraction: 20
+:reasoning: 20
+:calculation: 40
+::::
+:::::
+
+`````

app/pipeline/fewshots.py

@@ -79,3 +79,16 @@ def fewshot_for(analysis: dict) -> str:
     shot = load_fewshot(key)
     logger.info("Few-shot sélectionné : %s (%d caractères)", key, len(shot))
     return shot or "(aucun exemple canonique disponible pour ce type)"
+
+
+@lru_cache(maxsize=None)
+def fewshot_for_declinaison(decl_type: str) -> str:
+    """Exemple canonique COMPLET pour une déclinaison (qcm|qat) — fichiers
+    stricts (conventions corpus 222) calibrés sur les 33 exemples validés de
+    fewshots/declinaisons/. Complet (pas élagué) : la structure mcqAnswer /
+    :solution:/displayedSolution est le cœur de ce qu'il faut imiter."""
+    path = FEWSHOTS_DIR / f"{decl_type}.md"
+    if not path.exists():
+        logger.warning("Few-shot déclinaison absent : %s", path)
+        return "(aucun exemple canonique disponible)"
+    return path.read_text(encoding="utf-8")

app/pipeline/generate.py

@@ -21,7 +21,13 @@ from app.pipeline.postprocess import (
     normalize_python_fences,
     strip_fences,
 )
-from app.pipeline.prompts import STEP_PAIR_PROMPT, SYSTEM_PROMPT
+from app.pipeline.prompts import (
+    FGQ_SPEC,
+    MCQ_SPEC,
+    STEP_DECLINAISON_PROMPT,
+    STEP_PAIR_PROMPT,
+    SYSTEM_PROMPT,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -124,6 +130,7 @@ def build_exercise_metadata(
     lists_of_notions: str,
     analysis: dict | None = None,
     level: str = "",
+    decl_type: str | None = None,
 ) -> str:
     """Construit TOUJOURS un en-tête `{exercise}` complet et bien formé
     (5 backticks englobant tout l'exercice — le bloc Python à 4 backticks vient
@@ -142,6 +149,11 @@ def build_exercise_metadata(
     src = _parse_source_options(metadata)
 
     title = src.get("title") or analysis.get("exercise_title") or "Exercice"
+    if decl_type:
+        # Suffixe de traçabilité (convention des exemples validés : « - MCQ »).
+        suffix = " - MCQ" if decl_type == "qcm" else " - QAT"
+        if not title.rstrip().endswith(suffix.strip()):
+            title = title.rstrip() + suffix
 
     nb_q = analysis.get("nb_questions") or 0
     try:
@@ -170,7 +182,12 @@ def build_exercise_metadata(
 
     fence = "`" * EXERCISE_FENCE_BACKTICKS
     lines = [f"{fence}{{exercise}}"]
-    lines += [f":{k}: {values[k]}".rstrip() for k in _HEADER_FIELDS]
+    for k in _HEADER_FIELDS:
+        lines.append(f":{k}: {values[k]}".rstrip())
+        # Déclinaison d'un exercice existant : tracer l'id source juste après :id:
+        # (convention des exemples validés : :originalExerciseId:).
+        if k == "id" and decl_type and src.get("id"):
+            lines.append(f":originalExerciseId: {src['id']}")
     return "\n".join(lines)
 
 
@@ -208,6 +225,10 @@ _LANG_DIRECTIVES = {
 }
 
 
+_DECL_LABELS = {"qcm": "QCM (MCQ)", "qat": "QAT (FGQ)"}
+_DECL_SPECS = {"qcm": MCQ_SPEC, "qat": FGQ_SPEC}
+
+
 def generate_pair_blocks(
     content: str,
     exercise_header: str,
@@ -222,20 +243,37 @@ def generate_pair_blocks(
     model_idx: int,
     lang: str = "auto",
     set_step: Optional[Callable[[str], None]] = None,
+    decl_type: Optional[str] = None,
 ) -> list[str]:
-    """Boucle de génération par paires (séquentielle). Retourne les blocs."""
+    """Boucle de génération par paires (séquentielle). Retourne les blocs.
+    `decl_type` (qcm|qat) bascule sur le prompt Déclinaisons — même mécanique
+    par paires, 1 question source → 1 question déclinée."""
     nb_questions = analysis.get("nb_questions", max(1, len(question_segments)))
     lang_directive = _LANG_DIRECTIVES.get(lang, _LANG_DIRECTIVES["auto"])
-    common = dict(
-        analysis=json.dumps(analysis, ensure_ascii=False, indent=2),
-        functions=functions_ctx or "Aucune fonction spécifique détectée.",
-        niveau=level or "non précisé",
-        targeted_rules=targeted_rules_digest,
-        property_constraints=property_constraints_text,
-        fewshot=fewshot,
-        lang_directive=lang_directive,
-        nb_total=nb_questions,
-    )
+    if decl_type:
+        prompt_tmpl = STEP_DECLINAISON_PROMPT
+        common = dict(
+            analysis=json.dumps(analysis, ensure_ascii=False, indent=2),
+            functions=functions_ctx or "Aucune fonction spécifique détectée.",
+            niveau=level or "non précisé",
+            fewshot=fewshot,
+            lang_directive=lang_directive,
+            nb_total=nb_questions,
+            decl_label=_DECL_LABELS[decl_type],
+            decl_spec=_DECL_SPECS[decl_type],
+        )
+    else:
+        prompt_tmpl = STEP_PAIR_PROMPT
+        common = dict(
+            analysis=json.dumps(analysis, ensure_ascii=False, indent=2),
+            functions=functions_ctx or "Aucune fonction spécifique détectée.",
+            niveau=level or "non précisé",
+            targeted_rules=targeted_rules_digest,
+            property_constraints=property_constraints_text,
+            fewshot=fewshot,
+            lang_directive=lang_directive,
+            nb_total=nb_questions,
+        )
 
     generated: list[str] = []
 
@@ -244,7 +282,7 @@ def generate_pair_blocks(
         if set_step:
             set_step("Génération (bloc Python + toutes les questions)…")
         raw = process_with_openrouter(
-            prompt=STEP_PAIR_PROMPT.format(
+            prompt=prompt_tmpl.format(
                 content=content,
                 previous_blocks="(aucun — première génération)",
                 nb_current=nb_questions,
@@ -272,7 +310,7 @@ def generate_pair_blocks(
             current_segment = enonce + "\n\n" + current_segment
 
         raw_pair = process_with_openrouter(
-            prompt=STEP_PAIR_PROMPT.format(
+            prompt=prompt_tmpl.format(
                 content=exercise_header,
                 previous_blocks=("\n\n".join(generated) if generated
                                  else "(aucun — première paire)"),

app/pipeline/orchestrator.py

@@ -39,7 +39,7 @@ from app.rag.catalogue import catalogue_for
 from app.pipeline import postprocess as pp
 from app.pipeline.analyze import run_analysis_phase
 from app.pipeline.audit import run_audit
-from app.pipeline.fewshots import fewshot_for
+from app.pipeline.fewshots import fewshot_for, fewshot_for_declinaison
 from app.pipeline.generate import (
     assemble_exercise,
     build_exercise_metadata,
@@ -105,21 +105,31 @@ def run_exercise(
     model_idx: int = 1,
     lang: str = "fr",
     set_step: Optional[Callable[[str], None]] = None,
+    decl_type: Optional[str] = None,
+    shared_phase: Optional[tuple] = None,
 ) -> dict:
     """
-    Pythonise UN exercice. Retourne le dict résultat (contrat UI) :
+    Traite UN exercice. `decl_type=None` = pythonisation (flux historique) ;
+    `decl_type ∈ {"qcm","qat"}` = mode déclinaisons (même pipeline, prompt et
+    harnais étendus). `shared_phase` = résultat de run_analysis_phase à
+    RÉUTILISER (déclinaisons QCM+QAT d'une même source : une seule analyse).
+
+    Retourne le dict résultat (contrat UI) :
       exercise, pair_blocks, analysis, functions, notions, audit_patches,
       warnings, harness {ok, summary, seeds}, lang {source, target, action},
-      cost {usd, eur, requests}, duration_s
+      cost {usd, eur, requests}, duration_s [, decl_type]
     """
     t0 = time.time()
     cost_before = cost_snapshot()
     _step = set_step or (lambda label: None)
 
-    # ── 1. Analyse + notions + RAG (parallèle) ───────────────────────────────
-    _step("Analyse + notions + catalogue RAG (en parallèle)…")
-    analysis, notions_ctx, lists_of_notions, functions_ctx = run_analysis_phase(
-        content, model_idx)
+    # ── 1. Analyse + notions + RAG (parallèle ; partagée en mode QCM+QAT) ────
+    if shared_phase is not None:
+        analysis, notions_ctx, lists_of_notions, functions_ctx = shared_phase
+    else:
+        _step("Analyse + notions + catalogue RAG (en parallèle)…")
+        analysis, notions_ctx, lists_of_notions, functions_ctx = run_analysis_phase(
+            content, model_idx)
 
     step1_targets = [r for r in (analysis.get("target_rules") or []) if isinstance(r, str)]
     target_rules = list(dict.fromkeys(TRUNK_RULES + step1_targets))
@@ -133,7 +143,8 @@ def run_exercise(
 
     # ── 2. Génération par paires ─────────────────────────────────────────────
     metadata, enonce, question_segments = split_original_questions(content)
-    exercise_header = build_exercise_metadata(metadata, lists_of_notions, analysis, level)
+    exercise_header = build_exercise_metadata(metadata, lists_of_notions, analysis,
+                                              level, decl_type=decl_type)
 
     # Contexte fonctions = catalogue CURÉ (domaine détecté) + hits RAG FAISS.
     # Le catalogue curé donne « quel helper pour quel besoin » + couvre les
@@ -145,6 +156,8 @@ def run_exercise(
         if functions_ctx else "",
     ])) or "Aucune fonction spécifique détectée."
 
+    fewshot = (fewshot_for_declinaison(decl_type) if decl_type
+               else fewshot_for(analysis))
     pair_blocks = generate_pair_blocks(
         content=content,
         exercise_header=exercise_header,
@@ -152,13 +165,14 @@ def run_exercise(
         question_segments=question_segments,
         analysis=analysis,
         functions_ctx=functions_combined,
-        fewshot=fewshot_for(analysis),
+        fewshot=fewshot,
         targeted_rules_digest=targeted_rules_digest,
         property_constraints_text=property_constraints_text,
         level=level,
         model_idx=model_idx,
         lang=lang,
         set_step=_step,
+        decl_type=decl_type,
     )
 
     # ── 3. Post-traitements déterministes ────────────────────────────────────
@@ -247,6 +261,39 @@ def run_exercise(
     myst_exercise, dollar_patches = pp.fix_dollar_digit(myst_exercise)
     audit_patches.extend(dollar_patches)
 
+    if decl_type:
+        # Filet : alias d'option MCQ mal nommés / :isRightAnswer: manquant
+        # (le repli MCQ en QAT est concerné aussi).
+        myst_exercise, alias_fixed = pp.fix_mcq_answer_aliases(myst_exercise)
+        if alias_fixed:
+            audit_patches.append({
+                "rule": "MCQ", "location": "(mcqOption / :isRightAnswer:)",
+                "fix": f"{alias_fixed} bloc(s) d'option normalisé(s)",
+                "message": "Blocs d'options MCQ normalisés (mcqOption→mcqAnswer, :isRightAnswer: false par défaut).",
+                "iteration": 0,
+            })
+        # Déclinaisons : UN SEUL bloc {python} — fusion des blocs additionnels
+        # sans re-tirage (re-tirage → laissé au harnais + réparation LLM).
+        myst_exercise, merged = pp.merge_decl_python_blocks(myst_exercise)
+        if merged:
+            audit_patches.append({
+                "rule": "3.1", "location": "(blocs python additionnels)",
+                "fix": f"{merged} bloc(s) fusionné(s) dans le bloc principal",
+                "message": "Déclinaison : blocs {python} additionnels fusionnés (un seul bloc, spec).",
+                "iteration": 0,
+            })
+
+    if decl_type == "qcm":
+        # Filet MCQ : l'option « None/Aucune » doit être le dernier mcqAnswer.
+        myst_exercise, none_moved = pp.fix_none_option_last(myst_exercise)
+        if none_moved:
+            audit_patches.append({
+                "rule": "MCQ", "location": "(option None)",
+                "fix": f"{none_moved} option(s) « None » déplacée(s) en dernier",
+                "message": "Option « Aucune de ces réponses / None » repositionnée en dernière position.",
+                "iteration": 0,
+            })
+
     # Les warnings 6.1 du LLM deviennent du bruit une fois l'auto-lift passé.
     if not pp.INJECTION_RE.search(myst_exercise) or not any(
         "(" in tok or "**" in tok for tok in pp.INJECTION_RE.findall(myst_exercise)
@@ -363,12 +410,18 @@ def run_exercise(
         candidate, _ = pp.auto_lift_injections(candidate)
         candidate, _ = pp.rename_underscore_injections(candidate)
         candidate, _ = pp.fix_dollar_digit(candidate)
+        if decl_type:
+            candidate, _ = pp.fix_mcq_answer_aliases(candidate)
+            candidate, _ = pp.merge_decl_python_blocks(candidate)
+        if decl_type == "qcm":
+            candidate, _ = pp.fix_none_option_last(candidate)
         candidate, _ = pp.renumber_question_ids(candidate)
         candidate_report = harness.validate_text(candidate, seeds=HARNESS_GATE_SEEDS)
 
         def _badness(r: dict) -> int:
             return (len(r["static_errors"]) + r["n_exec_errors"]
-                    + r["n_unresolved"] + r["n_forbidden"])
+                    + r["n_unresolved"] + r["n_forbidden"]
+                    + r.get("n_mcq_collisions", 0))
 
         if candidate_report["ok"] or _badness(candidate_report) < _badness(report):
             myst_exercise, report = candidate, candidate_report
@@ -401,6 +454,49 @@ def run_exercise(
             "summary": harness.format_report(report),
         },
         "lang": lang_info,
+        "decl_type": decl_type,
         "cost": cost_delta(cost_before),
         "duration_s": round(time.time() - t0, 1),
     }
+
+
+def run_declinaisons(
+    content: str,
+    filename: str = "exercise.md",
+    level: str = "",
+    model_idx: int = 1,
+    lang: str = "fr",
+    types: Optional[list] = None,
+    set_step: Optional[Callable[[str], None]] = None,
+) -> list[tuple[str, dict]]:
+    """
+    Mode `declinaisons` : produit une déclinaison par type coché (qcm/qat).
+    L'analyse + notions + RAG sont calculées UNE SEULE fois et partagées entre
+    les types (aucun appel LLM redondant). Retourne [(decl_type, result), …].
+    Un échec sur un type n'empêche pas l'autre (l'appelant gère l'erreur).
+    """
+    _step = set_step or (lambda label: None)
+    types = [t for t in (types or []) if t in ("qcm", "qat")] or ["qcm"]
+
+    _step("Analyse + notions + catalogue RAG (partagés QCM/QAT)…")
+    shared = run_analysis_phase(content, model_idx)
+
+    out: list[tuple[str, dict]] = []
+    for decl_type in types:
+        label = "QCM" if decl_type == "qcm" else "QAT"
+
+        def step_with_type(msg: str, _label=label):
+            _step(f"[{_label}] {msg}")
+
+        result = run_exercise(
+            content=content,
+            filename=filename,
+            level=level,
+            model_idx=model_idx,
+            lang=lang,
+            set_step=step_with_type,
+            decl_type=decl_type,
+            shared_phase=shared,
+        )
+        out.append((decl_type, result))
+    return out

app/pipeline/postprocess.py

@@ -324,8 +324,19 @@ def fix_dollar_digit(exercise: str) -> tuple[str, list[dict]]:
        • `$` non échappé immédiatement suivi d'un chiffre  → `${}` + chiffre
        • `$` non échappé immédiatement suivi de `{{`       → `${}{{`
     Le groupe vide {} est invisible au rendu mais empêche la lecture
-    « montant en devise » qui désynchronise tout le `$…$`."""
+    « montant en devise » qui désynchronise tout le `$…$`.
+    EXCLUSION : les lignes `:solution:` (FGQ) — c'est un motif de
+    correspondance de réponse, pas du texte affiché ; un `${}` y casserait
+    la correction automatique."""
     masked, blocks = mask_python_blocks(exercise)
+    # Masque les lignes :solution: (elles ne doivent pas être réécrites).
+    sol_lines: list[str] = []
+
+    def _mask_sol(m: re.Match) -> str:
+        sol_lines.append(m.group(0))
+        return f"\x00SOLLINE{len(sol_lines) - 1}\x00"
+
+    masked = re.sub(r"(?m)^:solution:.*$", _mask_sol, masked)
     patches: list[dict] = []
 
     def _digit(m: re.Match) -> str:
@@ -350,6 +361,8 @@ def fix_dollar_digit(exercise: str) -> tuple[str, list[dict]]:
 
     masked = re.sub(r"(?<!\\)\$(?!\{)(\d)", _digit, masked)
     masked = re.sub(r"(?<!\\)\$\{\{", _inj, masked)
+    for i, line in enumerate(sol_lines):
+        masked = masked.replace(f"\x00SOLLINE{i}\x00", line)
     return unmask_python_blocks(masked, blocks), patches
 
 
@@ -605,6 +618,102 @@ def check_hardcoded_decimals_in_solutions(exercise: str) -> list[dict]:
     return warnings
 
 
+# ─────────────────────────────────────────────────────────────────────────────
+# Déclinaisons QCM/QAT — filets déterministes (mode `declinaisons`)
+# ─────────────────────────────────────────────────────────────────────────────
+
+QUESTION_BLOCK_RE = _QUESTION_BLOCK_RE          # réutilisé par le harnais étendu
+MCQ_ANSWER_RE = re.compile(
+    r"::::\{mcqAnswer\}\s*\n:isRightAnswer:\s*(true|false)\s*\n(.*?)\n::::",
+    re.DOTALL,
+)
+_NONE_OPTION_RE = re.compile(r"Aucune de ces réponses|None of these answers", re.IGNORECASE)
+
+
+def fix_none_option_last(exercise: str) -> tuple[str, int]:
+    """MCQ : l'option « Aucune de ces réponses / None » doit être le DERNIER
+    mcqAnswer de sa question — on la déplace si besoin (filet déterministe)."""
+    moved = {"n": 0}
+
+    def _fix_question(qm: re.Match) -> str:
+        block = qm.group(0)
+        answers = list(MCQ_ANSWER_RE.finditer(block))
+        if len(answers) < 2:
+            return block
+        none_idx = [i for i, a in enumerate(answers) if _NONE_OPTION_RE.search(a.group(2))]
+        if not none_idx or none_idx[-1] == len(answers) - 1:
+            return block
+        i = none_idx[-1]
+        none_text = answers[i].group(0)
+        # retire l'option None puis la réinsère après le dernier mcqAnswer
+        block2 = block.replace(none_text + "\n\n", "", 1).replace(none_text, "", 1)
+        last = list(MCQ_ANSWER_RE.finditer(block2))[-1]
+        block2 = block2[:last.end()] + "\n\n" + none_text + block2[last.end():]
+        moved["n"] += 1
+        return block2
+
+    new = QUESTION_BLOCK_RE.sub(_fix_question, exercise)
+    return new, moved["n"]
+
+
+def fix_mcq_answer_aliases(exercise: str) -> tuple[str, int]:
+    """Normalise les blocs d'options MCQ mal nommés/incomplets (vus en prod) :
+      • `::::{mcqOption}` / `::::{mcqChoice}` → `::::{mcqAnswer}` ;
+      • bloc mcqAnswer SANS ligne `:isRightAnswer:` → insère `false` (défaut)."""
+    fixed = {"n": 0}
+    out, n_alias = re.subn(r"(?m)^::::\{mcq(?:Option|Choice)\}", "::::{mcqAnswer}", exercise)
+    fixed["n"] += n_alias
+
+    def _ensure_flag(m: re.Match) -> str:
+        head, rest = m.group(1), m.group(2)
+        if rest.lstrip().startswith(":isRightAnswer:"):
+            return m.group(0)
+        fixed["n"] += 1
+        return f"{head}:isRightAnswer: false\n{rest}"
+
+    out = re.sub(r"(?ms)^(::::\{mcqAnswer\}\n)(.*?)(?=^::::$)",
+                 lambda m: _ensure_flag(m), out)
+    return out, fixed["n"]
+
+
+def merge_decl_python_blocks(exercise: str) -> tuple[str, int]:
+    """DÉCLINAISONS : la spec impose UN SEUL bloc {python}. Fusionne les blocs
+    additionnels dans le bloc principal (ordre préservé, un seul `globals()`
+    final) — SAUF si un bloc ultérieur RE-TIRE de l'aléatoire (`rd.`/`random.`) :
+    re-tirage = bug sémantique (valeurs incohérentes entre questions), on le
+    laisse en place pour que le harnais le signale et que la réparation LLM
+    corrige à la source."""
+    blocks = list(PYTHON_FENCE_RE.finditer(exercise))
+    if len(blocks) < 2:
+        return exercise, 0
+    extras = blocks[1:]
+    if any(re.search(r"\brd\.|(?<!_)\brandom\.", m.group("code")) for m in extras):
+        return exercise, 0          # re-tirage suspect → laisser le harnais trancher
+
+    main = blocks[0]
+    parts = [re.sub(r"(?m)^\s*globals\(\)\s*$", "", main.group("code")).rstrip()]
+    for m in extras:
+        code = re.sub(r"(?m)^\s*globals\(\)\s*$", "", m.group("code")).strip()
+        if code:
+            parts.append(code)
+    merged_code = "\n\n".join(parts) + "\n\nglobals()"
+
+    # Supprime les blocs additionnels (indices inversés), puis remplace le principal.
+    out = exercise
+    for m in reversed(extras):
+        out = out[:m.start()] + out[m.end():]
+    m0 = PYTHON_FENCE_RE.search(out)
+    out = (out[:m0.start()]
+           + f"{m0.group('open')}{{python}}\n{merged_code}\n{m0.group('open')}"
+           + out[m0.end():])
+    return re.sub(r"\n{3,}", "\n\n", out), len(extras)
+
+
+# (Les contrôles statiques MCQ/FGQ — {{}} dans un rôle, :solution:, résidus
+#  légacy — vivent dans validation/harness.py::check_declinaison_static :
+#  une seule source de vérité pour le verdict.)
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # Langues : détection, réduction bilingue → mono, contrôle des décimales
 # ─────────────────────────────────────────────────────────────────────────────

app/pipeline/prompts.py

@@ -523,6 +523,279 @@ TRANSLATE_FORMAT_BOTH = (
 )
 
 
+# ─────────────────────────────────────────────────────────────────────────────
+# DÉCLINAISONS QCM / QAT (NOUVEAU 2026-07 — mode `declinaisons`)
+# Spécification normative fournie par l'équipe (PROMPT_declinaisons_QCM_QAT §4-§6),
+# calibrée sur les 33 exemples validés de knowledge/fewshots/declinaisons/.
+# Divergences wx ↔ conventions strictes (corpus 222) tranchées : format
+# plateforme des wx (mcqAnswer/:solution:/{input}) + conventions strictes de
+# l'app (fences 4, globals(), injections nues camelCase Aff, IDs contigus).
+# ─────────────────────────────────────────────────────────────────────────────
+
+MCQ_SPEC = """\
+FORMAT QCM (questionType MCQ) — NORMATIF :
+
+:::::{question}
+:questionType: MCQ
+:questionId: N
+:questionIndex: N
+
+::::{questionStatement}
+<énoncé auto-suffisant ; maths et {{ }} HORS des rôles bilingues>
+::::
+
+::::{questionHint}
+<indice — peut rester vide ; VERBATIM si repris de la source>
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+<BONNE réponse — TOUJOURS en slot 1>
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+<distracteur 1 — erreur type>
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+<distracteur 2 — erreur type>
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+<distracteur 3 — erreur type>
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+<solution détaillée ; VERBATIM de la source si elle existe, sinon rédigée>
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 25
+:reasoning: 25
+:calculation: 25
+::::
+:::::
+
+RÈGLES MCQ DURES :
+  • EXACTEMENT UNE option `:isRightAnswer: true`, EN SLOT 1 (l'affichage est
+    mélangé côté plateforme — ne PAS randomiser l'ordre dans le fichier).
+  • 5 options par défaut (1 correcte + 3 distracteurs + « None » EN DERNIER).
+    Ensembles fermés (vrai/faux, intervalles exhaustifs) : « None » omis
+    autorisé (⇒ 4 options ; jamais moins de 3).
+  • PAS de `:solution:`, PAS de `{input}`, PAS de displayedSolution en MCQ.
+  • Ordre des blocs : questionStatement → questionHint → mcqAnswer×N →
+    detailedSolution → weightDistribution.
+  • L'option « None » et toute option textuelle sont bilingues si la cible l'est.
+
+DISTRACTEURS — ERREURS TYPES UNIQUEMENT (aucune valeur au hasard) :
+  • Algèbre : erreur de signe ; coefficient inversé ; terme oublié ; distribution partielle.
+  • Dérivées : oubli du facteur de la règle de chaîne ; exposant non décrémenté ;
+    primitive au lieu de dérivée ; quotient sans v² ; produit sans la 2e moitié.
+  • Intégrales : oubli du +1 sur l'exposant ; oubli du 1/a ; dérivée au lieu de
+    primitive ; oubli de |x| dans ln.
+  • Matrices : transposée ; colonnes/lignes échangées ; entrée non dérivée ;
+    matrice opposée ; oubli du terme +b.
+  • Compositions affines : oubli de b_f ; ordre inversé (g∘f vs f∘g) ; signe opposé.
+  • Limites : mauvaise forme indéterminée ; mauvais signe d'infini.
+
+ANTI-COLLISION (le piège n°1 des QCM randomisés — un distracteur peut devenir
+ÉGAL à la bonne réponse sur certaines graines) — dans CET ordre :
+  1. DISTINCT PAR CONSTRUCTION (préféré) : distracteurs de type différent,
+     tirages qui garantissent la non-nullité/non-égalité (coefficients >= 2,
+     exposants >= 2, entrées non nulles…). Documente-le en commentaire Python.
+  2. TIRAGE AVEC REJET dans le bloc Python : reboucler tant que les chaînes
+     RENDUES (latex) de toutes les options ne sont pas toutes distinctes.
+  3. Le harnais vérifie l'unicité sur 100 graines — un doublon = REJET.
+  ⚠️ La collision est aussi SÉMANTIQUE : deux options formulées différemment
+  mais mathématiquement ÉQUIVALENTES (« divise x par 2 » ≡ « multiplie x par
+  1/2 » ; « T_{1/a,1/b} » ≡ « division par a et b ») comptent comme un doublon
+  pour l'élève. Vérifie l'équivalence MATHÉMATIQUE de chaque paire d'options
+  sur TOUT l'espace des tirages (ex. b == 1/a possible ? → l'exclure au tirage).
+
+UN SEUL bloc {python} au total : JAMAIS de re-tirage (`rd.`/`random`) hors du
+bloc principal — un second tirage rendrait les valeurs incohérentes entre les
+questions. Les variables des paires suivantes s'ajoutent SANS aléa nouveau.
+
+FORMATAGE : STRICTEMENT IDENTIQUE entre bonne réponse et distracteurs (même
+style LaTeX, mêmes helpers, même nombre de décimales, même notation
+matricielle) — sinon la bonne réponse se devine.
+
+L'ÉNONCÉ NE DONNE JAMAIS LA RÉPONSE (l'énoncé définit, la question interroge).
+"""  # noqa: E501 — texte normatif verbatim (valeur injectée telle quelle, accolades SIMPLES)
+
+FGQ_SPEC = """\
+FORMAT QAT (questionType FGQ — question à champ(s) libre(s) ordonné(s)) — NORMATIF :
+
+:::::{question}
+:questionType: FGQ
+:questionId: N
+:questionIndex: N
+:solution: [["ord","${{v1Aff}}$","${{v2Aff}}$"],["0","0"]]
+
+::::{questionStatement}
+<énoncé auto-suffisant>
+
+<LIGNE VIDE obligatoire avant le premier {input}>
+$x_1 =$ {input}`||110` $\\qquad x_2 =$ {input}`||110`
+::::
+
+::::{questionHint}
+<indice — vide ou verbatim source>
+::::
+
+::::{displayedSolution}
+$x_1 = {{v1Aff}}$, $\\quad x_2 = {{v2Aff}}$
+::::
+
+::::{detailedSolution}
+<solution détaillée>
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 20
+:calculation: 45
+::::
+:::::
+
+RÈGLES FGQ DURES :
+  • `:solution:` DIRECTEMENT dans le champ (jamais construite dans une variable
+    Python), juste après `:questionIndex:`. Format [["ord","<v1>",…],["0",…]].
+  • ARITÉ STRICTE : nb de {input} == nb de valeurs dans "ord" == nb de
+    tolérances. Tolérance TOUJOURS "0" (exacte).
+  • Un `{{varAff}}` par valeur dynamique dans `:solution:` (variable NUE).
+  • ORDRE : les valeurs de "ord" suivent l'ordre d'apparition des {input}
+    dans l'énoncé. Plusieurs solutions (racines…) → ÉNONCER l'ordre (« de la
+    plus petite à la plus grande ») et le respecter dans "ord" ET dans
+    displayedSolution.
+  • Chaque {input} est INTRODUIT PAR UN LABEL ($x =$ {input}`||110`),
+    jamais nu, jamais collé à la prose ; LIGNE VIDE avant le premier {input}.
+  • Ordre des blocs : questionStatement → questionHint → displayedSolution →
+    detailedSolution → weightDistribution.
+  • Valeurs EXACTES (fractions, \\ln, \\sqrt, +\\infty…) — JAMAIS de décimales
+    approchées dans `:solution:`.
+  • REPLI MCQ : si une question n'est PAS auto-corrigeable en champ libre
+    (réponse avec fonction abstraite, vrai/faux, matrice à dimension VARIABLE),
+    produis cette question en MCQ (format ci-contre) — une sortie QAT peut être
+    mixte FGQ + MCQ. Ne force JAMAIS un champ libre ingérable.
+
+MATRICES EN QAT (PIÈGE plateforme) :
+  • `pxsl_matrix` est INTERDIT dans un champ `:solution:` (le rendu
+    \\left[\\begin{array}… ne matche pas le widget). Si champ unique matrice :
+    variable calculée avec latex(M, mat_delim='', mat_str='pmatrix') (FR)
+    ou mat_str='bmatrix' (EN), injectée nue.
+  • Dimension variable ⇒ repli MCQ pour cette question.
+
+L'ÉNONCÉ NE DONNE JAMAIS LA RÉPONSE (l'énoncé définit, la question interroge).
+"""  # noqa: E501 — texte normatif verbatim (valeur injectée telle quelle, accolades SIMPLES)
+
+# Prompt de génération d'une déclinaison (QCM ou QAT) — même mécanique par
+# paires que la pythonisation ; le champ {decl_spec} reçoit MCQ_SPEC ou FGQ_SPEC.
+STEP_DECLINAISON_PROMPT = """\
+Tu déclines un exercice PyxiScience MyST en version {decl_label}, niveau {niveau}.
+L'exercice source (statique OU déjà pythonisé) est fourni ; tu produis la
+déclinaison RANDOMISÉE (bloc Python terminé par `globals()` + injections),
+au format plateforme EXACT ci-dessous.
+
+═══════════════════════════════════════════════════════════════════════════
+ CONVENTIONS PLATEFORME (identiques à la pythonisation — NON NÉGOCIABLES)
+═══════════════════════════════════════════════════════════════════════════
+  • Bloc Python : 4 backticks ````{{python}} … ```` terminé par `globals()`.
+  • Injections `{{{{ }}}}` : UNIQUEMENT des noms de variables NUS camelCase
+    suffixe `Aff` — JAMAIS d'appel de fonction, de calcul, d'underscore, ni
+    d'accès dict. Tout se pré-calcule dans le bloc Python.
+  • `{{{{ }}}}` et les maths TOUJOURS HORS des rôles {{fr}}`…`{{en}}`…` (un
+    placeholder dans un rôle ne s'évalue PAS — texte cassé).
+  • Règle du `$` collé à un chiffre : préfixe `${{}}`. Décimales localisées
+    (virgule FR / point EN). `latex(expr, **config_standard)`.
+  • `:questionId:`/`:questionIndex:` contigus dès 0.
+  • Interdits : \\py{{}}, \\qcm, \\qat, \\qcl, \\right/\\wrong (légacy),
+    \\begin{{align*}}, \\displaystyle, \\[ \\], $$.
+
+FIDÉLITÉ À LA SOURCE :
+  • 1 question source → 1 question déclinée. NE JAMAIS inventer de
+    sous-questions ni enrichir l'énoncé.
+  • L'énoncé ne doit JAMAIS donner la réponse (l'énoncé définit, la question
+    interroge).
+  • detailedSolution : VERBATIM de la source si elle existe (seules les valeurs
+    littérales deviennent des {{{{varAff}}}}), sinon rédigée sobrement.
+  • Source DÉJÀ PYTHONISÉE : recopie son bloc Python À L'IDENTIQUE (octet pour
+    octet), puis ajoute `# === Ajouts déclinaison {decl_label} ===` suivi des
+    NOUVELLES variables (distracteurs/solutions), AVANT le `globals()` final.
+  • weightDistribution : repris de la question source si présent, sinon le
+    barème par défaut du format ci-dessous (somme = 100 TOUJOURS).
+
+═══════════════════════════════════════════════════════════════════════════
+ SPÉCIFICATION DU FORMAT {decl_label}
+═══════════════════════════════════════════════════════════════════════════
+{decl_spec}
+
+═══════════════════════════════════════════════════════════════════════════
+ EXEMPLE CANONIQUE COMPLET (structure et conventions à imiter)
+═══════════════════════════════════════════════════════════════════════════
+{fewshot}
+
+═══════════════════════════════════════════════════════════════════════════
+ CATALOGUE PyxiScience (helpers à utiliser DANS le bloc Python)
+═══════════════════════════════════════════════════════════════════════════
+{functions}
+
+═══════════════════════════════════════════════════════════════════════════
+ CONTEXTE
+═══════════════════════════════════════════════════════════════════════════
+
+EN-TÊTE déjà finalisé (NE PAS reproduire) :
+{content}
+
+VARIABLES DÉTECTÉES :
+{analysis}
+
+BLOCS PRÉCÉDENTS (ne pas redéfinir leurs variables, ne pas les répéter) :
+{previous_blocks}
+
+SECTION À DÉCLINER ({range_label} / {nb_total}) :
+{current_segment}
+
+{lang_directive}
+
+═══════════════════════════════════════════════════════════════════════════
+ RÈGLES D'ASSEMBLAGE PAR PAIRE
+═══════════════════════════════════════════════════════════════════════════
+⚠️ TU PRODUIS UNIQUEMENT LE CONTENU DE CETTE PAIRE (les paires précédentes
+sont concaténées mécaniquement avant ta sortie).
+⚠️ EXACTEMENT {nb_current} bloc(s) `:::::{{question}}` — questionId/questionIndex
+CONTINUS depuis la paire précédente.
+⚠️ PAIRE 1 UNIQUEMENT : le bloc ````{{python}}```` (source recopiée si déjà
+pythonisée + ajouts déclinaison + `globals()`) puis l'énoncé général VERBATIM,
+AVANT la première question.
+⚠️ PAIRES SUIVANTES : ni énoncé, ni ré-imports ; petit bloc ````{{python}}````
+additionnel possible pour les nouvelles variables seulement.
+
+═══════════════════════════════════════════════════════════════════════════
+ CHECKLIST FINALE
+═══════════════════════════════════════════════════════════════════════════
+  □ Bloc ````{{python}}```` (4 backticks) terminé par `globals()`
+  □ CHAQUE `{{{{ }}}}` = variable NUE camelCase (Aff) — aucun appel/underscore
+  □ Aucun `{{{{ }}}}` NI maths à l'intérieur d'un rôle {{fr}}`…`/{{en}}`…`
+  □ MCQ : 1 seule bonne réponse (slot 1), « None » en dernier, options toutes
+    distinctes SUR TOUTES LES GRAINES, formatage identique
+  □ FGQ : arité #input == #valeurs == #tolérances ("0"), :solution: littérale,
+    ordre énoncé/"ord"/displayedSolution cohérents, labels devant chaque {{input}}
+  □ 1 question source → 1 question ; solutions source VERBATIM ; poids repris
+  □ IDs contigus dès 0 ; aucun motif interdit ; `\\%` pour les pourcentages
+"""
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # Réparation post-harnais (NOUVEAU — 1 itération max)
 # ─────────────────────────────────────────────────────────────────────────────
@@ -554,9 +827,21 @@ RÈGLES DE CORRECTION :
     TIRAGE DÉGÉNÉRÉ — exclure la valeur fautive à la source
     (ex. `b = rd.randint(2, 5)` au lieu de `randint(1, 5)`, ou boucle de rejet
     `if b == 1: continue`). Ne PAS rafistoler le texte : corriger le tirage.
+    **EXCEPTION — texte pédagogique FIXE** qui enseigne précisément la règle de
+    l'exposant (`$b^{{0}} = 1$`, `$b^{{1}} = b$`) : réécrire SANS accolades
+    (`$b^0 = 1$`, `$b^1 = b$`) — rendu LaTeX identique pour un exposant à un
+    seul caractère, et conforme au corpus validé.
   • Injection non nue → pré-calculer en variable camelCase `…Aff`.
   • Le bloc {{python}} reste à 4 backticks et se termine par `globals()`.
   • Ne touche NI à `\\inftys`/`\\ds`/`\\dfrac`, NI à la prose des solutions.
+  • **QCM — collision d'options** (deux options rendues identiques sur une
+    graine) : contraindre le TIRAGE (rejet `while` sur les chaînes rendues) ou
+    changer la CONSTRUCTION du distracteur — jamais rafistoler le texte.
+  • **QCM — plusieurs/zéro `:isRightAnswer: true`** : exactement une, en slot 1.
+  • **FGQ — arité** : le nb de {{{{input}}}} doit égaler le nb de valeurs de
+    `"ord"` et le nb de tolérances ("0") dans `:solution:`.
+  • **`{{{{ }}}}` dans un rôle {{fr}}`…`/{{en}}`…`** : sortir l'injection du
+    rôle (elle ne s'évalue pas dedans) — découper le rôle autour.
 
 Réponds UNIQUEMENT avec l'exercice complet corrigé (de `````{{exercise}} à `````),
 sans préambule ni wrapper markdown.

app/server.py

@@ -30,10 +30,11 @@ from flask import Response, jsonify, render_template, request, send_file
 from app.config import (
     AVAILABLE_MODELS,
     DEFAULT_LANG,
+    DEFAULT_MODE,
     DEFAULT_MODEL_IDX,
     JOB_TTL,
 )
-from app.pipeline.orchestrator import run_exercise
+from app.pipeline.orchestrator import run_declinaisons, run_exercise
 
 logger = logging.getLogger(__name__)
 
@@ -42,6 +43,7 @@ _JOBS_LOCK = threading.Lock()
 
 VALID_LANGS = ("fr", "en", "both")
 VALID_LEVELS = ("", "Elementary", "Intermediate", "Advanced")
+VALID_MODES = ("pythonise", "declinaisons")
 
 
 def _set_job(job_id: str, **kwargs):
@@ -57,14 +59,16 @@ def _get_job(job_id: str):
 
 
 def _safe_md_name(filename: str, used: set) -> str:
-    """Nom de fichier .md sûr et unique pour la sortie pythonisée
-    (suffixe _pythonise pour ne pas écraser la source)."""
+    """Nom de fichier .md sûr et unique pour le ZIP. Les déclinaisons portent
+    déjà leur suffixe (_QCM/_QAT) ; la pythonisation reçoit _pythonise pour
+    ne pas écraser la source."""
     base = re.sub(r"\.(md|txt)$", "", filename or "", flags=re.IGNORECASE)
     base = re.sub(r"[^\w.\-() ]+", "_", base).strip() or "exercice"
-    name = f"{base}_pythonise.md"
+    suffix = "" if re.search(r"_(QCM|QAT)$", base) else "_pythonise"
+    name = f"{base}{suffix}.md"
     i = 2
     while name in used:
-        name = f"{base}_pythonise_{i}.md"
+        name = f"{base}{suffix}_{i}.md"
         i += 1
     used.add(name)
     return name
@@ -78,8 +82,17 @@ def _purge_old_jobs():
             del _JOBS[jid]
 
 
-def _run_job(job_id: str, files: list[dict], level: str, model_idx: int, lang: str):
-    """Worker de job : boucle séquentielle sur les fichiers, robuste."""
+def _decl_output_name(source_name: str, decl_type: str) -> str:
+    """foo.md + qcm → foo_QCM.md (nommage de sortie des déclinaisons)."""
+    base = re.sub(r"\.(md|txt)$", "", source_name or "exercice", flags=re.IGNORECASE)
+    return f"{base}_{'QCM' if decl_type == 'qcm' else 'QAT'}.md"
+
+
+def _run_job(job_id: str, files: list[dict], level: str, model_idx: int,
+             lang: str, mode: str = "pythonise", decl_types: list | None = None):
+    """Worker de job : boucle séquentielle sur les fichiers, robuste.
+    En mode `declinaisons`, chaque source produit 1 résultat PAR type coché
+    (analyse partagée entre types — aucun appel LLM redondant)."""
     results: list[dict] = []
     for i, f in enumerate(files):
         name = f.get("filename") or f"fichier_{i + 1}.md"
@@ -90,19 +103,36 @@ def _run_job(job_id: str, files: list[dict], level: str, model_idx: int, lang: s
             _set_job(job_id, step_label=f"[{_i + 1}/{len(files)}] {_name} — {label}")
 
         try:
-            result = run_exercise(
-                content=f["content"],
-                filename=name,
-                level=level,
-                model_idx=model_idx,
-                lang=lang,
-                set_step=set_step,
-            )
-            results.append({"filename": name, "status": "done", "result": result})
-            logger.info("Fichier %s : harnais %s, %d warnings, %.1fs, %.4f$",
-                        name, "VERT" if result["harness"]["ok"] else "ROUGE",
-                        len(result["warnings"]), result["duration_s"],
-                        result["cost"]["usd"])
+            if mode == "declinaisons":
+                for decl_type, result in run_declinaisons(
+                    content=f["content"],
+                    filename=name,
+                    level=level,
+                    model_idx=model_idx,
+                    lang=lang,
+                    types=decl_types,
+                    set_step=set_step,
+                ):
+                    out_name = _decl_output_name(name, decl_type)
+                    results.append({"filename": out_name, "status": "done", "result": result})
+                    logger.info("Déclinaison %s : harnais %s, %d warnings, %.1fs, %.4f$",
+                                out_name, "VERT" if result["harness"]["ok"] else "ROUGE",
+                                len(result["warnings"]), result["duration_s"],
+                                result["cost"]["usd"])
+            else:
+                result = run_exercise(
+                    content=f["content"],
+                    filename=name,
+                    level=level,
+                    model_idx=model_idx,
+                    lang=lang,
+                    set_step=set_step,
+                )
+                results.append({"filename": name, "status": "done", "result": result})
+                logger.info("Fichier %s : harnais %s, %d warnings, %.1fs, %.4f$",
+                            name, "VERT" if result["harness"]["ok"] else "ROUGE",
+                            len(result["warnings"]), result["duration_s"],
+                            result["cost"]["usd"])
         except Exception as exc:
             logger.exception("Échec du pipeline sur %s", name)
             results.append({"filename": name, "status": "error", "error": str(exc)})
@@ -212,6 +242,18 @@ def register_routes(app):
                 "error": f"'model_idx' inconnu : {model_idx}. Valides : {sorted(AVAILABLE_MODELS)}."
             }), 400
 
+        mode = (data.get("mode") or DEFAULT_MODE).strip()
+        if mode not in VALID_MODES:
+            return jsonify({"error": f"'mode' invalide : {mode!r} (pythonise|declinaisons)."}), 400
+        decl_types: list = []
+        if mode == "declinaisons":
+            types_obj = data.get("types") or {}
+            if not isinstance(types_obj, dict):
+                return jsonify({"error": "'types' doit être un objet {qcm: bool, qat: bool}."}), 400
+            decl_types = [t for t in ("qcm", "qat") if types_obj.get(t)]
+            if not decl_types:
+                return jsonify({"error": "En mode 'declinaisons', cocher au moins un type (qcm/qat)."}), 400
+
         job_id = uuid.uuid4().hex
         with _JOBS_LOCK:
             _JOBS[job_id] = {
@@ -229,7 +271,7 @@ def register_routes(app):
 
         threading.Thread(
             target=_run_job,
-            args=(job_id, clean_files, level, model_idx, lang),
+            args=(job_id, clean_files, level, model_idx, lang, mode, decl_types),
             daemon=True,
         ).start()
         return jsonify({"job_id": job_id}), 202

app/validation/harness.py

@@ -65,18 +65,25 @@ def install_pyxiscience_stubs() -> None:
         # sympy.latex (qui rejette toute clé inconnue).
         return {}
 
+    # Liste canonique partagée avec la sandbox (les deux systèmes de stubs
+    # partagent sys.modules — le premier installé sert aux deux).
+    from app.validation.sandbox import KNOWN_PXS_HELPERS
+
     def _make_module(name: str) -> types.ModuleType:
         mod = types.ModuleType(name)
 
         def __getattr__(attr):  # PEP 562
             if attr == "pxs_config":
                 return _pxs_config
+            if attr == "pxs_variation_number":
+                return 1
             # Classe si CamelCase OU motif pxs_Xxx (pxs_Interval, pxs_Plotable…)
             if attr and (attr[0].isupper() or re.match(r"pxs_[A-Z]", attr)):
                 return _Universal
             return _passthrough
 
         mod.__getattr__ = __getattr__
+        mod.__all__ = list(KNOWN_PXS_HELPERS)
         return mod
 
     root = _make_module("pyxiscience")
@@ -184,6 +191,132 @@ def scan_forbidden(body: str) -> list[str]:
     return errs
 
 
+# ── Contrôles déclinaisons QCM/QAT (mode `declinaisons`) ─────────────────────
+
+_QUESTION_RE = re.compile(r":::::\{question\}.*?:::::", re.DOTALL)
+_MCQ_ANSWER_RE = re.compile(
+    r"::::\{mcqAnswer\}\s*\n:isRightAnswer:\s*(true|false)\s*\n(.*?)\n::::",
+    re.DOTALL,
+)
+_NONE_OPTION_RE = re.compile(r"Aucune de ces réponses|None of these answers", re.IGNORECASE)
+_SOLUTION_FIELD_RE = re.compile(r"(?m)^:solution:[ \t]*(.+)$")
+_INPUT_RE = re.compile(r"\{input\}`")
+_QTYPE_RE = re.compile(r":questionType:\s*(\w+)")
+
+
+def has_declinaison_questions(text: str) -> bool:
+    return bool(re.search(r":questionType:\s*(MCQ|FGQ)\b", text))
+
+
+_LEGACY_PATTERNS = [
+    (re.compile(r"\\py\{"), r"résidu légacy `\py{`"),
+    (re.compile(r"\\qcm\b|\\qat\b|\\qcl\b"), r"résidu légacy `\qcm`/`\qat`/`\qcl`"),
+    (re.compile(r"\\input\{null\}"), r"résidu légacy `\input{null}`"),
+    (re.compile(r"\\begin\{align\*?\}"), r"`\begin{align*}` interdit (utiliser equation*)"),
+    (re.compile(r"(?<!\\)\$\$"), r"`$$` interdit (utiliser equation*)"),
+]
+
+
+def check_declinaison_static(text: str) -> list[str]:
+    """Contrôles statiques MCQ/FGQ (indépendants des graines)."""
+    import json as _json
+    errs: list[str] = []
+    body = strip_python_blocks(text)
+
+    # {{ }} dans un rôle bilingue → ne s'évalue pas.
+    for m in re.finditer(r"\{(?:fr|en)\}`([^`]*)`", body):
+        if "{{" in m.group(1):
+            errs.append(f"injection `{{{{…}}}}` dans un rôle bilingue : …{m.group(0)[:80]}…")
+            break
+
+    # Résidus de l'ancienne syntaxe plateforme.
+    errs += [msg for rx, msg in _LEGACY_PATTERNS if rx.search(body)]
+
+    # UN SEUL bloc {python} en déclinaison (un bloc additionnel qui RE-TIRE de
+    # l'aléatoire rendrait les valeurs incohérentes entre questions ; les blocs
+    # sans re-tirage sont fusionnés en amont par merge_decl_python_blocks).
+    n_blocks = len(PY_FENCE_ANY_RE.findall(text))
+    if n_blocks > 1:
+        errs.append(f"{n_blocks} blocs {{python}} (un seul attendu en déclinaison — "
+                    "bloc additionnel avec re-tirage aléatoire probable)")
+
+    # Approximations dans :solution: (valeurs exactes uniquement).
+    for m in _SOLUTION_FIELD_RE.finditer(text):
+        if "\\approx" in m.group(1) or "≈" in m.group(1):
+            errs.append("approximation (≈) dans un champ `:solution:` — valeurs exactes uniquement")
+            break
+
+    for qi, qm in enumerate(_QUESTION_RE.finditer(text)):
+        q = qm.group(0)
+        tm = _QTYPE_RE.search(q)
+        qtype = tm.group(1) if tm else "?"
+
+        if qtype == "MCQ":
+            answers = list(_MCQ_ANSWER_RE.finditer(q))
+            n_true = sum(1 for a in answers if a.group(1) == "true")
+            if n_true != 1:
+                errs.append(f"question {qi} (MCQ) : {n_true} option(s) `:isRightAnswer: true` (attendu : exactement 1)")
+            if not (3 <= len(answers) <= 6):
+                errs.append(f"question {qi} (MCQ) : {len(answers)} options (attendu : 3 à 5)")
+            none_idx = [i for i, a in enumerate(answers) if _NONE_OPTION_RE.search(a.group(2))]
+            if none_idx and none_idx[-1] != len(answers) - 1:
+                errs.append(f"question {qi} (MCQ) : option « None/Aucune » pas en dernière position")
+            if _SOLUTION_FIELD_RE.search(q) or _INPUT_RE.search(q):
+                errs.append(f"question {qi} (MCQ) : `:solution:`/`{{input}}` interdits en MCQ")
+
+        elif qtype == "FGQ":
+            sol = _SOLUTION_FIELD_RE.search(q)
+            n_inputs = len(_INPUT_RE.findall(q))
+            if not sol:
+                errs.append(f"question {qi} (FGQ) : champ `:solution:` manquant")
+                continue
+            if n_inputs == 0:
+                errs.append(f"question {qi} (FGQ) : aucun `{{input}}` dans l'énoncé")
+            raw = sol.group(1).strip()
+            if "pxsl_matrix" in raw:
+                errs.append(f"question {qi} (FGQ) : `pxsl_matrix` dans `:solution:` (interdit)")
+            # Parse JSON structurel : on remplace les {{var}} par un littéral neutre.
+            probe = INJECTION_RE.sub("V", raw)
+            try:
+                data = _json.loads(probe)
+                assert (isinstance(data, list) and len(data) == 2
+                        and isinstance(data[0], list) and isinstance(data[1], list)
+                        and data[0] and data[0][0] in ("ord", "CL"))
+                n_vals = len(data[0]) - 1
+                n_tols = len(data[1])
+                if not (n_vals == n_tols == n_inputs):
+                    errs.append(f"question {qi} (FGQ) : arité incohérente — "
+                                f"{n_inputs} input(s), {n_vals} valeur(s), {n_tols} tolérance(s)")
+                if any(str(t).strip() != "0" for t in data[1]):
+                    errs.append(f"question {qi} (FGQ) : tolérance ≠ \"0\"")
+            except Exception:
+                errs.append(f"question {qi} (FGQ) : `:solution:` non parseable en JSON : {raw[:80]}")
+
+    return errs
+
+
+def check_mcq_collisions(text: str, env: dict) -> list[str]:
+    """Pour UNE graine : deux options d'un même MCQ rendues identiques = échec.
+    (Le piège n°1 des QCM randomisés — un distracteur « erreur type » peut
+    devenir égal à la bonne réponse sur certaines graines.)"""
+    errs: list[str] = []
+    for qi, qm in enumerate(_QUESTION_RE.finditer(text)):
+        q = qm.group(0)
+        if not re.search(r":questionType:\s*MCQ\b", q):
+            continue
+        rendered: list[str] = []
+        for a in _MCQ_ANSWER_RE.finditer(q):
+            r, _unres = render_body(a.group(2), env)
+            rendered.append(re.sub(r"\s+", " ", r).strip())
+        seen: dict[str, int] = {}
+        for i, r in enumerate(rendered):
+            if r in seen:
+                errs.append(f"question {qi} (MCQ) : options {seen[r]} et {i} identiques après rendu : « {r[:70]} »")
+            else:
+                seen[r] = i
+    return errs
+
+
 # ── Rendu (substitution des injections) ──────────────────────────────────────
 
 def render_body(body_tmpl: str, env: dict) -> tuple[str, list[str]]:
@@ -218,6 +351,9 @@ def validate_text(text: str, seeds: int = 100) -> dict:
       }
     """
     static_errors = check_injection_tokens(text) + check_question_ids(text)
+    declinaison = has_declinaison_questions(text)
+    if declinaison:
+        static_errors += check_declinaison_static(text)
     code = extract_python_code(text)
     if code is None:
         static_errors.append("aucun bloc `{python}` trouvé")
@@ -229,6 +365,7 @@ def validate_text(text: str, seeds: int = 100) -> dict:
         "n_exec_errors": 0,
         "n_unresolved": 0,
         "n_forbidden": 0,
+        "n_mcq_collisions": 0,
         "first_failures": [],
     }
     if code is None:
@@ -261,11 +398,22 @@ def validate_text(text: str, seeds: int = 100) -> dict:
             report["n_unresolved"] += 1
             if len(failures) < 8:
                 failures.append(f"seed {s} : variable(s) non résolue(s) : {sorted(set(unresolved))}")
-        fb = scan_forbidden(rendered)
+        # Les lignes `:solution:` (FGQ) sont des motifs de correspondance de
+        # réponse, pas du texte affiché : exclues du scan des motifs interdits
+        # (`$5$` y est légitime — confirmé par les exemples validés). Leur
+        # format est contrôlé séparément (JSON, arité, exactitude).
+        scan_target = re.sub(r"(?m)^:solution:.*$", "", rendered)
+        fb = scan_forbidden(scan_target)
         if fb:
             report["n_forbidden"] += 1
             if len(failures) < 8:
                 failures.append(f"seed {s} : motif interdit : {fb[0]}")
+        if declinaison:
+            mc = check_mcq_collisions(text, env)
+            if mc:
+                report["n_mcq_collisions"] += 1
+                if len(failures) < 8:
+                    failures.append(f"seed {s} : collision d'options MCQ : {mc[0]}")
 
     report["first_failures"] = failures
     report["ok"] = (
@@ -273,6 +421,7 @@ def validate_text(text: str, seeds: int = 100) -> dict:
         and report["n_exec_errors"] == 0
         and report["n_unresolved"] == 0
         and report["n_forbidden"] == 0
+        and report["n_mcq_collisions"] == 0
     )
     return report
 
@@ -289,5 +438,7 @@ def format_report(report: dict) -> str:
         lines.append(f"[INJECTION] {report['n_unresolved']}/{n} graines avec variables non résolues")
     if report["n_forbidden"]:
         lines.append(f"[INTERDITS] {report['n_forbidden']}/{n} graines avec motif interdit")
+    if report.get("n_mcq_collisions"):
+        lines.append(f"[MCQ] {report['n_mcq_collisions']}/{n} graines avec collision d'options")
     lines.extend(f"  • {f}" for f in report["first_failures"])
     return "\n".join(lines) if lines else "VERT"

app/validation/sandbox.py

@@ -78,10 +78,62 @@ class _StubObject:
         return f"_StubObject({self._args!r})"
 
 
+# Liste CANONIQUE des helpers connus (catalogue curé + corpus 222 + 33 exemples
+# déclinaisons). Sert au `__all__` des modules stub : `from X import *` ne
+# passe PAS par __getattr__ (PEP 562), il lit __all__. Partagée avec
+# validation/harness.py — NE PAS dupliquer ailleurs.
+KNOWN_PXS_HELPERS = [
+    "pxs_config", "pxsl_latex", "pxsl_sign", "pxsl_format_number",
+    "pxsl_latex_with_formatting", "pxsl_latex_avec_formatage",
+    "pxsl_latex_coefficient", "pxsl_to_rational_or_symbol",
+    "pxsl_solve_general_inequality", "pxsl_Rational",
+    "pxs_is_reductible_sqrt", "pxs_separate_factors",
+    "pxs_explain_IBP", "pxsl_par", "pxsl_final_sentence",
+    "pxsl_pow", "pxsl_matrix", "pxsl_mat", "pxsl_sum_matrix",
+    "pxsl_prod_scalar_matrix", "pxsl_prod_matrix", "pxsl_ax",
+    "pxsl_system_lin", "pxsl_double_matrix", "pxsl_lines_op",
+    "pxsl_resol_system", "pxs_steps_invert_matrix", "pxs_compute_ech",
+    "pxs_compute_ech_reduite", "pxs_system_simpl", "pxs_commute_matrix",
+    "pxsl_pow_matrix", "pxs_invertible_matrix", "pxs_diag_matrix",
+    "randmatrixrect", "pxs_finiterv", "pxsl_law", "pxsl_moment",
+    "pxsl_scalar_product", "pxs_simul_law", "pxs_fct_finiterv",
+    "pxsl_res_num", "pxsl_sum_vector", "pxs_nvirgzero", "pxsl_num",
+    "pxs_gauss_jordan", "pxs_construct_RREF",
+    "pxs_repeat_generate_sys", "pxs_break_all_colinear_rows",
+    "pxsl_mult", "pxsl_choose_udv", "pxs_lang", "myst",
+    "pxs_variation_number",
+    "pxs_Interval", "pxs_Plotable",
+]
+_STUB_CLASS_NAMES = ("pxs_Interval", "pxs_Plotable")
+
+
+def _make_stub_module(name: str) -> types.ModuleType:
+    """Module stub PEP 562 : tout attribut inconnu est fourni (passthrough /
+    classe universelle), et `__all__` couvre les helpers connus pour que
+    `from X import *` fonctionne."""
+    import re as _re
+    mod = types.ModuleType(name)
+
+    def __getattr__(attr):
+        if attr == "pxs_config":
+            return _config_stub
+        if attr == "pxs_variation_number":
+            return 1                          # règle 13.2 : vaut toujours 1
+        if attr and (attr[0].isupper() or _re.match(r"pxs_[A-Z]", attr)):
+            return _StubObject                # ressemble à une classe
+        return _passthrough
+
+    mod.__getattr__ = __getattr__
+    mod.__all__ = list(KNOWN_PXS_HELPERS)
+    return mod
+
+
 def install_pyxiscience_stubs() -> None:
     """
     Register stub modules for `pyxiscience.*` in sys.modules so that generated
     Python blocks can `import` PyxiScience helpers without crashing. Idempotent.
+    UNIFIÉ avec validation/harness.py (même factory PEP 562 + __all__) : les
+    deux systèmes partagent sys.modules, le premier installé sert aux deux.
     """
     global _STUBS_INSTALLED
     if _STUBS_INSTALLED:
@@ -91,7 +143,7 @@ def install_pyxiscience_stubs() -> None:
         _STUBS_INSTALLED = True
         return
 
-    pyxiscience = types.ModuleType("pyxiscience")
+    pyxiscience = _make_stub_module("pyxiscience")
     sys.modules["pyxiscience"] = pyxiscience
 
     submodules = [
@@ -101,25 +153,12 @@ def install_pyxiscience_stubs() -> None:
         "Mes_fctions_d_analyse",       # alias without _bis (cf. Exo 2 Am. Sud)
         "Mes_fctions_d_alg_lineaire_bis",
         "Mes_fctions_probabilistes_bis",
+        "Mes_fctions_generalistes",    # alias historiques
+        "Mes_fctions_probabilistes",
+        "Mes_fctions_d_alg_lineaire",
     ]
-    helper_names = [
-        "pxs_config", "pxsl_latex_coefficient", "pxsl_format_number",
-        "pxsl_res_num", "pxsl_matrix", "pxsl_pow", "pxsl_par", "pxsl_mult",
-        "pxs_explain_IBP", "pxs_nvirgzero", "_pxsl_choose_udv",
-        "pxs_variation_number", "myst",
-        "pxsl_latex_avec_formatage",  # cf. Exo 2 Am Sud
-        "pxsl_choose_udv",
-    ]
-    class_names = ["pxs_Interval", "pxs_Plotable"]
-
     for sub in submodules:
-        m = types.ModuleType(f"pyxiscience.{sub}")
-        for name in helper_names:
-            setattr(m, name, _passthrough)
-        # Special-case: pxs_config must return a dict (used as **kwargs).
-        setattr(m, "pxs_config", _config_stub)
-        for name in class_names:
-            setattr(m, name, _StubObject)
+        m = _make_stub_module(f"pyxiscience.{sub}")
         sys.modules[f"pyxiscience.{sub}"] = m
         setattr(pyxiscience, sub, m)
 

app/web/templates/index.html

@@ -343,6 +343,24 @@
       <ul class="filelist" id="filelist" hidden></ul>
 
       <div class="meta">
+        <div>
+          <label class="field-label" for="mode-select">Mode</label>
+          <select id="mode-select" onchange="onModeChange()">
+            <option value="pythonise">Pythonisation</option>
+            <option value="declinaisons">Déclinaisons (QCM/QAT)</option>
+          </select>
+        </div>
+        <div id="decl-types" hidden>
+          <label class="field-label">Types de déclinaison</label>
+          <div style="display:flex;gap:14px;padding:9px 2px;font-size:13px;">
+            <label style="display:flex;align-items:center;gap:6px;cursor:pointer;">
+              <input type="checkbox" id="type-qcm" checked> QCM
+            </label>
+            <label style="display:flex;align-items:center;gap:6px;cursor:pointer;">
+              <input type="checkbox" id="type-qat"> QAT
+            </label>
+          </div>
+        </div>
         <div>
           <label class="field-label" for="model-select">Modèle</label>
           <select id="model-select" aria-label="Modèle LLM"></select>
@@ -478,6 +496,12 @@ function prettyModelName(slug) {
     .replace(/\b\w/g, c => c.toUpperCase()).replace(/Gpt/g, "GPT");
 }
 
+/* ─── Mode (pythonisation / déclinaisons) ─── */
+function onModeChange() {
+  const decl = document.getElementById("mode-select").value === "declinaisons";
+  document.getElementById("decl-types").hidden = !decl;
+}
+
 /* ─── Tabs ─── */
 function bindTabs() {
   document.querySelectorAll("#tabs .tab").forEach(btn => {
@@ -678,7 +702,15 @@ function setMetaResult(entry) {
   const cost = r.cost ? `<span class="pill pill--info">${r.cost.usd.toFixed(4)} $ · ${r.cost.requests} appels</span>` : "";
   const lang = r.lang ? `<span class="pill pill--info">langue : ${escapeHtml(r.lang.source)} → ${escapeHtml(r.lang.target)} (${escapeHtml(r.lang.action)})</span>` : "";
   const dur = r.duration_s ? `<span class="pill pill--info">${r.duration_s}s</span>` : "";
-  el.innerHTML = verdict + cost + lang + dur;
+  let decl = "";
+  if (r.decl_type) {
+    const label = r.decl_type === "qcm" ? "QCM" : "QAT";
+    decl = `<span class="pill pill--info">déclinaison : ${label}</span>`;
+    if (r.decl_type === "qat" && (r.exercise || "").includes(":questionType: MCQ")) {
+      decl += `<span class="pill pill--info">repli MCQ partiel</span>`;
+    }
+  }
+  el.innerHTML = verdict + decl + cost + lang + dur;
 }
 
 /* Sélecteur de fichier (batch) */
@@ -721,12 +753,24 @@ async function run() {
   }
   if (!files.length) { setStatus("error", "Saisissez un énoncé ou chargez des fichiers .md."); return; }
 
+  const mode = document.getElementById("mode-select").value;
   const payload = {
     files,
     level: document.getElementById("level").value,
     lang: document.getElementById("lang-select").value,
     model_idx: Number(document.getElementById("model-select").value || 0),
+    mode,
   };
+  if (mode === "declinaisons") {
+    payload.types = {
+      qcm: document.getElementById("type-qcm").checked,
+      qat: document.getElementById("type-qat").checked,
+    };
+    if (!payload.types.qcm && !payload.types.qat) {
+      setStatus("error", "Mode Déclinaisons : coche au moins un type (QCM ou QAT).");
+      return;
+    }
+  }
 
   if (pollTimer) { clearTimeout(pollTimer); pollTimer = null; }
   currentJobId = null;

tests/smoke.py

@@ -0,0 +1,363 @@
+"""
+Smoke tests minimaux — AUCUN appel réseau (LLM mocké), exécution :
+
+    .venv/bin/python tests/smoke.py
+
+Couvre : import/create_app, /health, 1 run de pipeline complet (mock LLM)
+avec porte harnais VERTE, et les filets déterministes clés.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+PASS = []
+
+
+def check(name, cond):
+    PASS.append((name, bool(cond)))
+    print(("✓" if cond else "✗"), name)
+
+
+# ── 1. Import + /health ──────────────────────────────────────────────────────
+from app import create_app  # noqa: E402
+
+flask_app = create_app()
+client = flask_app.test_client()
+health = client.get("/health").get_json()
+check("create_app + /health", health and health["status"] == "ok")
+models = client.get("/api/models").get_json()
+check("/api/models expose le roster", len(models["models"]) >= 5)
+
+# ── 2. Filets déterministes ──────────────────────────────────────────────────
+from app.pipeline import postprocess as pp  # noqa: E402
+
+t, _ = pp.fix_dollar_digit("Prix : $3$ et ${{nAff}}$.")
+check("fix_dollar_digit", "${}3$" in t and "${}{{nAff}}$" in t)
+check("detect_languages both", pp.detect_languages("{fr}`Calculer`{en}`Compute` $x$") == "both")
+check("strip_language fr", pp.strip_language("{fr}`Bonjour `{en}`Hello `", "fr").strip() == "Bonjour")
+
+# ── 3. Pipeline complet avec LLM mocké ───────────────────────────────────────
+SMOKE_SOURCE = """`````{exercise}
+:title: Somme de deux entiers
+:level: Elementary
+
+On additionne deux entiers.
+
+:::::{question}
+:questionType: STQ
+:questionId: 0
+:questionIndex: 0
+
+::::{questionStatement}
+Calculer $3 + 4$.
+::::
+
+::::{questionHint}
+Poser l'addition.
+::::
+
+::::{detailedSolution}
+On trouve $7$.
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 25
+:reasoning: 25
+:calculation: 25
+::::
+:::::
+`````"""
+
+MOCK_ANALYSIS = json.dumps({
+    "exercise_type": "équation linéaire",
+    "exercise_title": "Somme de deux entiers",
+    "nb_questions": 1,
+    "variables": [{"nom": "a", "type_python": "int", "description": "1er terme",
+                   "contraintes": "2..9", "plage_python": "rd.randint(2, 9)",
+                   "location": "énoncé", "valeur_exemple": "3"}],
+    "needs_fraction": False, "needs_sympy": False, "needs_numpy": False,
+    "needs_matplolib": False,   # typo v1 volontaire : doit être normalisée
+    "target_rules": [], "property_constraints": [],
+    "has_validated_solution_in_input": False,
+})
+
+MOCK_PAIR = """````{python}
+import random as rd
+a = rd.randint(2, 9)
+b = rd.randint(2, 9)
+sumAff = str(a + b)
+globals()
+````
+
+On additionne deux entiers.
+
+:::::{question}
+:questionType: STQ
+:questionId: 0
+:questionIndex: 0
+
+::::{questionStatement}
+Calculer ${}{{a}} + {{b}}$.
+::::
+
+::::{questionHint}
+Poser l'addition.
+::::
+
+::::{detailedSolution}
+On trouve ${}{{a}} + {{b}} = {{sumAff}}$.
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 25
+:reasoning: 25
+:calculation: 25
+::::
+:::::"""
+
+
+MOCK_MCQ_PAIR = """````{python}
+import random as rd
+a = rd.randint(2, 9)
+b = rd.randint(2, 9)
+sumAff = str(a + b)
+d1Aff = str(a + b + 1)      # erreur type : +1
+d2Aff = str(a + b - 1)      # erreur type : -1
+d3Aff = str(a * b + 100)    # produit décalé — toujours > somme+1 (distinct)
+globals()
+````
+
+On additionne deux entiers.
+
+:::::{question}
+:questionType: MCQ
+:questionId: 0
+:questionIndex: 0
+
+::::{questionStatement}
+Combien vaut ${}{{a}} + {{b}}$ ?
+::::
+
+::::{questionHint}
+Poser l'addition.
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+${}{{sumAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${}{{d1Aff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${}{{d2Aff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${}{{d3Aff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+On trouve ${}{{a}} + {{b}} = {{sumAff}}$.
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 25
+:reasoning: 25
+:calculation: 25
+::::
+:::::"""
+
+MOCK_FGQ_PAIR = """````{python}
+import random as rd
+a = rd.randint(2, 9)
+b = rd.randint(2, 9)
+sumAff = str(a + b)
+globals()
+````
+
+On additionne deux entiers.
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["ord","${{sumAff}}$"],["0"]]
+
+::::{questionStatement}
+Calculer ${}{{a}} + {{b}}$.
+
+$s =$ {input}`||110`
+::::
+
+::::{questionHint}
+Poser l'addition.
+::::
+
+::::{displayedSolution}
+$s = {{sumAff}}$
+::::
+
+::::{detailedSolution}
+On trouve ${}{{a}} + {{b}} = {{sumAff}}$.
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 20
+:calculation: 45
+::::
+:::::"""
+
+ANALYSIS_CALLS = {"n": 0}
+
+
+def mock_llm(prompt, model_idx=0, temperature=0.0, max_tokens=4096,
+             image_b64=None, system_prompt="", reasoning=False):
+    if "expert en analyse d'exercices" in prompt:
+        ANALYSIS_CALLS["n"] += 1
+        return MOCK_ANALYSIS
+    if "auditeur PyxiScience" in prompt:
+        return json.dumps({"verdict": "OK", "issues": []})
+    if "Tu déclines un exercice" in prompt:
+        return MOCK_MCQ_PAIR if "QCM (MCQ)" in prompt else MOCK_FGQ_PAIR
+    if "RÈGLES D'ASSEMBLAGE PAR PAIRE" in prompt:
+        return MOCK_PAIR
+    return "{}"
+
+
+import app.pipeline.analyze as analyze  # noqa: E402
+import app.pipeline.audit as audit  # noqa: E402
+import app.pipeline.generate as generate  # noqa: E402
+import app.pipeline.orchestrator as orchestrator  # noqa: E402
+
+analyze.process_with_openrouter = mock_llm
+audit.process_with_openrouter = mock_llm
+generate.process_with_openrouter = mock_llm
+orchestrator.process_with_openrouter = mock_llm
+analyze.enrich_exercise_with_notions = lambda *a, **k: ("(notions mockées)", "NOTION_TEST")
+analyze.retrieve_functions_context = lambda **k: {"catalogue": "(catalogue mocké)"}
+
+result = orchestrator.run_exercise(
+    content=SMOKE_SOURCE, filename="smoke.md", level="", model_idx=0, lang="fr")
+
+check("pipeline : exercice produit", bool(result["exercise"].strip()))
+check("pipeline : fence 4 backticks", "````{python}" in result["exercise"])
+check("pipeline : se termine par `````", result["exercise"].rstrip().endswith("`````"))
+check("pipeline : globals() présent", "globals()" in result["exercise"])
+check("pipeline : typo needs_matplolib normalisée",
+      "needs_matplolib" not in result["analysis"] and result["analysis"]["needs_matplotlib"] is False)
+check("pipeline : harnais VERT", result["harness"]["ok"])
+check("pipeline : coût exposé", "usd" in result["cost"])
+check("pipeline : langue exposée", result["lang"]["target"] == "fr")
+
+# En-tête {exercise} complet et bien formé
+ex = result["exercise"]
+check("header : enveloppe `````{exercise} en tête", ex.lstrip().startswith("`````{exercise}"))
+for field in (":id:", ":title:", ":modules:", ":recommendedExecutionTime:",
+              ":level:", ":chap:", ":involvedConcepts:", ":originalSource:", ":visibility:"):
+    check(f"header : champ {field} présent", field in ex.split("````{python}")[0])
+check("header : level mappé (level='' → Elementary)", ":level: Elementary" in ex)
+check("header : visibility All", ":visibility: All" in ex)
+check("header : concepts = notions", "NOTION_TEST" in ex)
+check("header : une seule enveloppe {exercise}", ex.count("`````{exercise}") == 1)
+
+# ── 3bis. Mode déclinaisons (QCM + QAT, LLM mocké, analyse partagée) ─────────
+ANALYSIS_CALLS["n"] = 0
+decl_results = orchestrator.run_declinaisons(
+    content=SMOKE_SOURCE, filename="smoke.md", level="", model_idx=0,
+    lang="fr", types=["qcm", "qat"])
+check("déclinaisons : 2 sorties (QCM + QAT)", len(decl_results) == 2)
+check("déclinaisons : analyse partagée (1 seul appel)", ANALYSIS_CALLS["n"] == 1)
+
+qcm = dict(decl_results)["qcm"]
+qat = dict(decl_results)["qat"]
+check("QCM : harnais VERT", qcm["harness"]["ok"])
+check("QCM : 5 options, 1 seule bonne", qcm["exercise"].count("{mcqAnswer}") == 5
+      and qcm["exercise"].count(":isRightAnswer: true") == 1)
+check("QCM : « None » en dernière option",
+      "Aucune de ces réponses" in qcm["exercise"].split(":isRightAnswer: false")[-1])
+check("QCM : titre suffixé - MCQ", " - MCQ" in qcm["exercise"].split("````{python}")[0])
+check("QAT : harnais VERT", qat["harness"]["ok"])
+check("QAT : :solution: + {input} présents",
+      ':solution: [["ord"' in qat["exercise"] and "{input}`" in qat["exercise"])
+check("QAT : displayedSolution présent", "{displayedSolution}" in qat["exercise"])
+check("déclinaisons : decl_type exposé", qcm["decl_type"] == "qcm" and qat["decl_type"] == "qat")
+
+# Harnais étendu : un MCQ avec collision d'options doit être ROUGE.
+from app.validation import harness as _harness  # noqa: E402
+
+_collision = qcm["exercise"].replace("{{d1Aff}}", "{{sumAff}}")   # distracteur == bonne réponse
+_rep = _harness.validate_text(_collision, seeds=10)
+check("harnais étendu : collision d'options MCQ détectée (ROUGE)",
+      not _rep["ok"] and _rep["n_mcq_collisions"] > 0)
+_two_true = qcm["exercise"].replace(":isRightAnswer: false", ":isRightAnswer: true", 1)
+_rep2 = _harness.validate_text(_two_true, seeds=5)
+check("harnais étendu : 2 bonnes réponses détectées (statique)",
+      not _rep2["ok"] and any("isRightAnswer" in e for e in _rep2["static_errors"]))
+_bad_arity = qat["exercise"].replace('[["ord","${{sumAff}}$"],["0"]]',
+                                     '[["ord","${{sumAff}}$","$2$"],["0","0"]]')
+_rep3 = _harness.validate_text(_bad_arity, seeds=5)
+check("harnais étendu : arité FGQ incohérente détectée",
+      not _rep3["ok"] and any("arité" in e for e in _rep3["static_errors"]))
+
+# Validation API du mode (sans lancer de job).
+r_bad_mode = client.post("/api/jobs", json={"content": "x", "mode": "zzz"})
+check("API : mode invalide → 400", r_bad_mode.status_code == 400)
+r_no_types = client.post("/api/jobs", json={"content": "x", "mode": "declinaisons", "types": {}})
+check("API : declinaisons sans type → 400", r_no_types.status_code == 400)
+
+# ── 4. Téléchargement ZIP (endpoint, sans LLM) ───────────────────────────────
+import io as _io  # noqa: E402
+import zipfile as _zipfile  # noqa: E402
+
+import app.server as _server  # noqa: E402
+
+_fake = {
+    "status": "done", "step_label": "Terminé", "current_file": "b.md",
+    "files_total": 2, "files_done": 2, "error": None, "summary": {},
+    "results": [
+        {"filename": "a.md", "status": "done",
+         "result": {"exercise": result["exercise"], "warnings": [],
+                    "harness": {"ok": True, "seeds": 100}, "cost": {"usd": 0.01}}},
+        {"filename": "a.md", "status": "done",   # collision de nom volontaire
+         "result": {"exercise": "````{python}\nglobals()\n````\n`````", "warnings": [{}],
+                    "harness": {"ok": False, "seeds": 100}, "cost": {"usd": 0.02}}},
+        {"filename": "c.md", "status": "error", "error": "boom"},
+    ],
+}
+with _server._JOBS_LOCK:
+    _server._JOBS["smoketest"] = _fake
+resp = client.get("/api/jobs/smoketest/download")
+check("ZIP : 200 + mimetype zip", resp.status_code == 200 and "zip" in resp.mimetype)
+zf = _zipfile.ZipFile(_io.BytesIO(resp.data))
+names = zf.namelist()
+check("ZIP : 2 .md (collision dédupliquée) + récap",
+      "a_pythonise.md" in names and "a_pythonise_2.md" in names
+      and "_recapitulatif.md" in names)
+check("ZIP : 404 si job inconnu", client.get("/api/jobs/zzz/download").status_code == 404)
+
+# ── Bilan ────────────────────────────────────────────────────────────────────
+failed = [n for n, ok in PASS if not ok]
+print(f"\n{len(PASS) - len(failed)}/{len(PASS)} smoke tests verts")
+if failed:
+    print("ÉCHECS :", failed)
+    sys.exit(1)
+print("✅ SMOKE OK")