Générer un script Python avec des outils d'IA

Le problème 1 est une simple question :

Toutes les IA répondront correctement à cette question.

Le problème 2 est le suivant (copie d’écran de Gemini) :

• En [1], le principe du calcul de l’impôt 2019 sur les revenus 2018 est expliqué dans un PDF. Nous y reviendrons ;
• En [2], on donne des instructions précises à Gemini sur ce qu’on veut, un script Python propre qui résout le problème posé et qui valide la solution proposée avec 11 tests unitaires ;
• En [3], pour lancer Gemini on doit écrire quelque chose ;

On est là exactement dans le même cas que celui d’un TD donné à l’université.

Là encore, toutes les IA testées vont résoudre le problème mais plus ou moins rapidement. Gemini donne un code correct et rapidement.

Toujours avec une copie d’écran de Google Gemini, le problème 3 est le suivant :

• En [1] on donne nos instructions, les mêmes que précédemment. Mais comme on ne donne pas le PDF qui donnait les règles exactes de calcul, l’IA va devoir chercher ces règles sur internet ;
• En [3], on lance l’exécution de l’IA ;

Seules trois IA ont passé ce test, dans l’ordre d’excellence (avis strictement personnel, cela va de soi) :

1. ChatGPT d’OpenAI ;
2. Grok de xAI ;
3. Google Gemini ;

L’IA ClaudeAI a échoué sur le problème 3. L’IA MistralAI a échoué sur les problèmes 2 et 3. L’IA DeepSeek a échoué sur le problème 3.

Les exemples de ce document ont été testés avec l'interpréteur Python 3.13.7 disponible à l'URL |https://www.python.org/downloads/| (août 2025) sur une machine Windows 10 :

En [1-2] téléchargez l’exécutable de l’installateur de Python puis exécutez-le.

L'installation de Python donne naissance à l'arborescence de fichiers [1] suivante :

Pour exécuter Python en mode interactif, double-cliquez sur [2]. Voici un exemple de code Python à exécuter :

Le prompt >>> permet d'émettre une instruction Python qui est immédiatement exécutée. Le code tapé ci-dessus a la signification suivante :

>>> nom="tintin"
>>> print("nom=%s" % nom)
nom=tintin
>>> print("type=%s" % type(nom))
type=<class 'str'>
>>>

Lignes :

• 1 : initialisation d'une variable. En Python, on ne déclare pas le type des variables. Celles-ci ont automatiquement le type de la valeur qu'on leur affecte. Ce type peut changer au cours du temps ;
• 2 : affichage du nom. 'nom=%s' est un format d'affichage où %s est un paramètre formel désignant une chaîne de caractères. nom est le paramètre effectif qui sera affiché à la place de %s ;
• 3 : le résultat de l'affichage ;
• 4 : l'affichage du type de la variable nom ;
• 5 : la variable nom est ici de type class. Avec Python 2.7 elle aurait la valeur <type 'str'> ;

Maintenant, ouvrons une console Windows :

Le fait qu'on ait pu taper [python] en [1] et que l'exécutable [python.exe] ait été trouvé montre que celui-ci est dans le PATH de la machine Windows. C'est important car cela signifie que les outils de développement Python sauront trouver l'interpréteur Python. On peut le vérifier ainsi :

• En [1], on quitte l'interpréteur Python ;
• En [2], la commande qui affiche le PATH des exécutables de la machine Windows ;
• En [3], on voit que le dossier de l'interpréteur Python 3.13 fait partie du PATH ;

Pour construire et exécuter les scripts de ce document, nous avons utilisé l'éditeur [PyCharm] Edition Community disponible (août 2025) à l'URL |https://www.jetbrains.com/fr-fr/pycharm/download/#section=windows| :

Téléchargez l'IDE PyCharm Community (ici pour Windows) [1-4] et installez-le.

Lançons l'IDE PyCharm. Un panneau de configuration apparaît :

• En [1] pour créer l’icône PyCharm sur le bureau ;
• En [2] pour ouvrir n’importe quel dossier du système de fichiers comme un projet Python ;
• En [3], les fichiers Python auront le suffixe .py ;
• En [4], passer à l’étape suivante ;

La fenêtre suivante propose de nouveau de la configuration [1] :

• En [2], on prend le thème [Light]. Le lecteur prendra le thème de son choix ;
• En [3], on laisse l’IDE en anglais ;
• En [4], on garde les raccourcis de Windows ;

Créons un premier projet Python [1-2] :

Cela ouvre la fenêtre suivante :

• En [2], indiquer le nom du dossier à créer pour le projet ;
• En [3], indiquer que les différentes versions du code qui seront sauvegardées seront gérées par le gestionnaire de versions Git. PyCharm permet d’en utiliser d’autres ;
• En [4-6], indiquer que votre projet va utiliser un environnement virtuel. L’environnement virtuel va créer un dossier [.venv] à la racine du projet. Tous les plugins (packages) utilisés par votre projet iront dans ce dossier. Cela assure une étanchéité entre projets lorsqu’il y a recherche de plugins. Le projet ne cherche ses plugins que dans son propre environnement virtuel [.venv] et pas ailleurs où il pourrait trouver des plugins de mêmes noms mais de versions peut-être différentes qui sont parfois partiellement incompatibles entre elles ;

L'IDE PyCharm présente le projet créé sous la forme suivante :

• En [1-2], l’arborescence du projet ;
• En [3], le dossier du projet ;
• En [4], le dossier de l’environnement virtuel du projet. C’est dans ce dossier que s’installeront les plugins que nous utiliserons pour le projet ;

Avant de commencer à coder, allons plus loin dans la configuration de l’IDE :

• Cliquer sur [1] pour faire apparaître le menu principal ;

• En [1-2], configurez l’IDE ;

  

• En [1-4], indiquez que vous voulez voir le menu principal au-dessus de la barre d’outils principale. Rien ne vous y oblige. On le fait ici pour éclairer les copies d’écran qui sont produites dans ce document. Validez votre changement ;

  Désormais, le menu principal est toujours affiché [1] :

  Continuons la configuration de l’IDE :

  

  En haut à droite de la fenêtre de PyCharm, on propose d’essayer la version pro de PyCharm. Selon la façon dont vous avez installé PyCharm, il se peut même que la version pro ait été installée d’office (2025). Cela amène des options de menu supplémentaires.

  

  Si vous avez installé la version pro d’évaluation pour un essai d’un mois, vous avez le message [2] en haut à droite.

  Toujours pour la cohérence des copies d’écran qui vont suivre, je montre comment annuler la version d’essai pro de l’IDE (vous pouvez y revenir quand vous voulez) :

  

• En [1-2], gérez les souscriptions de votre IDE ;

  

• En [1], désactivez la version pro. L’IDE va se relancer ;

  Maintenant configurons l’interpréteur Python qui va exécuter notre projet. Nous nous souvenons d’en avoir téléchargé un lors d’une étape précédente :

  

  

• En [1-3], nous configurons l’interpréteur Python du projet ;

• En [4], le chemin de l’interpréteur ;

• En [5], les packages (plugins) associés à cet interpréteur ;

En [4], découvrons le chemin complet de l’interpréteur utilisé :

• En [3], on découvre que l’interpréteur Python utilisé se trouve dans le dossier de l’environnement virtuel du projet [.venv] ;

  Il est possible de changer d’interpréteur Python, ce qui peut changer les plugins disponibles au projet :

  

• En [4], ajoutez un interpréteur Python ;

  

• En [5], ajoutez un interpréteur local. PyCharm va alors explorer le PATH de la machine à la recherche d’un binaire [python.exe] ;

  

• En [1], indiquez que le nouvel interpréteur doit utiliser l’environnement virtuel [.venv] existant du projet ;

• En [2], l’IDE propose comme interpréteur l’application Python installée dans une étape précédente ;

• Validez ce choix ;

• En [4], le nouvel interpréteur ;
• En [5], les packages auxquels aura accès le projet. C’est la principale différence amenée par le changement d’interpréteur. Si vous gérez plusieurs projets qui utilisent différents packages il est préférable d’utiliser les packages de l’environnement virtuel de chaque projet. Ainsi vous avez le contrôle des versions des plugins que vous utilisez. Pour cette raison, nous garderons l’interpréteur de l’environnement virtuel :

Allons un peu plus loin dans la configuration :

• En [1-2], entrez dans le mode configuration de l’IDE ;
• En [3-4], configurez des options du système ;
• En [5], pas de confirmation avant de quitter l’IDE ;
• En [6], lorsqu’on quitte l’IDE et qu’il y a un processus en cours d’exécution lancé par le code exécuté, on arrête celui-ci ;
• En [7], lorsque l’IDE est lancée, on ne rouvre pas automatiquement le dernier projet utilisé. On laisse l’utilisateur choisir son projet ;
• En [8], lorsque l’utilisateur gère plusieurs projets en même temps, chaque projet a sa fenêtre personnelle ;
• En [9], on a désigné le dossier par défaut de notre projet ;

Maintenant nous pouvons commencer à coder. Commençons par créer un dossier dans lequel nous mettrons notre premier script Python :

• Cliquer droit sur le projet, puis [1-3] pour créer un dossier ;
• En [4], tapez le nom du dossier : il sera créé dans le dossier du projet ;

Puis créons un script Python :

Cliquer droit sur le dossier [bases], puis [1-4] :

• Rappelons-nous ici que nous avons inclus le gestionnaire de versions Git à notre projet. Cela s’est fait lors de la création du projet où nous avons coché l’option Git. Git peut prendre des photos du projet à différentes étapes de celui-ci. Ici en [1-3], l’IDE nous demande si nous voulons inclure le fichier [bases.py] que nous sommes en train de créer dans la photo. Nous répondons oui [3]. Par ailleurs nous cochons [2] pour que cela soit fait systématiquement à la création d’un fichier. Nous reviendrons brièvement sur Git un peu plus loin ;
• En [4-5], le script [bases_01] a été créé et est prêt à être édité ;

