Przejdź do głównej treści
Polski— Wybierz język
Menu

Rozwiązywanie problemów matematycznych

Lekcja 9 z 12 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Matematyka: idealne pole do rozumowania
  2. Wieloetapowe problemy arytmetyczne
  3. Równania i układy równań
  4. Dowody i demonstracje
  5. Łamigłówki logiczne
  6. Optymalizacja i prawdopodobieństwo
  7. Wzorzec: automatyczna walidacja
  8. Porównanie: z rozumowaniem i bez niego
  9. Kluczowe wnioski

Lekcja zaktualizowana 2 listopada 2026 r. Oryginalne przykłady wykorzystywały model Magistral, który został wycofany 31 lipca 2026 r. Obecnie używamy Mistral Small 4 (mistral-small-2603) lub Mistral Large 4 (mistral-large-4-0) z parametrem reasoning_effort="high", a odpowiedź parsujemy za pomocą funkcji separer z Lekcji 3. Źródło: Reasoning (Dokumentacja Mistral).

Matematyka: idealne pole do rozumowania

Problemy matematyczne to przypadek użycia, w którym mechanizm rozumowania przynosi największą wartość. Model niewyposażony w tę funkcję poprawnie odpowie na pytanie „2 + 2“, ale często zawiedzie przy zadaniach wieloetapowych, dowodach i łamigłówkach logicznych. Dzięki włączonemu rozumowaniu model dekomponuje problem, weryfikuje każdy krok i potwierdza wynik – dokładnie to, czego brakuje przy generowaniu token po tokenie.

Wieloetapowe problemy arytmetyczne

Zacznijmy od przypadku, w którym kolejność działań decyduje o wyniku. Rabat 20% zastosowany przed bonem o wartości 15 € daje inny rezultat niż bon użyty przed obniżką ceny; pospieszny model często myli te kolejności.

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}]
)

# The model reasons step by step:
# 1. Calculate total price before discount
# 2. Apply 20% discount
# 3. Subtract 15-euro voucher
# 4. Verify the result

Rozumowanie zapobiega pomijaniu kroków przez model i zapewnia sprawdzenie spójności obliczeń pośrednich przed podaniem końcowej kwoty.

Równania i układy równań

Układy równań testują tę samą dyscyplinę w bardziej formalnym ustawieniu. Tutaj monit systemowy wymusza ścisły wymóg szczegółowości:

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}
    ],
)

Model zaczyna od wyboru metody – podstawiania, przeciwnych współczynników lub macierzy – stosuje działania krok po kroku, a następnie podstawia uzyskane wartości z powrotem do oryginalnych równań, aby zweryfikować, czy są spełnione. Ten ostatni krok, często pomijany przez modele bez rozumowania, pozwala wychwycić błędy w znakach.

Dowody i demonstracje

Dowody matematyczne ujawniają pełną moc rozumowania, pod warunkiem że zdefiniujesz oczekiwane ramy. Przy dłuższych dowodach warto przetestować Mistral Large 4 w trybie high, jeśli Small 4 okaże się niewystarczający. Wymuszenie czterech etapów indukcji w monocie systemowym zapobiega sytuacji, w której model „wyciąga wnioski“ na podstawie zaledwie dwóch konkretnych przypadków:

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}
    ],
)

Łamigłówki logiczne

Łamigłówki oparte na ograniczeniach są szczególnie pouczające, ponieważ nie prowadzi do nich żaden pojedynczy wzór; model musi zbadać możliwości, a następnie je wyeliminować. Klasyczna zagadka dotycząca trzech przyjaciół, trzech zawodów i trzech kolorów samochodów jest tego najlepszym przykładem.

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}]
)

W śladach rozumowania model wymienia możliwości dla każdej osoby, stosuje ograniczenia jedno po drugim, eliminuje niemożliwe kombinacje, a następnie waliduje wybrane rozwiązanie wobec wszystkich sześciu wskazówek: Alice jest inżynierem z niebieskim samochodem, Bob jest prawnikiem z czerwonym samochodem, a Charlie lekarzem z zielonym samochodem. Szósta wskazówka nie jest ozdobnikiem; bez niej Alice i Bob mogliby zamienić się rolami prawnika i inżyniera, co pozostawiłoby zagadkę z dwoma rozwiązaniami. Dobry model rozumujący to wychwytuje; to doskonały sposób na przetestowanie własnych treści zadań. To końcowe przejście weryfikacyjne odróżnia dedukcję od szczęśliwego trafu.

Optymalizacja i prawdopodobieństwo

Zadania kombinatoryczne stanowią podobne wyzwanie: odpowiedź zależy od wyboru modelu probabilistycznego, który AI musi jawnie określić przed wykonaniem obliczeń.

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}]
)

Wzorzec: automatyczna walidacja

W przypadku wyników krytycznych pojedyncze wywołanie nie wystarczy. Możesz wykorzystać rozumowanie po raz drugi, przesyłając wygenerowane rozwiązanie do niezależnej проверки: model podchodzi wtedy do problemu, mając już przed oczami odpowiedź, co zmusza go do weryfikacji, a nie generowania.

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

    # Step 1: Resolution
    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)

    # Step 2: Verification via a second call
    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],
    }

Porównanie: z rozumowaniem i bez niego

Aby zmierzyć wpływ na konkretnym przykładzie, wróćmy do zagadki z kurami. Proporcjonalność jest tu myląca i popycha model bez rozumowania ku odpowiedzi „12“ poprzez prostą analogię z treścią polecenia.

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

# Without reasoning — risk of error via naive analogy (answer "12")
response_none = client.chat.complete(
    model="mistral-small-2603",
    messages=[{"role": "user", "content": probleme_test}],
    reasoning_effort="none"
)

# With reasoning — correct decomposition
response_high = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[{"role": "user", "content": probleme_test}]
)
# Expected reasoning: 1 chicken = 1 egg / 3 days
# 12 chickens in 12 days = 12 * (12/3) = 48 eggs

Uruchom oba wywołania na własnych problemach przed podjęciem decyzji; to jedyny niezawodny sposób, by stwierdzić, czy dodatkowy koszt rozumowania jest uzasadniony w Twojej dziedzinie.

Kluczowe wnioski

  • Rozumowanie exceluje w wieloetapowych problemach matematycznych
  • Używaj monitu systemowego, który wymusza strukturę rozwiązania (kroki, weryfikacja)
  • Dowody indukcyjne korzystają ogromnie ze strukturalnego rozumowania
  • Łamigłówki logiczne uwypuklają badanie i eliminację możliwości
  • Wdróż podwójną weryfikację dla wyników krytycznych
  • Zawsze porównuj wyniki z rozumowaniem i bez niego, aby zwalidować dodaną wartość