Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Résolution de problèmes mathématiques

Nodarbība 9 no 12 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Les mathématiques : le terrain idéal pour le raisonnement
  2. Problèmes arithmétiques en plusieurs étapes
  3. Équations et systèmes d’équations
  4. Preuves et démonstrations
  5. Énigmes logiques
  6. Optimisation et probabilités
  7. Motif : Validation automatique
  8. Comparaison : Avec et sans raisonnement
  9. Galvenās atziņas

Leçon mise à jour le 2 novembre 2026. Les exemples originaux utilisaient Magistral, retiré le 31 juillet 2026. Ils font désormais appel à Mistral Small 4 (mistral-small-2603) ou Mistral Large 4 (mistral-large-4-0) avec reasoning_effort="high", et analysent la réponse grâce à la fonction separer de la leçon 3. Source : Reasoning (Documentation Mistral).

Les mathématiques : le terrain idéal pour le raisonnement

Les problèmes mathématiques constituent le cas d’usage où le raisonnement apporte le plus de valeur. Un modèle sans capacité de raisonnement répond correctement à « 2 + 2 », mais échoue souvent sur les problèmes en plusieurs étapes, les démonstrations et les énigmes logiques. Avec le raisonnement activé, le modèle décompose le problème, vérifie chaque étape et valide le résultat, comblant ainsi les lacunes inhérentes à la génération token par token.

Problèmes arithmétiques en plusieurs étapes

Commençons par un cas où l’ordre des opérations détermine le résultat. Une remise de 20 % suivie d’un bon d’achat de 15 € ne donne pas le même total qu’un bon appliqué avant la remise ; un modèle trop pressé les confond souvent.

from mistralai.client import Mistral

client = Mistral(api_key="YOUR_API_KEY")

probleme = """A store offers a 20% discount on all items.
A customer buys 3 items at 45 euros, 2 items at 30 euros, and 1 item at 75 euros.
They also have an additional 15-euro voucher applicable after the discount.
What is the final amount to pay? Detail each step."""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[{"role": "user", "content": probleme}]
)

# Le modèle raisonne étape par étape :
# 1. Calculer le prix total avant remise
# 2. Appliquer la remise de 20 %
# 3. Soustraire le bon d'achat de 15 €
# 4. Vérifier le résultat

Le raisonnement empêche le modèle de sauter des étapes et garantit qu’il vérifie la cohérence de ses calculs intermédiaires avant de fournir un montant final.

Équations et systèmes d’équations

Les systèmes d’équations mettent à l’épreuve cette même rigueur dans un cadre plus formel. Ici, l’instruction système impose une exigence stricte de détail :

systeme = """Solve the following system of equations:
3x + 2y - z = 7
x - y + 2z = 3
2x + 3y + z = 12

Show every step of the solution."""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "system", "content": "You are a mathematics teacher. Detail every operation."},
        {"role": "user", "content": systeme}
    ],
)

Le modèle commence par choisir une méthode — substitution, élimination ou matrices — applique les opérations une par une, puis réinjecte ses valeurs dans les équations originales pour vérifier qu’elles sont satisfaites. Cette dernière étape, souvent négligée par les modèles sans raisonnement, permet de détecter les erreurs de signe.

Preuves et démonstrations

Les démonstrations mathématiques révèlent toute la puissance du raisonnement, à condition de définir le cadre attendu. Pour les preuves longues, il vaut la peine de tester Mistral Large 4 en mode high si Small 4 s’avère insuffisant. Imposer les quatre étapes du raisonnement par récurrence dans l’instruction système empêche le modèle de « conclure » sur la base de seulement deux cas particuliers :

demonstration = """Prove by induction that for any integer n >= 1:
1^2 + 2^2 + 3^2 + ... + n^2 = n(n+1)(2n+1) / 6"""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "system", "content": """You are a rigorous mathematician.
Expected proof structure:
1. Base case (Initialization)
2. Inductive hypothesis
3. Inductive step (from n to n+1)
4. Conclusion"""},
        {"role": "user", "content": demonstration}
    ],
)

Énigmes logiques

Les puzzles basés sur des contraintes sont particulièrement révélateurs, car aucune formule unique ne mène à la solution ; le modèle doit explorer des possibilités puis les éliminer. L’énigme classique impliquant trois amis, trois professions et trois couleurs de voitures en est l’exemple le plus pur.