Écrivons notre premier script :

• Lignes 1, 3 : les commentaires commencent avec le signe # ;
• Ligne 2 : initialisation d'une variable. Python ne déclare pas le type de ses variables ;

• Ligne 4 : affichage écran. La syntaxe utilisée ici est [format % données] avec :

  • format : nom=%s où %s désigne l'emplacement d'une chaîne de caractères. Celle-ci sera trouvée dans la partie [données] de l'expression ;
  • données : la valeur de la variable [nom] viendra remplacer le format %s dans la chaîne de format ;
• Avec [1-2], on reformate le code selon les recommandations de l'organisme gérant Python. On peut aussi taper au clavier la séquence Ctrl-Alt-L ;

Sur la copie d’écran on voit que certains textes sont soulignés. PyCharm signale des erreurs d’orthographe dans les commentaires et chaînes de caractères. Il les appelle des typos. Il est par défaut configuré pour des textes en anglais. Pour éviter le signalement des typos en français, procédons comme suit :

• En [1-2], configurons l’IDE ;
• En [3-6], désactivons l’option [Proofreading] de l’éditeur ;

En [7], le signalement des typos a disparu. Le script est exécuté avec un clic sur l’icône [8] de la barre d’outils principale. Le résultat est le suivant :

• En [1-2], une fenêtre de résultats s’est ouverte ;
• En [3], on voit que le code de [bases_01.py] a été exécuté par l’interpréteur Python de l’environnement virtuel du projet ;
• En [4], le résultat de l’exécution ;

Pour exécuter les scripts de ce document, téléchargez le code à l'URL |Générer un script Python avec des outils d'IA| (cloud OneDrive) puis dans PyCharm procédez comme suit :

• En [1-2], fermez le projet sur lequel vous êtes en train de travailler ;

  

• En [1], on choisit l’option [Projects] ;

• Dans la fenêtre [2], on a la liste des derniers projets sur lesquels on a travaillé ;

• En [3], on indique qu’on veut ouvrir un projet existant ;

• En [1], on ouvre le dossier qu’on a téléchargé ;

• En [1-2], le projet PyCharm ;

  Configurons ce projet pour qu’il ait un environnement virtuel d’exécution :

• En [1-2], on configure le nouveau projet ;

• En [3-4], on configure un interpréteur pour le projet ;

• En [5-6], on choisit un environnement virtuel d’exécution ;
• En [7], le nouvel interpréteur Python utilisé pour le projet ;

Ceci fait, vous pouvez exécuter les scripts du projet :

Nous rappelons la première copie d’écran de Gemini donnée précédemment :

• En [1], l’URL de Gemini ;
• En [2], la version de Gemini utilisée ;
• En [3-5], les trois problèmes posés à Gemini ;

