4. Resolución de los tres problemas con Google Gemini

Vamos a mostrar las capturas de pantalla de las tres sesiones de Gemini que permitieron resolver los tres problemas planteados. Entraremos bastante en detalle. Una vez hecho esto, no repetiremos el proceso para las demás IA probadas. Funcionan de manera análoga. Solo daremos los detalles más destacados.

4.1. Introducción

Recordamos la primera captura de pantalla de Gemini mostrada anteriormente:

En [1], el URL de Gemini;
En [2], el version de Gemini utilizado;
En [3-5], las tres preguntas planteadas a Gemini;

Gemini es un producto de Google disponible en URL [https://gemini.google.com/]. Para disponer de un historial de tus sesiones de preguntas y respuestas como el anterior, debes crear una cuenta. Por otra parte, al igual que todas las demás IA probadas, Gemini limita el número de preguntas y el número de archivos descargados. Cuando se alcanza este límite, la sesión finaliza y se te propone continuarla más tarde. Como resulta bastante frustrante tener que parar en medio de una sesión, me he suscrito. Por suerte, el primer mes de la suscripción a Gemini es gratuito. Hice lo mismo con los demás IA que tenían estas limitaciones, a saber, ChatGPT, MistralAI y ClaudeAI. Contraté una suscripción de un mes, pero en este caso el primer mes era de pago. No he encontrado límites con Grok. DeepSeek no anuncia límites, pero a veces responde [Server busy] e interrumpe la sesión. Es como poner límites sin decirlo.

En lo que sigue, hablaré de sesiones de preguntas y respuestas, abreviadas simplemente como «sesiones». Los IA suelen utilizar el término inglés «chat» (charla) o «conversación».

La interfaz de Gemini para hacer una pregunta es la siguiente:

En [1], tu pregunta;
En [2], el icono que inicia IA para el cálculo de la respuesta;
En [3-4], puede adjuntar archivos;

4.2. El problema 1

La sesión para el problema 1 es la siguiente:

En [1], la pregunta;
En [2], el inicio de la respuesta de Gemini;

El resto de la respuesta es el siguiente:

La respuesta es correcta. Los otros cinco IA también darán la respuesta correcta de forma similar.

4.3. El problema 2

4.3.1. Introducción

Recordemos aquí el problema inicial del curso [python3-flask-2020]. Se trata de un texto que se ha dado a los estudiantes en TD.

La tabla anterior permite calcular el impuesto en el caso simplificado de un contribuyente que solo tiene que declarar su salario. Como indica la nota (1), el impuesto así calculado es el impuesto antes de aplicar tres mecanismos:

El límite máximo del coeficiente familiar que se aplica a las rentas elevadas;
La bonificación y la reducción de impuestos que se aplican a las rentas bajas;

Así, el cálculo del impuesto comprende los siguientes pasos [http://impotsurlerevenu.org/comprendre-le-calcul-de-l-impot/1217-calcul-de-l-impot-2019.php]:

Nos proponemos escribir un programa que permita calcular el impuesto de un contribuyente en 2019 en el caso simplificado de un contribuyente que solo tenga que declarar su salario.

4.3.1.1. Cálculo del impuesto bruto

El impuesto bruto se puede calcular de la siguiente manera:

En primer lugar, se calcula el número de participaciones del contribuyente:

Cada progenitor aporta 1 parte;
Los dos primeros hijos aportan cada uno 1/2 parte;
Los hijos siguientes aportan una parte cada uno:

Por lo tanto, el número de participaciones es:

nbParts=1+nbEnfants*0,5+(n.º de hijos-2)*0,5 si el empleado no está casado;
nbParts = 2 + nbEnfants * 0,5 + (nbEnfants - 2) * 0,5 si está casado;
donde nbEnfants es su número de hijos;
Se calcula la renta imponible R = 0,9 * S, donde S es el salario anual;
Se calcula el coeficiente familiar QF = R / nbParts;
Se calcula el impuesto bruto I a partir de los siguientes datos (2019):

9964	0	0
27519	0,14	1394,96
73779	0,3	5798
156 244	0,4	13913,69
0	0,45	20163,45

Cada línea tiene 3 campos: champ1, champ2, champ3. Para calcular el impuesto I, se busca la primera línea en la que QF <= campo1 y se toman los valores de esa línea. Por ejemplo, para un empleado casado con dos hijos y un salario anual S de 50 000 euros:

Renta imponible: R=0,9*S=45 000

Número de cuotas: nbParts=2+2*0,5=3

Cotización familiar: QF=45 000/3=15 000

La primera línea en la que QF <= campo1 es la siguiente:

1	`27519 0.14 1394.96`

El impuesto I es entonces igual a 0,14*R – 1394,96*nbParts=[0,14*45000-1394,96*3]=2115. El impuesto se redondea al euro inferior.

Si la relación QF <= campo1 se cumple desde la primera línea, entonces el impuesto es nulo.

Si QF es tal que la relación QF<=campo1 nunca se cumple, entonces se utilizan los coeficientes de la última línea. En este caso:

1	`0 0.45 20163.45`

lo que da el impuesto bruto I = 0,45*R – 20 163,45*nbParts.

4.3.1.2. Límite máximo del coeficiente familiar

Para saber si se aplica el límite máximo del coeficiente familiar QF, se vuelve a calcular el impuesto bruto sin tener en cuenta a los hijos. Siguiendo con el ejemplo del asalariado casado con dos hijos y un salario anual S de 50 000 euros:

Renta imponible: R = 0,9 * S = 45 000

Número de partes: nbParts=2 (ya no se cuentan los hijos)

Cotización familiar: QF = 45 000 / 2 = 22 500

La primera línea en la que QF <= campo1 es la siguiente:

1	`27519 0.14 1394.96`

El impuesto I es entonces igual a 0,14*R – 1394,96*nbParts=[0,14*45000-1394,96*2]=3510.

Ganancia máxima por hijos: 1551 * 2 = 3102 euros

Impuesto mínimo: 3510-3102 = 408 euros

El impuesto bruto con 2 partes, ya calculado en el párrafo anterior (2115 euros), es superior al impuesto mínimo (408 euros), por lo que el límite máximo familiar no se aplica en este caso.

En general, el impuesto bruto es sup(impuesto1, impuesto2), donde:

[impôt1]: es el impuesto bruto calculado con los hijos;
[impôt2]: es el impuesto bruto calculado sin los hijos y reducido en la ganancia máxima (en este caso, 1551 euros por media parte) relacionada con los hijos;

4.3.1.3. Cálculo de la reducción

Siguiendo con el ejemplo del asalariado casado con dos hijos y un salario anual S de 50 000 euros:

El impuesto bruto (2115 euros) resultante del paso anterior es inferior a 2627 euros para una pareja (1595 euros para una persona soltera): por lo tanto, se aplica la reducción. Se obtiene mediante el siguiente cálculo:

descuento = umbral (pareja = 1970 / soltero = 1196) - 0,75 * Impuesto bruto

descuento = 1970 - 0,75 * 2115 = 383,75, redondeado a 384 euros.

Nuevo impuesto bruto = 2115 - 384 = 1731 euros

Hay que tener en cuenta dos reglas en el cálculo de la reducción (algunas herramientas de IA han tropezado con esta cuestión):

El descuento no puede ser negativo;
La deducción no puede ser superior al impuesto ya calculado;

4.3.1.4. Cálculo de la reducción de impuestos

Por debajo de un determinado umbral, se aplica una reducción del 20 % sobre el impuesto bruto resultante de los cálculos anteriores. En 2019, los umbrales son los siguientes:

soltero: 21 037 euros;
pareja: 42 074 euros; (la cifra de 37 968 utilizada en el ejemplo anterior parece errónea);

Este umbral se incrementa en el valor: 3797 * (número de medias partes aportadas por los hijos).

Siguiendo con el ejemplo del asalariado casado con dos hijos y un salario anual S de 50 000 euros:

Su renta imponible (45 000 euros) es inferior al umbral (42 074 + 2 × 3797) = 49 668 euros;
Por lo tanto, tiene derecho a una reducción del 20 % de su impuesto: 1731 * 0,2 = 346,2 euros, redondeado a 347 euros;
El impuesto bruto del contribuyente pasa a ser: 1731 - 347 = 1384 euros;

4.3.1.5. Cálculo del impuesto net

Nuestro cálculo se detendrá aquí: el impuesto net a pagar será de 1384 euros. En la realidad, el contribuyente puede beneficiarse de otras reducciones, en particular por donaciones a organismos de interés público o general.

4.3.1.6. El caso de las rentas elevadas

Nuestro ejemplo anterior corresponde a la mayoría de los casos de asalariados. Sin embargo, el cálculo del impuesto es diferente en el caso de las rentas altas.

4.3.1.6.1. Límite máximo de la reducción del 10 % sobre los ingresos anuales

En la mayoría de los casos, la renta imponible se obtiene mediante la fórmula: R = 0,9 * S, donde S es el salario anual. A esto se le denomina la reducción del 10 %. Esta reducción tiene un límite máximo. En 2019:

No puede ser superior a 12 502 euros;
No puede ser inferior a 437 euros;

Tomemos el caso de un asalariado soltero sin hijos y con un salario anual de 200 000 euros:

La reducción del 10 % es de 20 000 euros > 12 502 euros. Por lo tanto, se reduce a 12 502 euros;

4.3.1.6.2. Límite máximo del coeficiente familiar

Tomemos un caso en el que se aplica el límite máximo familiar presentado en el apartado |Límite máximo del coeficiente familiar|. Tomemos el caso de una pareja con tres hijos y unos ingresos anuales de 100 000 euros. Repasemos los pasos del cálculo:

La deducción del 10 % es de 100 000 euros < 12 502 euros. Por lo tanto, la renta imponible R es de 100 000 - 10 000 = 90 000 euros;
La pareja tiene nbParts = 2 + 0,5 × 2 + 1 = 4 partes;
Por lo tanto, su coeficiente familiar es QF = R/nbParts = 90 000/4 = 22 500 euros;
Su impuesto bruto I1 con hijos es I1 = 0,14 × 90 000 – 1 394,96 × 4 = 7 020 euros;
Su impuesto bruto I2 sin hijos:
- QF = 90 000 / 2 = 45 000 euros;
- I2 = 0,3 × 90 000 − 5798 × 2 = 15 404 euros;
La regla del límite máximo del coeficiente familiar establece que la ganancia aportada por los hijos no puede superar (1551*4 medias partes)=6204 euros. Sin embargo, en este caso es I2-I1=15404-7020= 8384 euros, por lo que es superior a 6204 euros;
Por lo tanto, el impuesto bruto se recalcula como I3 = I2-6204 = 15 404 - 6 204 = 9 200 euros;
Como I3 > I1, se mantendrá el impuesto I3;

Esta pareja no tendrá ni bonificación ni reducción y su impuesto final será de 9200 euros.

4.3.1.7. Cifras oficiales

El cálculo del impuesto es complejo. A lo largo de todo el documento, las pruebas se realizarán con los siguientes ejemplos. Los resultados son los del simulador de la administración tributaria |https://www3.impots.gouv.fr/simulateur/calcul_impot/2019/simplifie/index.htm|:

Contribuyente	Resultados oficiales	Resultados del algoritmo del documento
Pareja con 2 hijos y unos ingresos anuales de 55 555 euros	Impuesto = 2815 euros Tipo impositivo = 14 %	Impuesto = 2814 euros Tipo impositivo = 14 %
Pareja con dos hijos y unos ingresos anuales de 50 000 euros	Impuesto = 1385 euros Descuento = 384 euros Reducción = 346 euros Tipo impositivo = 14 %	Impuesto = 1384 euros Descuento = 384 euros Descuento = 347 euros Tipo impositivo = 14 %
Pareja con 3 hijos y unos ingresos anuales de 50 000 euros	Impuesto = 0 euros Descuento = 720 euros Descuento = 0 euros Tipo impositivo = 14 %	Impuesto = 0 euros Descuento = 720 euros Descuento = 0 euros Tipo impositivo = 14 %
Soltero con 2 hijos y unos ingresos anuales de 100 000 euros	Impuesto = 19 884 euros Descuento = 0 euros Reducción = 0 euros Tipo impositivo = 41 %	Impuesto = 19 884 euros Recargo = 4480 euros Descuento = 0 euros Reducción = 0 euros Tipo impositivo = 41 %
Soltero con 3 hijos y unos ingresos anuales de 100 000 euros	Impuesto = 16 782 euros Descuento = 0 euros Descuento = 0 euros Tipo impositivo = 41 %	Impuesto = 16 782 euros Recargo = 7176 euros Descuento = 0 euros Reducción = 0 euros Tipo impositivo = 41 %
Pareja con 3 hijos y unos ingresos anuales de 100 000 euros	Impuesto = 9200 euros Descuento = 0 euros Descuento = 0 euros Tipo impositivo = 30 %	Impuesto = 9200 euros Recargo = 2180 euros Descuento = 0 euros Reducción = 0 euros Tipo impositivo = 30 %
Pareja con 5 hijos y unos ingresos anuales de 100 000 euros	Impuesto = 4230 euros Descuento = 0 euros Descuento = 0 euros Tipo impositivo = 14 %	Impuesto = 4230 euros Descuento = 0 euros Descuento = 0 euros Tipo impositivo = 14 %
Soltero sin hijos y con unos ingresos anuales de 100 000 euros	Impuesto = 22 986 euros Descuento = 0 euros Descuento = 0 euros Tipo impositivo = 41 %	Impuesto = 22 986 euros Recargo = 0 euros Descuento = 0 euros Reducción = 0 euros Tipo impositivo = 41 %
Pareja con 2 hijos y unos ingresos anuales de 30 000 euros	Impuesto = 0 euros Descuento = 0 euros Descuento = 0 euros Tipo impositivo = 0 %	Impuesto = 0 euros Descuento = 0 euros Reducción = 0 euros Tipo impositivo = 0 %
Soltero sin hijos y con unos ingresos anuales de 200 000 euros	Impuesto = 64 211 euros Descuento = 0 euros Descuento = 0 euros Tipo impositivo = 45 %	Impuesto = 64 210 euros Recargo = 7498 euros Descuento = 0 euros Reducción = 0 euros Tipo impositivo = 45 %
Pareja con 3 hijos y unos ingresos anuales de 200 000 euros	Impuesto = 42 843 euros Descuento = 0 euros Descuento = 0 euros Tipo impositivo = 41 %	Impuesto = 42 842 euros Recargo = 17 283 euros descuento = 0 euros Reducción = 0 euros Tipo impositivo = 41 %

En el ejemplo anterior, se denomina recargo a lo que pagan de más las rentas altas debido a dos fenómenos:

El límite máximo de la deducción del 10 % sobre los ingresos anuales;
El límite máximo del coeficiente familiar;

Este indicador no se ha podido verificar, ya que el simulador de la administración tributaria no lo proporciona.

Se observa que el algoritmo del documento da un impuesto correcto en todos los casos, aunque con un margen de error de 1 euro. Este margen de error se debe a los redondeos. Todas las cantidades monetarias se redondean a veces al euro superior y a veces al euro inferior. Como no conocía las normas oficiales, las cantidades del algoritmo del documento se han redondeado:

Al euro superior para los descuentos y reducciones;
Al euro inferior para los recargos y el impuesto final;

Vamos a pedirle al IA que realice este cálculo del impuesto.

4.3.2. Configuración de la sesión de Gemini

La pregunta planteada a Gemini va acompañada de dos archivos:

En [1], el cálculo que acabamos de detallar se ha introducido en un PDF que se entrega a Gemini. Gemini encontrará en él las reglas exactas para el cálculo simplificado del impuesto de 2019 sobre los ingresos de 2018;
En [2], nuestras instrucciones;
En [3] para ejecutar el IA;

Nuestras instrucciones en el archivo de texto [instructionsAvecPDF.txt] son las siguientes:

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é.

Estas instrucciones son el resultado de numerosas preguntas formuladas a Gemini. Muy pronto nos damos cuenta de que el IA debe estar muy bien definido si queremos obtener lo que queremos. Debido a todos estos intentos fallidos, la sesión de Gemini se detuvo finalmente por exceder los límites. Examinemos el resto de estas instrucciones:

Línea 1: se solicita que la conversación sea en francés. Esta indicación es para DeepSeek, que tendía a hablar en inglés;
Línea 3: lo que queremos;
Línea 5: se le dice a IA que utilice el PDF que se le ha dado;
Líneas 7-14: una serie de consejos útiles, sobre todo para el problema 3 sin PDF. Se han perdido varios IA en el cálculo del impuesto;
Líneas 15-44: las 11 pruebas unitarias que queremos que se incluyan en el script generado. Cuando se genere el script, lo ejecutaremos en PyCharm y veremos si las 11 pruebas pasan;
Líneas 46-53: sin estas instrucciones, IA generaba pruebas unitarias que buscaban resultados exactos y fallaban;
Líneas 55-56: le indico a IA que no se conecte a Internet. La solución más sencilla es utilizar PDF;
Líneas 58-59: esta instrucción no fue seguida por los IA. Me vi obligado a escribirla explícitamente en una pregunta, cuando comprobé que una prueba había fallado;
Líneas 61-65: indico qué tipo de script de Python deseo;
Líneas 67-69: hubiera preferido un enlace para recuperar el script generado, ya que mostrar el código en pantalla lleva tiempo. Resultó que la mayoría de los IA no saben hacer esto. Los enlaces proporcionados no funcionaban;
Líneas 71-72: me hubiera gustado saber el tiempo que tardó el IA en responder a la pregunta. Solo Gemini pudo darme esta información. Los demás IA o bien no respondían a esta instrucción, o bien daban cifras fantasiosas que demostraban que no la entendían;

4.3.3. La respuesta de Gemini

La primera respuesta de Gemini es la siguiente:

En [1-4], Gemini proporciona enlaces a la parte del PDF o del archivo de texto de las instrucciones que utiliza en un momento dado;

La continuación es la siguiente:

En [1], Gemini afirma que ha ejecutado con éxito las 11 pruebas unitarias. La mayoría de los IA afirmaban lo mismo tanto en el problema 2 como en el problema 3 y, a menudo, al cargar el script generado, este no funcionaba. Por lo tanto, hay que desconfiar de esta afirmación. En el caso de Gemini, resultará ser cierto;
En [2], un enlace que resultará no funcionar;
En [3], solo Gemini dio un tiempo de ejecución realista;

Por lo tanto, el enlace [2] no funciona. Se lo indicamos a Gemini:

La respuesta de Gemini:

En [1], el script de Python generado por Gemini;

Cargamos este script en PyCharm y lo ejecutamos:

En [1], [gemini1] es el script generado por Gemini;

Al ejecutar el script aparecen errores de compilación:


"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\chatGPT\chatGPT1.py" 
Testing started at 17:12 ...
Launching unittests with arguments python -m unittest C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\chatGPT\chatGPT1.py in C:\Data\st-2025\dev\python\code\python-flask-2025-cours

Traceback (most recent call last):
  File "C:\Program Files\JetBrains\PyCharm 2025.2.0.1\plugins\python-ce\helpers\pycharm\_jb_unittest_runner.py", line 38, in <module>
    sys.exit(main(argv=args, module=None, testRunner=unittestpy.TeamcityTestRunner,
             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                  buffer=not JB_DISABLE_BUFFERING))
                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Program Files\Python313\Lib\unittest\main.py", line 103, in __init__
    self.parseArgs(argv)
    ~~~~~~~~~~~~~~^^^^^^
  File "C:\Program Files\Python313\Lib\unittest\main.py", line 142, in parseArgs
    self.createTests()
    ~~~~~~~~~~~~~~~~^^
  File "C:\Program Files\Python313\Lib\unittest\main.py", line 153, in createTests
    self.test = self.testLoader.loadTestsFromNames(self.testNames,
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^
                                                   self.module)
                                                   ^^^^^^^^^^^^
  File "C:\Program Files\Python313\Lib\unittest\loader.py", line 207, in loadTestsFromNames
    suites = [self.loadTestsFromName(name, module) for name in names]
              ~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^
  File "C:\Program Files\Python313\Lib\unittest\loader.py", line 137, in loadTestsFromName
    module = __import__(module_name)
  File "C:\Data\st-2025\dev\python\code\python-flask-2025-cours\outils ia\chatGPT\chatGPT1.py", line 28, in <module>
    [cite_start]
     ^^^^^^^^^^
NameError: name 'cite_start' is not defined

Process finished with exit code 1

Empty suite

Línea 30, el error de compilación. [cite_start] es un marcador para generar un determinado tipo de texto;

Ponemos los registros anteriores en un archivo [logs gemini1.txt] y se lo pasamos a Gemini:

La respuesta de Gemini es entonces la siguiente:

Una vez cargado en PyCharm, la ejecución del nuevo script genera exactamente el mismo error. Se se lo comunicamos a Gemini proporcionándole de nuevo los registros de la ejecución:

La respuesta de Gemini es la siguiente:

Esta vez sí. Las 11 pruebas unitarias se han superado. Se lo comunicamos a Gemini:

Que responde:

El script generado por Gemini ha seguido las instrucciones dadas en el archivo de texto [instructionsAvecPDF.txt]:

# -*- 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 IMPÔT 2019 ---
# Todos los valores se extraen del documento PDF proporcionado.

# Límites máximos para la deducción del 10 % sobre los ingresos anuales
PLAFOND_ABATTEMENT_10_POURCENT = 12502.0
MINIMUM_ABATTEMENT_10_POURCENT = 437.0

# Escala del impuesto sobre la renta de 2019
# Estructura: (Umbral máximo del tramo, tipo impositivo, importe a deducir por parte)
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}
]