enigme = """Three friends (Alice, Bob, Charlie) each have a different profession
(doctor, lawyer, engineer) and a car of a different color (red, blue, green).

Clues:
1. Alice is not the doctor
2. The owner of the red car is the lawyer
3. Bob does not have the green car
4. Charlie is not the lawyer
5. The engineer has the blue car
6. Alice does not have the red car

Find the profession and car color for each person."""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[{"role": "user", "content": enigme}]
)

Dans ses traces de raisonnement, le modèle liste les possibilités pour chaque personne, applique les contraintes une par une, élimine les combinaisons impossibles, puis valide la solution retenue face aux six indices : Alice est ingénieure avec la voiture bleue, Bob est avocat avec la voiture rouge, et Charlie est médecin avec la voiture verte. Le sixième indice n’est pas décoratif ; sans lui, Alice et Bob pourraient échanger leurs rôles d’avocat et d’ingénieur, laissant l’énigme avec deux solutions. Un bon modèle de raisonnement le signale ; c’est un excellent moyen de tester tes propres énoncés. Cette passe de validation finale distingue la déduction d’une simple devinette heureuse.

Optimisation et probabilités

Les problèmes de dénombrement posent un défi similaire : la réponse dépend d’un choix de modèle probabiliste que l’IA doit expliciter avant de calculer.

proba = """An urn contains 5 red balls, 3 blue balls, and 2 green balls.
We draw 3 balls without replacement.
What is the probability of getting exactly 2 red balls and 1 blue ball?
Express the result as an irreducible fraction."""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[{"role": "user", "content": proba}]
)

Motif : Validation automatique

Pour des résultats critiques, un seul appel ne suffit pas. Tu peux exploiter le raisonnement une seconde fois en soumettant la solution générée à une vérification indépendante : le modèle aborde alors le problème avec la réponse déjà en vue, ce qui le force à vérifier plutôt qu’à générer.

def solve_and_verify(client, problem):
    """Solves a problem and requests verification."""

    # Étape 1 : Résolution
    solve_response = client.chat.complete(
        model="mistral-small-2603",
        reasoning_effort="high",
        messages=[{"role": "user", "content": problem}]
    )

    _, answer = separer(solve_response.choices[0].message.content)

    # Étape 2 : Vérification via un second appel
    verify_response = client.chat.complete(
        model="mistral-small-2603",
        reasoning_effort="high",
        messages=[
            {"role": "user", "content": f"""Verify this solution to the following problem:

PROBLEM: {problem}

PROPOSED SOLUTION: {answer}

Is the solution correct? If not, correct it."""}
        ]
    )

    return {
        "solution": answer,
        "verification": separer(verify_response.choices[0].message.content)[1],
    }

Comparaison : Avec et sans raisonnement

Pour mesurer l’impact sur un exemple concret, reprenons l’énigme des poules. La proportionnalité est trompeuse et pousse un modèle sans raisonnement vers la réponse « 12 » par simple analogie avec l’énoncé.

probleme_test = "If 3 chickens lay 3 eggs in 3 days, how many eggs do 12 chickens lay in 12 days?"

# Sans raisonnement — risque d'erreur par analogie naïve (réponse "12")
response_none = client.chat.complete(
    model="mistral-small-2603",
    messages=[{"role": "user", "content": probleme_test}],
    reasoning_effort="none"
)

# Avec raisonnement — décomposition correcte
response_high = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[{"role": "user", "content": probleme_test}]
)
# Raisonnement attendu : 1 poule = 1 œuf / 3 jours
# 12 poules en 12 jours = 12 * (12/3) = 48 œufs

Exécute les deux appels sur tes propres problèmes avant de décider ; c’est le seul moyen fiable de savoir si le coût supplémentaire du raisonnement est justifié dans ton domaine.

Galvenās atziņas

  • Le raisonnement excelle dans les problèmes mathématiques en plusieurs étapes
  • Utilise une instruction système qui impose une structure de solution (étapes, vérification)
  • Les preuves par récurrence bénéficient énormément d’un raisonnement structuré
  • Les énigmes logiques mettent en lumière l’exploration et l’élimination des possibilités
  • Mets en œuvre une double vérification pour les résultats critiques
  • Compare toujours les résultats avec et sans raisonnement pour valider la valeur ajoutée