Gemini est un produit de Google disponible à l’URL [https://gemini.google.com/]. Pour avoir un historique de vos sessions de questions / réponses comme ci-dessus, il vous faut créer un compte. Par ailleurs, comme toutes les autres IA testées, Gemini limite le nombre de vos questions et le nombre de fichiers téléchargés. Quand cette limite est atteinte, la session est terminée et on vous propose de la continuer plus tard dans le temps. Comme il est assez frustrant de s’arrêter en plein milieu d’une session, j’ai pris un abonnement. Le premier mois de l’abonnement Gemini est par chance gratuit. J’ai fait de même avec les autres IA qui avaient ces limites, à savoir ChatGPT, MistralAI, ClaudeAI. J’ai pris un abonnement d’un mois, mais là le premier mois était payant. Je n’ai pas rencontré de limites avec Grok. DeepSeek n’annonce pas de limites mais répond parfois [Server busy] et interrompt la session. Ça revient à mettre des limites sans le dire.

Dans la suite, je parlerai de session de questions / réponses, raccourcie à session simplement. Les IA utilisent le plus souvent le terme anglais chat (discussion) ou conversation.

L’interface de Gemini pour poser une question est la suivante :

• En [1], votre question ;
• En [2], l’icône qui lance l’IA pour le calcul de la réponse ;
• En [3-4], vous pouvez joindre des fichiers ;

La session pour le problème 1 est la suivante :

• En [1], la question ;
• En [2], le début de la réponse de Gemini ;

La suite de la réponse est la suivante :

La réponse est correcte. Les cinq autres IA donneront également la bonne réponse sous une forme analogue.

6-3-1. Introduction▲

27519    0.14    1394.96

0    0.45    20163.45

27519    0.14    1394.96

6-3-2. Configuration de la session Gemini▲

1 - Exprime-toi en français.

2 - Peux-tu générer un script Python permettant de calculer l'impôt payé par les familles en 2019 sur leurs revenus de 2018.

3 - Tu t'aideras du document PDF que j'ai joint et qui explique les calculs à faire.

4 - Tu dois faire attention aux points suivants :

- plafonnement du quotient familial. Il y a des seuils à vérifier.
- calcul de la décote dans certains cas. Il y a des seuils à vérifier.
- calcul de la réduction de 20% dans certains cas. Il y a des seuils à vérifier.
- plafonnement de l'abattement de 10% sur les revenus annuels dans certains cas.
- tu considèreras que tous les revenus sont à déclarer pour le déclarant 1 même si le couple est marié.

5 - Tu ajouteras au script généré des tests unitaires pour les cas suivants.

Dans ces tests on appelle :

adultes :nombre d'adultes du foyer fiscal
enfants : nombre d'enfants du foyer fiscal
revenus : revenus nets annuels avant impôt, ç-à-d avant le 1er calcul de l'abattement.
impot : l'impôt à payer
decote :la décote éventuelle du foyer fiscal
reduction : la réduction de 20% pour les faibles revenus

Voici les 11 tests à vérifier. Ils ont tous été vérifiés manuellement sur le simulateur officiel
du calcul de l'impôt 2019 [https://www3.impots.gouv.fr/simulateur/calcul_impot/2019/simplifie/index.html].
Si tu utilises ce simulateur les revenus doivent être associés au seul déclarant 1 dans le cas d'un couple, le déclarant 2 étant alors ignoré. Lorsqu'on répartit les revenus
sur deux déclarants, on n'obtient pas le même résultat.

On utilise la syntaxe (adultes, enfants, revenus) -> (impot, decote, reduction) pour dire que le script reçoit les entrées
(adultes, enfants, revenus) et produit les résultats (impot, decote, reduction)

test1 : (2,2,55555) -> (2815, 0, 0)
test2 : (2, 2, 50000) -> (1385, 384, 346)
test3 : (2,3,50000) -> (0, 720, 0)
test4: (1,2,100000) -> (19884, 0, 0)
test5: (1,3,100000) -> (16782, 0, 0)
test6 : (2, 3, 100000) -> (9200, 0, 0)
test7 : (2, 5, 100000) -> (4230, 0, 0)
test8 : (1, 0, 100000) -> (22986, 0, 0)
test9 : (2, 2, 30000) -> (0, 0, 0)
test10 : (1,0,200000) -> (64211, 0, 0)
test11  : (2, 3, 200000) -> (42843, 0, 0)

6 - Il peut y avoir des problèmes d'arrondis. Tu procèderas comme suit
- l'impôt à payer sera arrondi à l'euro inférieur,
- la décote sera arrondie à l'euro supérieur,
- la réduction de 20 % sera arrondie à l'euro supérieur.
- l'abattement de 10% sera arrondi à l'euro supérieur

Fais tous les tests unitaires à l'euro près à cause de ces éventuelles erreurs d'arrondi.
Ne cherche pas à avoir les valeurs exactes ci-dessus mais ces valeurs à 1 euro près.

7 - Evite de chercher sur internet. Le PDF que je te donne est correct.
Ne donne ton résultat que lorsque tu as passé les 11 tests unitaires avec succès.

8 - si l'un des tests échoue et que tu es bloqué, affiche ton raisonnement pour ce test
afin que je puisse t'aider.

9- Mets des commentaires détaillés dans le script que tu génères.
Mets le barème progressif dans une liste ou dictionnaire puis utilise cette liste ou dictionnaire
Mets les nombres en dur (nombres magiques) que tu utilises dans des constantes
Utilise des fonctions pour séparer les étapes du calcul.
Ecris le tout en français

9 - n'affiche pas le code généré à l'écran. Donne-moi simplement un lien pour le récupérer.
Si les tests unitaires échouent, je te donnerai les logs de l'exécution du script pour que
tu voies tes erreurs.

10 - si c'est possible, indique le temps en minutes et secondes que tu as mis pour produire
le script demandé.

6-3-3. La réponse de Gemini▲

# -*- coding: utf-8 -*-
"""
Script pour le calcul de l'impôt 2019 sur les revenus de 2018 en France,
basé sur les règles simplifiées fournies dans le document PDF.
"""

import math
import unittest

# --- CONSTANTES DE CALCUL POUR L'IMPÔT 2019 ---
# Toutes les valeurs sont extraites du document PDF fourni.

# Plafonds pour l'abattement de 10% sur les revenus annuels
PLAFOND_ABATTEMENT_10_POURCENT = 12502.0
MINIMUM_ABATTEMENT_10_POURCENT = 437.0

# Barème de l'impôt sur le revenu 2019
# Structure: (Seuil maximum de la tranche, Taux d'imposition, Montant à déduire par part)
BAREME_IMPOT_2019 = [
    {"seuil": 9964, "taux": 0.0, "deduction_par_part": 0},
    {"seuil": 27519, "taux": 0.14, "deduction_par_part": 1394.96},
    {"seuil": 73779, "taux": 0.30, "deduction_par_part": 5798},
    {"seuil": 156244, "taux": 0.41, "deduction_par_part": 13913.69},
    {"seuil": float('inf'), "taux": 0.45, "deduction_par_part": 20163.45}
]

# Plafonnement du quotient familial
GAIN_MAX_DEMI_PART = 1551.0  # Gain maximal par demi-part supplémentaire

# Seuils et montants pour la décote
SEUIL_APPLICATION_DECOTE = {"celibataire": 1595.0, "couple": 2627.0}
SEUIL_CALCUL_DECOTE = {"celibataire": 1196.0, "couple": 1970.0}

# Seuils pour la réduction d'impôt de 20%
SEUIL_BASE_REDUCTION_20 = {"celibataire": 21037.0, "couple": 42074.0}
MAJORATION_SEUIL_REDUCTION_PAR_DEMI_PART = 3797.0


def calculer_nombre_parts(adultes: int, enfants: int) -> float:
    """
    Calcule le nombre de parts fiscales du foyer.
    - Chaque parent amène 1 part.
    - Les deux premiers enfants amènent chacun 1/2 part.
    - Les enfants suivants amènent une part chacun.
    """
    if adultes not in [1, 2]:
        raise ValueError("Le nombre d'adultes doit être 1 ou 2.")

    parts = float(adultes)
    if enfants > 0:
        parts += 0.5 * min(enfants, 2)
    if enfants > 2:
        parts += 1.0 * (enfants - 2)

    return parts


def calculer_revenu_imposable(revenus: float) -> float:
    """
    Calcule le revenu net imposable après l'abattement de 10%.
    Cet abattement est plafonné.
    L'abattement est arrondi à l'euro supérieur.
    """
    abattement_calcule = revenus * 0.1
    # L'abattement est plafonné entre un minimum et un maximum
    abattement = min(PLAFOND_ABATTEMENT_10_POURCENT, max(MINIMUM_ABATTEMENT_10_POURCENT, abattement_calcule))

    # L'énoncé demande d'arrondir l'abattement à l'euro supérieur
    abattement_arrondi = math.ceil(abattement)

    return revenus - abattement_arrondi


def calculer_impot_brut_base(revenu_imposable: float, nombre_parts: float) -> float:
    """
    Calcule l'impôt brut selon le barème progressif.
    """
    if nombre_parts <= 0:
        return 0.0

    quotient_familial = revenu_imposable / nombre_parts

    tranche_applicable = None
    for tranche in BAREME_IMPOT_2019:
        if quotient_familial <= tranche["seuil"]:
            tranche_applicable = tranche
            break

    # Si le QF est supérieur à tous les seuils, on utilise la dernière tranche
    if tranche_applicable is None:
        tranche_applicable = BAREME_IMPOT_2019[-1]

    # Formule de calcul de l'impôt brut
    impot_brut = (revenu_imposable * tranche_applicable["taux"]) - (
            tranche_applicable["deduction_par_part"] * nombre_parts)

    return max(0.0, impot_brut)


def appliquer_plafonnement_qf(impot_brut_avec_enfants: float, revenu_imposable: float, adultes: int,
                              enfants: int) -> float:
    """
    Applique le plafonnement du quotient familial si nécessaire.
    L'impôt final ne peut être inférieur à l'impôt calculé sans les enfants,
    diminué d'un gain maximal par demi-part.
    """
    if enfants == 0:
        return impot_brut_avec_enfants

    # Calcul de l'impôt sans les parts des enfants
    parts_sans_enfants = calculer_nombre_parts(adultes, 0)
    impot_sans_enfants = calculer_impot_brut_base(revenu_imposable, parts_sans_enfants)

    # Calcul du gain maximal lié aux enfants
    parts_avec_enfants = calculer_nombre_parts(adultes, enfants)
    demi_parts_enfants = (parts_avec_enfants - parts_sans_enfants) * 2
    gain_maximal = demi_parts_enfants * GAIN_MAX_DEMI_PART

    impot_minimal_plafone = impot_sans_enfants - gain_maximal

    # L'impôt retenu est le plus élevé des deux calculs
    return max(impot_brut_avec_enfants, impot_minimal_plafone)


def appliquer_decote(impot_avant_decote: float, adultes: int) -> tuple[float, float]:
    """
    Applique la décote si l'impôt est inférieur à certains seuils.
    La décote est arrondie à l'euro supérieur.
    """
    statut = "couple" if adultes == 2 else "celibataire"
    seuil_application = SEUIL_APPLICATION_DECOTE[statut]
    seuil_calcul = SEUIL_CALCUL_DECOTE[statut]

    decote = 0.0
    # La décote s'applique si l'impôt est sous le seuil d'application
    if impot_avant_decote < seuil_application:
        # Formule de la décote : seuil - 0.75 * Impôt brut
        decote_calculee = seuil_calcul - (0.75 * impot_avant_decote)

        # Arrondi à l'euro supérieur
        decote = math.ceil(decote_calculee)

        # La décote ne peut être négative ni supérieure à l'impôt
        decote = max(0.0, min(decote, impot_avant_decote))

    impot_apres_decote = impot_avant_decote - decote
    return impot_apres_decote, decote


def appliquer_reduction_20_pourcent(impot_avant_reduction: float, revenu_imposable: float, adultes: int,
                                    enfants: int) -> tuple[float, float]:
    """
    Applique la réduction de 20% sous condition de revenus.
    La réduction est arrondie à l'euro supérieur.
    """
    statut = "couple" if adultes == 2 else "celibataire"
    seuil_base = SEUIL_BASE_REDUCTION_20[statut]

    # Le seuil est augmenté pour chaque demi-part liée aux enfants
    parts_avec_enfants = calculer_nombre_parts(adultes, enfants)
    parts_adultes = calculer_nombre_parts(adultes, 0)
    demi_parts_enfants = (parts_avec_enfants - parts_adultes) * 2
    seuil_final = seuil_base + (demi_parts_enfants * MAJORATION_SEUIL_REDUCTION_PAR_DEMI_PART)

    reduction = 0.0
    # La réduction s'applique si le revenu imposable est sous le seuil
    if revenu_imposable < seuil_final:
        reduction_calculee = impot_avant_reduction * 0.20

        # Arrondi à l'euro supérieur
        reduction = math.ceil(reduction_calculee)

    impot_apres_reduction = impot_avant_reduction - reduction
    return max(0.0, impot_apres_reduction), reduction


def calculer_impot(adultes: int, revenus: float, enfants: int) -> dict:
    """
    Orchestre le calcul complet de l'impôt net à payer.
    """
    # Étape 1: Calcul du revenu imposable
    revenu_imposable = calculer_revenu_imposable(revenus)

    # Étape 2: Calcul du nombre de parts
    nombre_parts = calculer_nombre_parts(adultes, enfants)

    # Étape 3: Calcul de l'impôt brut
    impot_brut_initial = calculer_impot_brut_base(revenu_imposable, nombre_parts)

    # Étape 4: Application du plafonnement du QF
    impot_apres_plafonnement = appliquer_plafonnement_qf(impot_brut_initial, revenu_imposable, adultes, enfants)

    # Étape 5: Application de la décote
    impot_apres_decote, decote_calculee = appliquer_decote(impot_apres_plafonnement, adultes)

    # Étape 6: Application de la réduction de 20%
    impot_avant_arrondi_final, reduction_calculee = appliquer_reduction_20_pourcent(impot_apres_decote,
                                                                                    revenu_imposable, adultes, enfants)

    # Étape 7: Arrondi final de l'impôt à l'euro inférieur
    impot_final = math.floor(impot_avant_arrondi_final)

    return {
        "impot": impot_final,
        "decote": decote_calculee,
        "reduction": reduction_calculee
    }


# --- TESTS UNITAIRES ---
# Validation du script avec les cas fournis
class TestCalculImpot2019(unittest.TestCase):

    def _verifier_resultat(self, adultes, enfants, revenus, impot_attendu, decote_attendue, reduction_attendue):
        """Fonction utilitaire pour exécuter un test et vérifier les résultats à 1 euro près."""
        resultat = calculer_impot(adultes=adultes, revenus=revenus, enfants=enfants)

        self.assertAlmostEqual(resultat["impot"], impot_attendu, delta=1,
                               msg=f"Test ({adultes}, {enfants}, {revenus}): Impôt attendu {impot_attendu}, obtenu {resultat['impot']}")

        self.assertAlmostEqual(resultat["decote"], decote_attendue, delta=1,
                               msg=f"Test ({adultes}, {enfants}, {revenus}): Décote attendue {decote_attendue}, obtenue {resultat['decote']}")

        self.assertAlmostEqual(resultat["reduction"], reduction_attendue, delta=1,
                               msg=f"Test ({adultes}, {enfants}, {revenus}): Réduction attendue {reduction_attendue}, obtenue {resultat['reduction']}")

    def test_cas_1(self):
        # (2, 2, 55555) -> (2815, 0, 0)
        self._verifier_resultat(2, 2, 55555, 2815, 0, 0)

    def test_cas_2(self):
        # (2, 2, 50000) -> (1385, 384, 346)
        self._verifier_resultat(2, 2, 50000, 1385, 384, 346)

    def test_cas_3(self):
        # (2, 3, 50000) -> (0, 720, 0)
        self._verifier_resultat(2, 3, 50000, 0, 720, 0)

    def test_cas_4(self):
        # (1, 2, 100000) -> (19884, 0, 0)
        self._verifier_resultat(1, 2, 100000, 19884, 0, 0)

    def test_cas_5(self):
        # (1, 3, 100000) -> (16782, 0, 0)
        self._verifier_resultat(1, 3, 100000, 16782, 0, 0)

    def test_cas_6(self):
        # (2, 3, 100000) -> (9200, 0, 0)
        self._verifier_resultat(2, 3, 100000, 9200, 0, 0)

    def test_cas_7(self):
        # (2, 5, 100000) -> (4230, 0, 0)
        self._verifier_resultat(2, 5, 100000, 4230, 0, 0)

    def test_cas_8(self):
        # (1, 0, 100000) -> (22986, 0, 0)
        self._verifier_resultat(1, 0, 100000, 22986, 0, 0)

    def test_cas_9(self):
        # (2, 2, 30000) -> (0, 0, 0)
        self._verifier_resultat(2, 2, 30000, 0, 0, 0)

    def test_cas_10(self):
        # (1, 0, 200000) -> (64211, 0, 0)
        self._verifier_resultat(1, 0, 200000, 64211, 0, 0)

    def test_cas_11(self):
        # (2, 3, 200000) -> (42843, 0, 0)
        self._verifier_resultat(2, 3, 200000, 42843, 0, 0)


if __name__ == '__main__':
    print("Exécution des tests unitaires...")
    unittest.main(argv=['first-arg-is-ignored'], exit=False)

    # Exemple d'utilisation du calculateur pour un cas précis
    print("\n--- Exemple de calcul ---")
    revenus_annuels = 50000
    nombre_adultes = 2
    nombre_enfants = 2

    resultat_calcul = calculer_impot(adultes=nombre_adultes, revenus=revenus_annuels, enfants=nombre_enfants)

    print(f"Pour un couple ({nombre_adultes} adultes) avec {nombre_enfants} enfants et {revenus_annuels}€ de revenus :")
    print(f"  - Impôt à payer : {resultat_calcul['impot']}€")
    print(f"  - Montant de la décote : {resultat_calcul['decote']}€")
    print(f"  - Montant de la réduction : {resultat_calcul['reduction']}€")

Le problème 3 est identique au problème 2, si ce n’est qu’on ne donne plus à l’IA le PDF qui donnait les règles de calcul à observer.

La question initiale à Gemini est la suivante :

Le fichier des instructions en [1] est quasiment le même que pour le problème 2 avec les différences suivantes :

1 - Exprime-toi en français.

2 - Peux-tu générer un script Python permettant de calculer l'impôt payé par les familles en 2019 sur leurs revenus de 2018.

3 - Tu t'aideras des sources que tu trouveras sur internet. Dans ta réponse indique-moi ces sources.

4 - Tu dois faire attention aux points suivants :
…

• En [3], on lui dit de trouver sur internet les règles de calcul de l’impôt 2019 sur les revenus 2018. C’est un exercice plus difficile que le précédent ;

  Je ne donne ci-dessous que des parties de la première réponse de Gemini :

  Le temps estimé est plausible. On attend longtemps la réponse de Gemini.

  Comme précédemment, Gemini a fourni un lien de téléchargement du script généré, lien qui ne marche pas. On le lui dit :

  La réponse de Gemini :

  On charge le script dans PyCharm sous le nom [gemini2]:

  On l’exécute et… ça ne marche pas. Les logs de l’exécution sont les suivants :

   

  Sélectionnez

  1.
  2.
  3.
  4.
  5.
  6.
  7.
  8.
  9.
  10.
  11.
  12.
  13.
  14.
  15.
  16.
  17.
  18.
  19.
  20.
  21.
  22.
  23.
  24.
  25.
  26.
  27.
  28.
  29.
  30.
  31.
  32.
  33.
  34.
  35.
  36.
  37.
  38.
  39.
  40.
  41.
  42.
  43.
  44.
  45.
  46.
  47.
  48.
  49.
  50.
  

  "C:\Program Files\Python313\python.exe" "C:/Program Files/JetBrains/PyCharm 2025.2.0.1/plugins/python-ce/helpers/pycharm/_jb_unittest_runner.py" --path "C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\gemini\gemini2.py" 
  Testing started at 17:23 ...
  Launching unittests with arguments python -m unittest C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\gemini\gemini2.py in C:\Data\st-2025\dev\python\code\python-flask-2025-cours
  
  
  Failure
  Traceback (most recent call last):
    File "C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\gemini\gemini2.py", line 278, in test_cas_2
      self.assertAlmostEqual(impot, 1385, delta=1)
      ~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^
  AssertionError: 1691 != 1385 within 1 delta (306 difference)
  
  
  Error
  Traceback (most recent call last):
    File "C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\gemini\gemini2.py", line 291, in test_cas_3
      impot, _, _ = calculer_impot_final(2, 3, 50000)
                    ~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^
    File "C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\gemini\gemini2.py", line 187, in calculer_impot_final
      decote, impot_apres_decote = calculer_decote(impot_apres_plafonnement, adultes)
                                   ~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    File "C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\gemini\gemini2.py", line 134, in calculer_decote
      decote = seuil_decote - (impot_avant_decote * COFFICIENT_DECOTE)
                                                    ^^^^^^^^^^^^^^^^^
  NameError: name 'COFFICIENT_DECOTE' is not defined. Did you mean: 'COEFFICIENT_DECOTE'?
  
  
  Error
  Traceback (most recent call last):
    File "C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\gemini\gemini2.py", line 316, in test_cas_9
      self._verifier_cas(2, 2, 30000, (0, 0, 0))
      ~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^
    File "C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\gemini\gemini2.py", line 216, in _verifier_cas
      impot_calcule, decote_calculee, reduction_calculee = calculer_impot_final(adultes, enfants, revenus)
                                                           ~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^
    File "C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\gemini\gemini2.py", line 187, in calculer_impot_final
      decote, impot_apres_decote = calculer_decote(impot_apres_plafonnement, adultes)
                                   ~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    File "C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\gemini\gemini2.py", line 134, in calculer_decote
      decote = seuil_decote - (impot_avant_decote * COFFICIENT_DECOTE)
                                                    ^^^^^^^^^^^^^^^^^
  NameError: name 'COFFICIENT_DECOTE' is not defined. Did you mean: 'COEFFICIENT_DECOTE'?
  
  
  
  Ran 11 tests in 0.038s
  
  FAILED (failures=1, errors=2)
  
  Process finished with exit code 1
  

• Ligne 11, un test a échoué ;

• Lignes 25, 42 : une même erreur de compilation ;

On met ces logs dans un fichier texte qu’on donne à Gemini :

La réponse de Gemini :

On charge dans PyCharm le script et on l’exécute. Encore des erreurs. On le dit à Gemini en joignant de nouveau les logs de l’exécution :

La réponse de Gemini :

On charge ce nouveau script dans PyCharm et on l’exécute. Cette fois les 11 tests unitaires passent :

Le code généré par Gemini est le suivant :

# -*- coding: utf-8 -*-
import math
import unittest

# ==============================================================================
# CONSTANTES POUR L'IMPOSITION DES REVENUS 2018 (PAYÉE EN 2019)
# ==============================================================================
BAREME_IMPOT_2019 = [
    {'seuil': 0, 'taux': 0.0},
    {'seuil': 9964, 'taux': 0.14},
    {'seuil': 27519, 'taux': 0.30},
    {'seuil': 73779, 'taux': 0.41},
    {'seuil': 156244, 'taux': 0.45},
]
ABATTEMENT_FORFAITAIRE_TAUX = 0.10
ABATTEMENT_FORFAITAIRE_MINIMUM = 437
ABATTEMENT_FORFAITAIRE_PLAFOND = 12502
PLAFONNEMENT_AVANTAGE_QF_DEMI_PART = 1551
SEUIL_DECOTE_CELIBATAIRE = 1196
SEUIL_DECOTE_COUPLE = 1970
COEFFICIENT_DECOTE = 0.75
TAUX_REDUCTION_20_POURCENT = 0.20
SEUIL_RFR_REDUCTION_CELIBATAIRE = 18985
SEUIL_RFR_REDUCTION_COUPLE = 37970
MAJORATION_RFR_REDUCTION_PAR_DEMI_PART = 3803


# ==============================================================================
# FONCTIONS DE CALCUL
# ==============================================================================

def calculer_nombre_parts(adultes: int, enfants: int) -> float:
    """Calcule le nombre de parts du foyer fiscal."""
    if adultes < 1: return 0
    parts = float(adultes)
    if enfants >= 1: parts += 0.5
    if enfants >= 2: parts += 0.5
    if enfants >= 3: parts += (enfants - 2) * 1.0
    return parts


def calculer_revenu_imposable(revenus_bruts: float) -> float:
    """Calcule le revenu net imposable après abattement de 10%."""
    if revenus_bruts == 0: return 0.0
    abattement = revenus_bruts * ABATTEMENT_FORFAITAIRE_TAUX
    if abattement < ABATTEMENT_FORFAITAIRE_MINIMUM: abattement = ABATTEMENT_FORFAITAIRE_MINIMUM
    if abattement > ABATTEMENT_FORFAITAIRE_PLAFOND: abattement = ABATTEMENT_FORFAITAIRE_PLAFOND
    abattement = math.ceil(abattement)
    revenu_imposable = revenus_bruts - abattement
    return revenu_imposable if revenu_imposable > 0 else 0


def calculer_impot_brut_par_tranche(revenu_imposable: float, nombre_parts: float) -> float:
    """Calcule l'impôt brut en appliquant le barème progressif."""
    if nombre_parts <= 0 or revenu_imposable <= 0: return 0.0
    quotient_familial = revenu_imposable / nombre_parts
    impot_par_part = 0.0
    for i in range(len(BAREME_IMPOT_2019)):
        tranche = BAREME_IMPOT_2019[i]
        seuil_actuel = tranche['seuil']
        taux = tranche['taux']
        if quotient_familial > seuil_actuel:
            base_imposable_tranche = 0
            if i < len(BAREME_IMPOT_2019) - 1:
                seuil_suivant = BAREME_IMPOT_2019[i + 1]['seuil']
                base_imposable_tranche = min(quotient_familial, seuil_suivant) - seuil_actuel
            else:
                base_imposable_tranche = quotient_familial - seuil_actuel
            impot_par_part += base_imposable_tranche * taux
    return impot_par_part * nombre_parts


def appliquer_plafonnement_qf(revenu_imposable: float, nombre_parts: float, adultes: int,
                              impot_brut_famille: float) -> float:
    """Applique le plafonnement des effets du quotient familial."""
    if nombre_parts <= adultes: return impot_brut_famille
    impot_base = calculer_impot_brut_par_tranche(revenu_imposable, float(adultes))
    demi_parts_enfants = (nombre_parts - adultes) * 2
    avantage_qf_max = PLAFONNEMENT_AVANTAGE_QF_DEMI_PART * demi_parts_enfants
    avantage_qf_reel = impot_base - impot_brut_famille
    if avantage_qf_reel > avantage_qf_max:
        return impot_base - avantage_qf_max
    return impot_brut_famille


def calculer_impot_final(adultes: int, enfants: int, revenus: float) -> (int, int, int):
    """Orchestre le calcul complet de l'impôt."""
    revenu_imposable = calculer_revenu_imposable(revenus)
    nombre_parts = calculer_nombre_parts(adultes, enfants)
    impot_brut = calculer_impot_brut_par_tranche(revenu_imposable, nombre_parts)
    impot_apres_plafonnement = appliquer_plafonnement_qf(revenu_imposable, nombre_parts, adultes, impot_brut)

    # CORRECTION : Si l'impôt est déjà 0, pas de décote ni de réduction.
    if impot_apres_plafonnement == 0:
        return 0, 0, 0

    # --- LOGIQUE CORRIGÉE POUR L'INTERACTION DÉCOTE / RÉDUCTION ---
    decote_calculee = 0.0
    reduction_calculee = 0.0
    impot_a_traiter = impot_apres_plafonnement

    # 1. Déterminer l'éligibilité à la réduction de 20%
    est_eligible_reduction = False
    if adultes >= 2:
        seuil_rfr = SEUIL_RFR_REDUCTION_COUPLE + max(0, (nombre_parts - 2) * 2) * MAJORATION_RFR_REDUCTION_PAR_DEMI_PART
    else:
        seuil_rfr = SEUIL_RFR_REDUCTION_CELIBATAIRE + max(0, (
                nombre_parts - 1) * 2) * MAJORATION_RFR_REDUCTION_PAR_DEMI_PART
    if revenu_imposable < seuil_rfr:
        est_eligible_reduction = True

    # 2. Déterminer l'éligibilité à la décote
    seuil_decote_foyer = SEUIL_DECOTE_COUPLE if adultes >= 2 else SEUIL_DECOTE_CELIBATAIRE
    reduction_theorique = math.ceil(impot_a_traiter * TAUX_REDUCTION_20_POURCENT) if est_eligible_reduction else 0

    if (impot_a_traiter - reduction_theorique) < seuil_decote_foyer:
        decote_calculee = seuil_decote_foyer - (impot_a_traiter * COEFFICIENT_DECOTE)
        decote_calculee = math.ceil(decote_calculee)
        # CORRECTION : La décote retournée ne peut excéder l'impôt qu'elle annule
        decote_calculee = min(decote_calculee, math.ceil(impot_a_traiter))
        impot_a_traiter -= decote_calculee
        impot_a_traiter = max(0.0, impot_a_traiter)

    # 3. Appliquer la réduction de 20% si éligible
    if est_eligible_reduction:
        reduction_calculee = math.ceil(impot_a_traiter * TAUX_REDUCTION_20_POURCENT)
        impot_a_traiter -= reduction_calculee
        impot_a_traiter = max(0.0, impot_a_traiter)

    impot_final = math.floor(impot_a_traiter)

    return impot_final, int(decote_calculee), int(reduction_calculee)


# ==============================================================================
# TESTS UNITAIRES
# ==============================================================================

class TestCalculImpot2019(unittest.TestCase):
    def _verifier_cas(self, adultes, enfants, revenus, attendu):
        impot_attendu, decote_attendue, reduction_attendue = attendu
        impot_calcule, decote_calculee, reduction_calculee = calculer_impot_final(adultes, enfants, revenus)
        self.assertAlmostEqual(impot_calcule, impot_attendu, delta=1, msg=f"Impôt ({impot_calcule} vs {impot_attendu})")
        self.assertAlmostEqual(decote_calculee, decote_attendue, delta=1,
                               msg=f"Décote ({decote_calculee} vs {decote_attendue})")
        self.assertAlmostEqual(reduction_calculee, reduction_attendue, delta=1,
                               msg=f"Réduction ({reduction_calculee} vs {reduction_attendue})")

    def test_cas_1(self): self._verifier_cas(2, 2, 55555, (2815, 0, 0))

    def test_cas_2(self): self._verifier_cas(2, 2, 50000, (1385, 384, 346))

    def test_cas_3(self): self._verifier_cas(2, 3, 50000, (0, 720, 0))

    def test_cas_4(self): self._verifier_cas(1, 2, 100000, (19884, 0, 0))

    def test_cas_5(self): self._verifier_cas(1, 3, 100000, (16782, 0, 0))

    def test_cas_6(self): self._verifier_cas(2, 3, 100000, (9200, 0, 0))

    def test_cas_7(self): self._verifier_cas(2, 5, 100000, (4230, 0, 0))

    def test_cas_8(self): self._verifier_cas(1, 0, 100000, (22986, 0, 0))

    def test_cas_9(self): self._verifier_cas(2, 2, 30000, (0, 0, 0))

    def test_cas_10(self): self._verifier_cas(1, 0, 200000, (64211, 0, 0))

    def test_cas_11(self): self._verifier_cas(2, 3, 200000, (42843, 0, 0))


if __name__ == '__main__':
    print("Lancement des tests unitaires pour le calcul de l'impôt 2019...")
    unittest.main(argv=['first-arg-is-ignored'], exit=False)

De nouveau je n’ai pas inspecté ce code. J’ai simplement constaté qu’il passait les 11 tests avec succès.

Mais on peut être curieux de connaître son raisonnement, notamment pour les cas particuliers du calcul de l’impôt. On le lui demande :

C’est un cas de hauts revenus avec à la fois un plafonnement possible de l’abattement de 10% et un plafonnement possible du quotient familial.

La réponse de Gemini est la suivante :

Ces deux dernières copies d’écran sont intéressantes. Gemini utilise une méthode de calcul différente de celle expliquée dans le PDF. On trouve effectivement cette méthode de calcul sur internet. Les deux méthodes sont équivalentes.

L’explication est remarquable par sa clarté. On pourrait la donner telle-quelle à des étudiants pour expliquer la méthode de calcul de l’impôt.

Maintenant prenons un autre exemple cette fois-ci avec des faibles revenus. Dans ce cas, il peut y avoir décote et réduction :

La réponse de Gemini est la suivante :

Ici, on constate que Gemini applique une règle qui n’est pas dans le PDF. Il l’a probablement trouvée sur internet, mais la source est-elle fiable ?

Ici, Gemini continue d’appliquer une règle inconnue (la règle spéciale ci-dessus).

Donc les résultats de Gemini collent avec le résultat du simulateur officiel des impôts. Mais il a utilisé une règle non présente dans le PDF. Où est l’erreur ? On le lui demande en lui joignant le PDF :

La réponse de Gemini :

Je pense que Gemini a raison et que mon PDF est erroné. Pour le vérifier, je lui demande un test :

• Où son raisonnement donnerait les mêmes résultats que le simulateur d’impôt officiel ;
• Où le raisonnement du PDF donnerait lui des résultats différents de ceux du simulateur ;

La réponse de Gemini est la suivante :

Ici Gemini se trompe. J’ai lancé le simulateur sur cet exemple et j’ai trouvé la chose suivante :

Cependant, on va découvrir que le raisonnement de Gemini donne bien les résultats ci-dessus. On continue :

Très bien. C’est noté. On continue :

Donc Gemini a trouvé (impôt, décote, réduction)= (431, 325, 1296) alors que le simulateur utilisé par mes soins donne (431, 324, 1297). Gemini a trouvé les bons résultats à 1 euro près mais il ne le sait pas. On le lui dit :

Gemini répond :

Maintenant, on se demande si Gemini pourrait générer un PDF corrigé :

La réponse de Gemini :

Gemini ne m’a donc pas donné de lien vers un PDF, mais il a généré un texte pour générer moi-même ce PDF. Bien que ce soit encombrant de donner ici, les copies d’écran du PDF, je le fais pour que le lecteur voie le côté génératif de l’IA :

Honnêtement je n’ai pas vérifié si tout ce qui est dit dans ce PDF est vrai. En tout cas, c’est un document parfait pour un TD, généré en quelques secondes.

Néanmoins, on peut faire vérifier par Gemini lui-même que son PDF est bon. On démarre une nouvelle conversation :

• en [1], on a mis le PDF généré par Gemini [Le problème selon Gemini.pdf] ;
• en [2], [instructionsAvecPDF2.txt] est identique aux instructions de [instructionsAvecPDF.txt], si ce n’est qu’on a ajouté un douzième test unitaire, celui-là même qui a montré que le PDF initial était erroné :

test12 : (2, 2, 49500) -> (1297, 431, 324)

Curieusement il a fallu plusieurs allers-retours avant que Gemini génère le bon script :

Question 2

Question 3

Comme il a été fait maintenant plusieurs fois, lorsque le script généré et chargé dans PyCharm échoue, on donne à Gemini le fichier texte des logs de l’exécution. Gemini les comprend très bien.

Question 4

Question 5

Question 6 et fin

Maintenant nous sommes rassurés sur la validité du PDF généré par Gemini. Les règles de calcul qui y sont données sont correctes.

Nous allons maintenant faire la même chose pour les cinq autres IA mais nous serons très brefs dans nos explications, sauf pour ChatGPT l’IA leader du moment. Ce qui nous intéresse c’est de savoir si l’IA résoud ou non les trois problèmes qu’on lui pose. En effet, les interfaces de toutes ces IA sont très analogues et j’ai procédé avec elles comme avec Gemini. Le lecteur est encouragé à rejouer les conversations Gemini avec l’IA de son choix.

Voici une première copie d’écran d’une session ChatGPT :

• En [1-3], les trois problèmes posés à ChatGPT ;
• En [4], l’URL de ChatGPT ;
• En [5], la version de ChatGPT utilisée ;

ChatGPT est un produit de OpenAI disponible à l’URL [https://chatgpt.com/]. Pour avoir un historique de vos sessions de questions / réponses comme ci-dessus, il vous faut créer un compte. Par ailleurs, comme toutes les autres IA testées, ChatGPT limite le nombre de vos questions et le nombre de fichiers téléchargés. Quand cette limite est atteinte, la session est terminée et on vous propose de la continuer plus tard dans le temps. Les limites imposées par ChatGPT sont atteintes très rapidement. Pour faire ce tutoriel, j’ai du prendre un abonnement payant d’un mois.

L’interface de ChatGPT est la suivante :

• En [1], pour joindre des fichiers à la question posée ;
• En [2], la question posée ;
• En [3], pour lancer l’exécution de l’IA ;

La question à ChatGPT :

ChatGPT répond correctement.

C’est le calcul de l’impôt avec le PDF. Pour être honnête, on va utiliser le PDF généré par Gemini qui corrige des erreurs du PDF initial.

• En [1], on a donné le PDF généré par Gemini ;
• En [2], on a ajouté le test unitaire par lequel Gemini a démontré sa supériorité :

test12 : (2, 2, 49500) -> (1297, 431, 324)

On lance ChatGPT. Il met environ 3 minutes pour générer sa réponse. Contrairement à Gemini, il livre bien un lien qui marche pour récupérer le script généré. On charge celui-ci dans PyCharm :

Le script [chatGPT1] fonctionne du premier coup. Là il n’y a pas photo, sur ce problème ChatGPT a été plus performant que Gemini.

Le script [chatGPT1] fourni par ChatGPT est le suivant :

# -*- coding: utf-8 -*-
"""
Calcul de l'impôt 2019 (revenus 2018) en Python.

Hypothèses et règles (d'après le PDF fourni) :
- Tous les revenus sont portés sur le déclarant 1 (même pour un couple).
- Abattement forfaitaire de 10 % encadré par un minimum et un maximum.
- Barème progressif 2018 appliqué au quotient familial (QF).
- Plafonnement du quotient familial : avantage par demi-part enfant limité.
- Décote et réduction de 20 % pour faibles revenus, avec la règle de repêchage.
- Ordre des correctifs : plafonnement QF -> décote -> réduction 20 %.
- Arrondis : abattement (↑), décote (↑), réduction (↑), impôt final (↓).
- On renvoie l'impôt à payer (arrondi à l'euro inf.), la décote et la réduction
  (arrondies à l'euro sup.).

Les nombres “magiques” sont regroupés en constantes, et chaque étape est isolée
dans des fonctions pour la clarté.
"""

from dataclasses import dataclass
from math import ceil, floor

# ---------- Constantes réglementaires ----------

# Abattement frais pro (plancher/plafond) pour revenus 2018
ABATTEMENT_TAUX = 0.10
ABATTEMENT_MIN = 437
ABATTEMENT_MAX = 12502

# Barème 2018 (QF)
# Chaque tranche est (borne_sup, taux). La première tranche 0% se termine à 9 964 €.
BAREME_2018 = [
    (9964, 0.00),
    (27519, 0.14),
    (73779, 0.30),
    (156244, 0.41),
    (float("inf"), 0.45),
]

# Plafonnement du quotient familial
PF_QF_AVANTAGE_PAR_DEMI_PART = 1551  # avantage max par 1/2 part ENFANT

# Décote (seuils selon le nombre d'adultes / statut couple)
DECOTE_SEUIL_CELIB = 1196
DECOTE_SEUIL_COUPLE = 1970

# Réduction de 20 % : seuils en fonction des parts
REDUCTION_BASE_1_PART = 18985
REDUCTION_BASE_2_PARTS = 37970
REDUCTION_PAR_DEMI_PART_SUP = 3803  # ajout par 1/2 part au-delà du socle de 1 ou 2 parts


# ---------- Structures de données ----------

@dataclass
class ResultatImpot:
    impot: int  # impôt final à payer, arrondi à l'euro inférieur
    decote: int  # décote arrondie à l'euro supérieur
    reduction: int  # réduction 20 % arrondie à l'euro supérieur


# ---------- Fonctions utilitaires ----------

def arrondi_sup(euros: float) -> int:
    """Arrondi à l'euro supérieur (ceil)."""
    return int(ceil(euros))


def arrondi_inf(euros: float) -> int:
    """Arrondi à l'euro inférieur (floor)."""
    return int(floor(euros))


# ---------- Étape 1 : Revenu Net Imposable (RNI) ----------

def calcul_abattement(revenus_bruts: float) -> int:
    """
    Calcule l'abattement de 10 %, plafonné/planche, ARRONDI À L'EURO SUPÉRIEUR.
    """
    abattement_calcule = revenus_bruts * ABATTEMENT_TAUX
    abattement_calcule = max(ABATTEMENT_MIN, min(ABATTEMENT_MAX, abattement_calcule))
    return arrondi_sup(abattement_calcule)


def revenu_net_imposable(revenus_bruts: float) -> int:
    """RNI = revenus bruts - abattement (abattement arrondi ↑)."""
    return int(round(revenus_bruts - calcul_abattement(revenus_bruts)))


# ---------- Étape 2 : Nombre de parts ----------

def nombre_parts(adultes: int, enfants: int) -> float:
    """
    Règles : 1 part si 1 adulte, 2 parts si 2 adultes.
    Enfants : +0,5 pour les 2 premiers, +1 par enfant à partir du 3e.
    (On ignore ici tout cas particulier type parent isolé, conformément au PDF.)
    """
    parts = 1.0 if adultes == 1 else 2.0
    if enfants <= 0:
        return parts
    if enfants == 1:
        return parts + 0.5
    # enfants >= 2
    parts += 1.0  # +0,5 +0,5 pour les deux premiers
    if enfants > 2:
        parts += (enfants - 2) * 1.0  # +1 par enfant à partir du 3e
    return parts


def demi_parts_enfants(enfants: int) -> int:
    """Nombre de DEMI-parts dû aux enfants (utile pour le plafonnement QF)."""
    if enfants <= 0:
        return 0
    if enfants == 1:
        return 1  # 0,5 part
    # Deux premiers enfants = 2 * demi-part, puis +2 demi-parts par enfant à partir du 3e
    return 2 + (enfants - 2) * 2


# ---------- Étape 3 : Impôt brut via QF ----------

def impot_brut_par_parts(qf: float) -> float:
    """Impôt par part via barème progressif 2018 (sans arrondi)."""
    imp = 0.0
    previous = 0.0
    for borne_sup, taux in BAREME_2018:
        montant_tranche = max(0.0, min(qf, borne_sup) - previous)
        imp += montant_tranche * taux
        if qf <= borne_sup:
            break
        previous = borne_sup
    return imp


def impot_brut_total(rni: float, parts: float) -> float:
    """Impôt brut total = impôt par part * nombre de parts (sans arrondi)."""
    if parts <= 0:
        return 0.0
    qf = rni / parts
    return impot_brut_par_parts(qf) * parts


# ---------- Étape 4.1 : Plafonnement du quotient familial ----------

def apply_plafonnement_qf(impot_avec_enfants: float, rni: float, adultes: int, enfants: int) -> float:
    """
    Calcule l'impôt après plafonnement QF si l'avantage des enfants dépasse le plafond.
    - Impôt A : avec parts incluant enfants
    - Impôt B : avec seulement parts des adultes (1 ou 2)
    - Avantage réel = B - A
    - Avantage maximal = 1551 € par 1/2 part ENFANT
    Si avantage réel > avantage max, impôt = B - avantage max, sinon impôt = A.
    """
    parts_adultes = 1.0 if adultes == 1 else 2.0
    imp_b = impot_brut_total(rni, parts_adultes)
    imp_a = impot_avec_enfants
    avantage_reel = max(0.0, imp_b - imp_a)
    avantage_max = PF_QF_AVANTAGE_PAR_DEMI_PART * demi_parts_enfants(enfants)
    if avantage_reel > avantage_max:
        return imp_b - avantage_max
    return imp_a


# ---------- Étape 4.2 : Décote et Réduction 20 % ----------

def seuil_decote(adultes: int) -> int:
    return DECOTE_SEUIL_COUPLE if adultes >= 2 else DECOTE_SEUIL_CELIB


def seuil_reduction_20(rni: int, adultes: int, parts: float) -> int:
    """
    Seuil d'éligibilité à la réduction de 20 % :
    - Base : 18 985 € pour 1 part, 37 970 € pour 2 parts
    - + 3 803 € par 1/2 part supplémentaire au-delà de la base correspondante.
    """
    base = REDUCTION_BASE_2_PARTS if adultes >= 2 else REDUCTION_BASE_1_PART
    base_parts = 2.0 if adultes >= 2 else 1.0
    demi_sup = max(0, int(round((parts - base_parts) * 2)))
    return base + demi_sup * REDUCTION_PAR_DEMI_PART_SUP


def calc_decote_reduction(impot_apres_plaf: float, rni: int, adultes: int, parts: float):
    """
    Calcule (decote_arrondie, reduction_arrondie, impot_apres_correctifs).
    Règle d'interaction : la décote peut s'appliquer via repêchage si, après
    application THÉORIQUE de la réduction de 20 %, l'impôt passerait sous le seuil.
    Ordre : décote -> réduction.
    """
    imp = max(0.0, impot_apres_plaf)
    decote = 0
    reduction = 0

    # Éligibilité réduction 20 % basée sur RNI
    seuil_red = seuil_reduction_20(rni, adultes, parts)
    eligible_reduction = rni < seuil_red  # "inférieur à un seuil" dans le PDF

    # Éligibilité décote : sous le seuil directement, ou repêchage si réduction ferait passer sous le seuil
    s_dec = seuil_decote(adultes)
    direct_decote = imp <= s_dec
    repechage = False
    if not direct_decote and eligible_reduction:
        imp_theorique_apres_red = imp * 0.80  # réduction théorique 20%
        if imp_theorique_apres_red <= s_dec:
            repechage = True

    elig_decote = (direct_decote or repechage) and (imp > 0)

    # Appliquer la décote en premier (si éligible)
    if elig_decote:
        montant_decote = s_dec - (imp * 0.75)
        decote_calc = max(0, arrondi_sup(montant_decote))
        # La décote ne peut pas excéder l'impôt restant : on la borne
        decote = min(decote_calc, arrondi_sup(imp))
        imp = max(0.0, imp - decote)

    # Puis appliquer la réduction si éligible
    if eligible_reduction and imp > 0:
        montant_reduction = imp * 0.20
        reduction = max(0, arrondi_sup(montant_reduction))
        imp = max(0.0, imp - reduction)

    return decote, reduction, imp


# ---------- API principale ----------

def calcule_impot(adultes: int, enfants: int, revenus_bruts: float) -> ResultatImpot:
    """
    Calcule l'impôt 2019 (revenus 2018) pour un foyer.
    Retourne ResultatImpot(impot, decote, reduction).
    """
    # 1) RNI
    rni = revenu_net_imposable(revenus_bruts)

    # 2) Parts
    parts = nombre_parts(adultes, enfants)

    # 3) Impôt brut via barème (avec toutes parts)
    imp_brut_A = impot_brut_total(rni, parts)

    # 4.1) Plafonnement du quotient familial
    imp_apres_plaf = apply_plafonnement_qf(imp_brut_A, rni, adultes, enfants)

    # 4.2) Décote puis réduction 20 % (avec repêchage)
    decote, reduction, imp_corrige = calc_decote_reduction(imp_apres_plaf, rni, adultes, parts)

    # 5) Arrondi final impôt (↓) et bornage à 0
    imp_final = max(0, arrondi_inf(imp_corrige))

    return ResultatImpot(impot=imp_final, decote=decote, reduction=reduction)


# ---------- Petit exécutable de test ----------

def _nearly_equal(a: int, b: int, tol: int = 1) -> bool:
    return abs(a - b) <= tol


def tests_unitaires():
    """
    Renvoie une liste de tuples (inputs, attendu, obtenu, ok) pour chaque test.
    Tolérance : ±1 € sur chaque valeur (impôt, décote, réduction).
    """
    cas = [
        # (adultes, enfants, revenus) -> (impot, decote, reduction)
        ((2, 2, 55555), (2815, 0, 0)),
        ((2, 2, 50000), (1385, 384, 346)),
        ((2, 3, 50000), (0, 720, 0)),
        ((1, 2, 100000), (19884, 0, 0)),
        ((1, 3, 100000), (16782, 0, 0)),
        ((2, 3, 100000), (9200, 0, 0)),
        ((2, 5, 100000), (4230, 0, 0)),
        ((1, 0, 100000), (22986, 0, 0)),
        ((2, 2, 30000), (0, 0, 0)),
        ((1, 0, 200000), (64211, 0, 0)),
        ((2, 3, 200000), (42843, 0, 0)),
        ((2, 2, 49500), (1297, 431, 324)),
    ]

    resultats = []
    for (adultes, enfants, revenus), attendu in cas:
        res = calcule_impot(adultes, enfants, revenus)
        obtenu = (res.impot, res.decote, res.reduction)
        ok = _nearly_equal(obtenu[0], attendu[0]) and _nearly_equal(obtenu[1], attendu[1]) and _nearly_equal(obtenu[2],
                                                                                                             attendu[2])
        resultats.append(((adultes, enfants, revenus), attendu, obtenu, ok))
    return resultats


if __name__ == "__main__":
    for inputs, attendu, obtenu, ok in tests_unitaires():
        print(f"{inputs} -> attendu={attendu}, obtenu={obtenu} : {'OK' if ok else 'ECHEC'}")

Maintenant on demande à ChatGPT de chercher les règles de calcul de l’impôt sur internet :

Cette fois-ci on ne fournit pas le PDF qui donnait les règles de calcul à observer. On donne seulement nos instructions dans le fichier texte. On rappelle que ce fichier texte contient maintenant 12 tests unitaires après avoir ajouté aux 11 tests initiaux, celui utilisé par Gemini pour démontrer que mon PDF initial était erroné.

ChatGPT répond en 8 minutes, donne un lien pour télécharger le script généré. Une fois chargé dans PyCharm, ce script passe les 12 tests. Donc aux deux problèmes posés, ChatGPT a répondu juste du premier coup, surpassant ainsi Gemini.

ChatGPT donne ses sources dans sa réponse :

Il n’y a rien à dire, c’est du beau travail.

Maintenant, on peut lui demander, comme on l’a fait avec Gemini de générer un PDF pour des étudiants.

La réponse de ChatGPT a été obtenue après plusieurs allers-retours car le PDF généré utilisait une police qui remplaçait des caractères par un carré. Mais finalement, il a généré le PDF. Je le donne car il donne des règles différentes du PDF de Gemini et je me suis demandé alors qui avait raison. On va enquêter.

La différence avec le PDF de Gemini est dans le calcul de la décote. Les deux IA n’ont pas la même approche. Gemini avait écrit :

Les deux IA ont deux approches différentes. Qui a raison ?

On va demander à ChatGPT de s’appuyer sur son PDF pour faire le calcul de l’impôt :

Comme les fois précédentes, il génère un script Python qui marche du premier coup. On avait ajouté dans les instructions un test supplémentaire :

test13 : (1, 0, 18535) -> (359, 491, 90)

Les 13 tests ont été passés avec succès.

Maintenant, on revient dans Gemini à qui on va présenter le PDF de ChatGPT. Vu que les règles implémentées dans ce PDF sont différentes de celles implémentées dans le PDF de Gemini, on peut se demander ce qui va se passer :

Gemini a tout d’abord généré un script Python qui ratait des tests. On lui a présenté les logs :

Question 2

Question 3

Il y a encore des erreurs. On continue.

Question 4

Toujours des erreurs à l’exécution :

Cette fois-ci c’est bon.

On est quand même intrigués qu’avec des PDF ayant des règles de calcul assez différentes les IA génèrent toutes deux des résultats corrects.

On pose la question suivante à Gemini :

La question complète est la suivante :

Après tout ce qu'on a fait, compare les deux approches, la tienne et celle de ChatGPT dans les pDF que je te joins [.. selon Gemini] pour toi, [.. selon ChatGPT] pour ChatGPT. Dis-moi laquelle on doit préférer vu que sur les 13 tests générés tu les réussis tous avec l'un ou avec l'autre PDF.

La réponse de Gemini est catégorique :

Les résultats obtenus avec Gemini et ChatGPT laissent un doute. Les IA ont-elles trouvé une solution générale qui valide tous les tests imaginables ou ont-elles trouvé une solution qui valide les seuls tests imposés. On va repartir sur une solution sans PDF pour obliger les IA à aller sur internet rechercher les informations dont elles ont besoin. Et on modifie nos instructions de la façon suivante :

Le fichier texte [instructionsSansPDF4.txt] contient déjà 14 tests imposés. A ces tests, on rajoute les instructions suivantes :

7 - tu ajouteras autant de tests unitaires que nécessaires pour vérifier les cas limites du calcul de l'impôt.

Pour le code tu complèteras le script suivant auquel tu auras rajouté tes propres tests.

# =========================
# Tests unitaires (tolérance de ±1 €)
# =========================

TESTS = [
    # (adultes, enfants, revenus) -> (impot, decote, reduction)
    ((2, 2, 55555), (2815, 0, 0)),
    ((2, 2, 50000), (1385, 384, 346)),
    ((2, 3, 50000), (0, 720, 0)),
    ((1, 2, 100000), (19884, 0, 0)),
    ((1, 3, 100000), (16782, 0, 0)),
    ((2, 3, 100000), (9200, 0, 0)),
    ((2, 5, 100000), (4230, 0, 0)),
    ((1, 0, 100000), (22986, 0, 0)),
    ((2, 2, 30000), (0, 0, 0)),
    ((1, 0, 200000), (64211, 0, 0)),
    ((2, 3, 200000), (42843, 0, 0)),
    ((2, 2, 49500), (1297, 431, 324)),
    ((1, 0, 18535), (359, 491, 90)),
    ((2, 0, 43333), (2270, 0, 400)),
]


def _ok(a, b, tol=1):
    return abs(a - b) <= tol


def run_tests(verbose: bool = True) -> bool:
    all_ok = True
    for (params, expected) in TESTS:
        a, e, r = params
        exp_impot, exp_decote, exp_reduc = expected
        res = calcul_impot_2019(a, e, r)
        ok_impot = _ok(res.impot, exp_impot)
        ok_decote = _ok(res.decote, exp_decote)
        ok_reduc = _ok(res.reduction, exp_reduc)
        test_ok = ok_impot and ok_decote and ok_reduc
        if verbose:
            print(
                f"Test {params} -> obtenu (impôt={res.impot}, décote={res.decote}, réduction={res.reduction}) | attendu {expected} | {'OK' if test_ok else 'ECHEC'}")
            if not test_ok:
                print(
                    f" Détails tolérance ±1€ : impôt ok? {ok_impot}, décote ok? {ok_decote}, réduction ok? {ok_reduc}")
        all_ok &= test_ok
    if verbose:
        print("\nRésultat global :", "TOUS LES TESTS PASSENT ✅" if all_ok else "AU MOINS UN TEST ÉCHOUE ❌")
    return all_ok


if __name__ == "__main__":
    run_tests()

• Lignes 11-24, les 14 tests imposés ;
• Lignes 5-55 : ce code vient du script généré par ChatGPT. On va imposer à Gemini d’utiliser ce code pour faciliter les comparaisons entre les deux scripts générés.

On commence par ChatGPT :

Sa première réponse est incorrecte. Je le lui dis en lui donnant les logs de l’exécution :

Sa deuxième réponse est la bonne. ChatGPT a rajouté les 11 tests suivants aux 14 tests imposés :

# Cas limites supplémentaires (bords de paliers/arrondis)
TESTS += [
    # Abattement 10 % : plancher et plafond
    ((1, 0, 3000), (0, 0, 0)),  # 10 % = 300 < plancher 437 => RNI faible -> impôt nul
    ((1, 0, 200000), (64211, 0, 0)),  # plafond abattement déjà couvert dans tests initiaux

    # Décote : juste en dessous / au-dessus des seuils
    ((1, 0, 25000), None),  # diagnostique
    ((2, 0, 35000), None),  # diagnostique

    # Réduction 20 % : plein droit vs écrêtement
    ((1, 0, 17000), None),  # diagnostique
    ((2, 0, 34000), None),  # diagnostique
    ((1, 0, 20000), None),  # diagnostique
    ((2, 0, 40000), None),  # diagnostique

    # Changement de parts (plafonnement QF)
    ((2, 1, 80000), None),
    ((2, 2, 80000), None),
    ((2, 3, 80000), None),
]

Il y a maintenant 25 tests unitaires. J’ai vérifié manuellement les 11 nouveaux tests avec le simulateur officiel de la DGIP et c’est bon.

Maintenant, on passe à Gemini. Cela va être beaucoup plus compliqué. Il va réussir à générer un script qui passe les 25 tests de ChatGPT mais après un long débogage.

Ci-dessous, la liste du débogage :

Bizarrement, une majorité de tests a échoué même parmi les 14 imposés alors que par le passé Gemini avait généré du code qui les passait tous.

La réponse suivante de Gemini n’est toujours pas correcte :

La réponse suivante non plus :

La réponse suivante non plus. Du coup je change mon fusil d’épaule. Je lui demande de réussir les 25 tests qu’a réussis ChatGPT en lui joignant les logs de ChatGPT :

Gemini échoue. Il a bien ajouté les tests de ChatGPT. Je lui joins les logs de son exécution :

Toujours pas :

Toujours pas :

Toujours pas :

Toujours pas mais c’est mieux :

Gemini fait de nouvelles erreurs :

Il s’améliore de nouveau :

Cette fois, c’est bon :

Indiscutablement, sur cet exemple précis du calcul de l’impôt 2019 avec les contraintes placées dans le fichier des instructions, ChatGPT a été plus pertinent que Gemini. Mais ce n’est qu’un exemple.

On peut aller plus loin. On peut demander à Gemini de régénérer un PDF selon les règles de calcul qu’il a utilisées pour réussir les 25 tests. On veut voir s’il a changé son raisonnement premier sur les calculs de la décote et de la réduction de 20% :

Cette fois-ci, Gemini a généré un fichier MarkDown que j’ai ensuite transformé en PDF [Le problème selon Gemini version 2]. Et Gemini a effectivement changé son raisonnement :

On constate qu’il n’y a plus le calcul particulier de la décote ni la règle de repêchage. Gemini a désormais adopté le raisonnement de ChatGPT.

• En [1], l’URL de l’IA Grok propriété de l’entreprise xAI [https://x.ai/company] ;
• En [2], l’historique de vos conversations. Pour l’avoir, il faut vous créer un compte ;
• En [3], posez votre question ;
• En [4], vous pouvez joindre des fichiers ;
• En [5], vous lancez l’exécution de l’IA ;

Contrairement à Gemini et ChatGPT, je n’ai pas rencontré de limites de questions, de temps ou de nombre de fichiers joints. Cela ne veut pas dire que ces limites n’existent pas.

Grok répond correctement à cette question.

On propose à Grok de résoudre le calcul de l’impôt à l’aide du PDF généré par ChatGPT et on lui donne nos instructions dans un fichier texte.

Le fichier texte est celui déjà utilisé avec les deux IA testées, mais on y a mis les 25 tests validés par ChatGPT et Gemini. Le PDF utilisé est celui généré par ChatGPT :

Grok fournit alors un script très propre mais porté dans PyCharm, pratiquement aucun test ne passe. Je lui fournis alors les logs de ses erreurs :

Cette fois-ci, Grok réussit les 25 tests. En [1-3], on montre le script [grok1] généré ainsi que les deux fichiers joints à la question.

Cette fois-ci, on ne donne pas de PDF pour les règles de calcul. Grok devra les trouver sur internet. Les instructions texte [instructionsSansPDF5.txt] lui donnent les mêmes 25 tests que précédemment à vérifier.

Grok réussit presque du premier coup. Il génère un script qui réussit 24 tests sur 25. On lui donne ses logs.

Au deuxième coup ça marche. En [1], le script généré par Grok, en [2] les instructions à suivre.

On lui demande maintenant de générer un PDF qui explique les règles de calcul qu’il a utilisées pour réussir les 25 tests :

Grok ne génère alors pas un PDF mais un fichier [MarkDown]. J’ai utilisé un outil gratuit pour le transformer en PDF. Par ailleurs, PyCharm sait lire les fichiers [MarkDown] :

Pour valider le PDF généré précédemment, on le donne à Grok.

Sa première mouture est correcte. Le script passe les 25 tests. En fait les IA ne semblent pas déterministes. On peut leur poser deux fois la même question et voir leurs réponses diverger. Cela a été le cas ici avec Grok. La première fois, j’avais omis qu’il ne devait pas aller sur internet et utiliser uniquement son PDF. Il a alors produit un script erroné. Je lui ai donné ses logs et là j’ai vu qu’il allait sur internet vérifier des choses. Dans la question ci-dessus, j’ai demandé à ce qu’il ne le fasse pas. Du coup, globalement Grok a été performant.

Résolution des trois problèmes avec ClaudeAI

• En [1], l’URL de l’IA ClaudeAI [https://claude.ai/chat] produit de l’entreprise Anthropic [https://www.anthropic.com/] ;
• En [2], l’historique de vos chats. Les sessions gratuites de ClaudeAI sont très limitées. J’ai pris un abonnement payant d’un mois pour faire les tests qui suivent ;
• En [3], votre question ;
• En [4], pour joindre des fichiers à votre question ;
• En [5], pour exécuter votre question ;

La question :

ClaudeAI répond correctement.

La question :

En [2], on a joint un fichier texte déjà utilisé avec les IA précédentes. Il oblige l’IA à chercher ses informations sur internet et impose là encore les 25 tests unitaires.

La première réponse a beaucoup d’erreurs. On transmet les logs à l’IA :

Encore des erreurs :

Toujours pas. On l’encourage :

Toujours pas :

Toujours pas :

Rien à faire :

Encore beaucoup d’échecs. On va considérer que ClaudeAI n’a pas su résoudre le problème 3 dans un délai raisonnable.

• En [1], l’URL de l’IA MistralAI [https://chat.mistral.ai/chat] produit de l’entreprise Mistral AI [https://mistral.ai/] ;
• En [2], l’historique de vos questions. Les sessions gratuites de MistralAI sont très limitées en nombre de questions, nombre de fichiers joints, temps passé. J’ai dû prendre un abonnement payant d’un mois pour faire les tests sui suivent ;
• En [3], votre question ;
• En [4], pour joindre des fichiers à votre question ;
• En [5], pour exécuter votre question ;

La question :

MistralAI répond correctement à la question.

La question :

On propose à MistralAI de résoudre le problème de calcul de l’impôt 2019 avec les règles de calcul générées par ChatGPT dans le PDF. Le fichier texte donne mes instructions avec les 25 tests à réaliser.

En fait, je n’arriverai à rien avec MistralAI. Le problème principal est qu’il ne lit pas (ou ne veut pas lire) les instructions du fichier texte [instructionsAvecPDF4.txt]. Il génère un code qui ne respecte pas mes exigences et ne génère pas non plus les 25 tests unitaires demandés.

• En [1], l’URL de DeepSeek [https://chat.deepseek.com/] ;
• En [2], votre historique. Pour l’avoir il faut vous créer un compte (gratuit en sept. 2025) ;
• En [3], votre question ;
• En [4], pour joindre des fichiers à votre question ;
• En [5], pour exécuter votre question ;

La question :

La réponse de DeepSeek laisse à désirer. Elle est moins précise que celles générées par les autres IA.

La question :

La première réponse est incorrecte. On relance :

La réponse suivante est un peu meilleure :

La réponse suivante est très décevante. Quasiment tous les tests échouent. Dans les réponses de DeepSeek, on ne sent pas la certitude des premières IA testées. On dirait que l’IA doute elle-même de l’exactitude de ses réponses. Par ailleurs, on a l’impression que DeepSeek ne réfléchit pas. Elle donne une réponse très rapidement alors que ChatGPT mettait des minutes à réfléchir. Peut-être un problème de configuration.

Cette fois-ci c’est mieux. Il ne reste plus qu’un échec à 2 euros près. D’autres IA ont chuté sur ce même test avec ces mêmes deux euros d’écart. On va considérer que le script de DeepSeek est correct.

La question

Cette fois, plus de PDF. DeepSeek va devoir chercher les règles de calcul sur internet.

Première réponse : les 25 tests échouent. On recommence.

Les 25 tests échouent de nouveau.

De nouveau, 25 tests échoués. On abandonne et on considère que DeepSeek n’a pas su résoudre le problème 3 dans un temps raisonnable.