# Límite máximo del coeficiente familiar
GAIN_MAX_DEMI_PART = 1551.0  # Ganancia máxima por cada media parte adicional

# Umbrales e importes para la reducción
SEUIL_APPLICATION_DECOTE = {"celibataire": 1595.0, "couple": 2627.0}
SEUIL_CALCUL_DECOTE = {"celibataire": 1196.0, "couple": 1970.0}

# Umbrales para la reducción fiscal del 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
     # La deducción tiene un límite máximo y mínimo
    abattement = min(PLAFOND_ABATTEMENT_10_POURCENT, max(MINIMUM_ABATTEMENT_10_POURCENT, abattement_calcule))

     # La pregunta pide redondear la deducción al euro superior
    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 el QF es superior a todos los umbrales, se utiliza el último tramo
    if tranche_applicable is None:
        tranche_applicable = BAREME_IMPOT_2019[-1]

     # Fórmula para calcular el impuesto bruto
    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

     # Cálculo del impuesto sin las participaciones de los hijos
    parts_sans_enfants = calculer_nombre_parts(adultes, 0)
    impot_sans_enfants = calculer_impot_brut_base(revenu_imposable, parts_sans_enfants)

     # Cálculo de la ganancia máxima relacionada con los hijos
    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

     # El impuesto retenido es el más alto de los dos cálculos
    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 reducción se aplica si el impuesto está por debajo del umbral de aplicación
    if impot_avant_decote < seuil_application:
         # Fórmula de la reducción: umbral - 0,75 * Impuesto bruto
        decote_calculee = seuil_calcul - (0.75 * impot_avant_decote)

         # Redondeado al euro superior
        decote = math.ceil(decote_calculee)

         # La reducción no puede ser negativa ni superior al impuesto
        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]

     # El umbral se incrementa por cada media parte relacionada con los hijos
    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 reducción se aplica si la renta imponible está por debajo del umbral
    if revenu_imposable < seuil_final:
        reduction_calculee = impot_avant_reduction * 0.20

         # Redondeado al euro superior
        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.
    """
     # Paso 1: Cálculo de la base imponible
    revenu_imposable = calculer_revenu_imposable(revenus)

     # Paso 2: Cálculo del número de partes
    nombre_parts = calculer_nombre_parts(adultes, enfants)

     # Paso 3: Cálculo del impuesto bruto
    impot_brut_initial = calculer_impot_brut_base(revenu_imposable, nombre_parts)

     # Paso 4: Aplicación del límite máximo de QF
    impot_apres_plafonnement = appliquer_plafonnement_qf(impot_brut_initial, revenu_imposable, adultes, enfants)

     # Paso 5: Aplicación de la deducción
    impot_apres_decote, decote_calculee = appliquer_decote(impot_apres_plafonnement, adultes)

     # Paso 6: Aplicación de la reducción del 20 %
    impot_avant_arrondi_final, reduction_calculee = appliquer_reduction_20_pourcent(impot_apres_decote,
                                                                                    revenu_imposable, adultes, enfants)

     # Paso 7: Redondeo final del impuesto al euro inferior
    impot_final = math.floor(impot_avant_arrondi_final)

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


# --- TESTS UNITAIRES ---
# Validación del script con los casos proporcionados
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)

     # Ejemplo de uso de la calculadora para un caso concreto
    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']}€")

No he comprobado este código. Dado que las 11 pruebas unitarias han pasado, considero que es «probablemente correcto». No he hecho nada más con mi propio código que comprobar estas 11 pruebas.

4.4. El problema 3

El problema 3 es idéntico al problema 2, salvo que ya no se le da al IA el PDF que proporcionaba las reglas de cálculo a seguir.

La pregunta inicial a Gemini es la siguiente:

El archivo de instrucciones en [1] es prácticamente el mismo que para el problema 2, con las siguientes diferencias:


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], se le pide que busque en Internet las normas de cálculo del impuesto de 2019 sobre los ingresos de 2018. Es un ejercicio más difícil que el anterior;

A continuación solo incluyo partes de la primera respuesta de Gemini:

El tiempo estimado es plausible. Esperamos mucho tiempo la respuesta de Gemini.

Al igual que antes, Gemini ha proporcionado un enlace de descarga del script generado, enlace que no funciona. Se lo indicamos:

La respuesta de Gemini:

Cargamos el script en PyCharm con el nombre [gemini2]:

Lo ejecutamos y… no funciona. Los registros de la ejecución son los siguientes:


"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

Línea 11, una prueba ha fallado;
Líneas 25 y 42: el mismo error de compilación;

Guardamos estos registros en un archivo de texto que le pasamos a Gemini:

La respuesta de Gemini:

Cargamos el script en PyCharm y lo ejecutamos. Más errores. Se lo comunicamos a Gemini adjuntando de nuevo los registros de la ejecución:

La respuesta de Gemini:

Cargamos este nuevo script en PyCharm y lo ejecutamos. Esta vez, las 11 pruebas unitarias se superan:

El código generado por Gemini es el siguiente:

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

# ==============================================================================
# CONSTANTES POUR ElIMPOSITION 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 el impuesto ya es 0, no hay descuento ni reducción.
    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. Determinar la elegibilidad para el descuento del 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. Determinar la elegibilidad para el descuento
    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: El descuento devuelto no puede superar el impuesto que anula
        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. Aplicar la reducción del 20 % si se cumple el requisito
    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)

Una vez más, no he revisado este código. Simplemente he comprobado que superaba las 11 pruebas con éxito.

Pero puede que nos interese conocer su razonamiento, especialmente en los casos particulares del cálculo del impuesto. Se le pregunta:

Se trata de un caso de ingresos elevados con un posible límite máximo de la deducción del 10 % y un posible límite máximo del coeficiente familiar.

La respuesta de Gemini es la siguiente:

Estas dos últimas capturas de pantalla son interesantes. Gemini utiliza un método de cálculo diferente al explicado en el PDF. De hecho, este método de cálculo se puede encontrar en Internet. Ambos métodos son equivalentes.

La explicación destaca por su claridad. Se podría entregar tal cual a los estudiantes para explicar el método de cálculo del impuesto.

Ahora tomemos otro ejemplo, esta vez con ingresos bajos. En este caso, puede haber una bonificación y una reducción:

La respuesta de Gemini es la siguiente:

Aquí vemos que Gemini aplica una regla que no está en el PDF. Probablemente la haya encontrado en Internet, pero ¿es fiable la fuente?

Aquí, Gemini sigue aplicando una regla desconocida (la regla especial mencionada anteriormente).

Por lo tanto, los resultados de Gemini coinciden con el resultado del simulador oficial de impuestos. Pero ha utilizado una regla que no aparece en el PDF. ¿Dónde está el error? Se lo preguntamos adjuntándole el PDF:

La respuesta de Gemini:

Creo que Gemini tiene razón y que mi PDF es erróneo. Para verificarlo, le pido que haga una prueba:

Donde su razonamiento daría los mismos resultados que el simulador fiscal oficial;
Donde el razonamiento del PDF le daría resultados diferentes a los del simulador;

La respuesta de Gemini es la siguiente:

Aquí Gemini se equivoca. He ejecutado el simulador con este ejemplo y he obtenido lo siguiente:

Sin embargo, veremos que el razonamiento de Gemini da efectivamente los resultados anteriores. Continuamos:

Muy bien. Tomamos nota. Continuamos:

Así pues, Gemini ha calculado (impuesto, descuento, reducción) = (431, 325, 1296), mientras que el simulador que yo he utilizado da como resultado (431, 324, 1297). Por lo tanto, Gemini ha obtenido los resultados correctos con una diferencia de 1 euro, pero no lo sabe. Se lo indicamos:

Gemini responde:

Ahora nos preguntamos si Gemini podría generar un PDF corregido:

La respuesta de Gemini:

Así pues, Gemini no me ha proporcionado un enlace a un PDF, pero ha generado un texto para que yo mismo genere ese PDF. Aunque resulte un poco pesado incluir aquí las capturas de pantalla del PDF, lo hago para que el lector vea el aspecto generativo del IA:

Sinceramente, no he comprobado si todo lo que se dice en este PDF es cierto. En cualquier caso, es un documento perfecto para un TD, generado en unos segundos.

No obstante, podemos hacer que el propio Gemini compruebe que su PDF es correcto. Iniciamos una nueva conversación:

en [1], hemos puesto el PDF generado por Gemini [Le problème selon Gemini.pdf];
en [2], [instructionsAvecPDF2.txt] es idéntico a las instrucciones de [instructionsAvecPDF.txt], salvo que se ha añadido una duodécima prueba unitaria, la misma que demostró que el PDF inicial era erróneo:

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

Curiosamente, fueron necesarias varias idas y venidas antes de que Gemini generara el script correcto:

Pregunta 2

Pregunta 3

Como ya se ha hecho varias veces, cuando el script generado y cargado en PyCharm falla, se le proporciona a Gemini el archivo de texto con los registros de la ejecución. Gemini los entiende perfectamente.

Pregunta 4

Pregunta 5

Pregunta 6 y fin

Ahora estamos seguros de la validez del PDF generado por Gemini. Las reglas de cálculo que se indican en él son correctas.

Ahora haremos lo mismo con los otros cinco IA, pero seremos muy breves en nuestras explicaciones, salvo en el caso de ChatGPT, el IA líder en este momento. Lo que nos interesa es saber si el IA resuelve o no los tres problemas que se le plantean. De hecho, las interfaces de todos estos IA son muy similares y he procedido con ellos igual que con Gemini. Se anima al lector a volver a reproducir las conversaciones de Gemini con el IA de su elección.