💻 computer science

CoRE: A Fine-Grained Code Reasoning Benchmark Beyond Output Prediction

L'article présente CoRE, une évaluation de raisonnement sur le code à granularité fine qui mesure les modèles de langage de grande taille sur l'invariance d'implémentation et la transparence du processus, révélant que les modèles actuels manquent souvent de robustesse face à des implémentations de code équivalentes et s'appuient sur une exécution superficielle plutôt que sur un raisonnement authentique sur les états intermédiaires.

Auteurs originaux : Jun Gao, Yun Peng, Qian Qiao, Changhai Zhou, Yuhua Zhou, Shiyang Zhang, Shichao Weng, Zhenchang Xing, Xiaoxue Ren

Publié 2026-04-29

📖 6 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Jun Gao, Yun Peng, Qian Qiao, Changhai Zhou, Yuhua Zhou, Shiyang Zhang, Shichao Weng, Zhenchang Xing, Xiaoxue Ren

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

La Grande Idée : Les codeurs IA « pensent-ils » vraiment ?

Imaginez que vous engagez un étudiant brillant pour résoudre un problème de mathématiques. Il écrit la réponse finale, et elle est correcte. Vous lui donnez une étoile dorée.

Mais ensuite, vous lui demandez d'expliquer comment il y est arrivé. Il commence à inventer des chiffres, à mélanger les étapes et à se perdre au milieu du processus. Pourtant, d'une manière ou d'une autre, il est toujours arrivé au bon chiffre final.

Le Problème : Les tests actuels pour l'IA (les modèles de langage ou LLM) sont comme cette étoile dorée. Ils ne vérifient que la réponse finale. Si l'IA produit la bonne sortie, nous supposons qu'elle « a compris » le code. Les auteurs de ce papier soutiennent que c'est un piège. L'IA pourrait simplement deviner ou utiliser des raccourcis (des heuristiques) plutôt que de simuler réellement l'exécution du code dans son « esprit ».

La Solution : CoRE (Le « test d'honnêteté » pour le code)

Les auteurs ont créé un nouveau benchmark appelé CoRE (Code Reasoning). Au lieu de simplement demander « Quelle est la réponse ? », CoRE pose deux questions beaucoup plus difficiles :

Est-ce que la façon dont vous posez la question a de l'importance ? (Invariance d'implémentation)
Savez-vous ce qui s'est passé au milieu ? (Transparence du processus)

Analogie 1 : « Le même gâteau, différentes recettes » (Invariance d'implémentation)

Imaginez que vous demandez à un chef de cuire un gâteau au chocolat.

Test standard : Vous lui donnez une recette spécifique (Recette A). Il la cuit. C'est bon. Validé.
Test CoRE : Vous lui donnez quatre recettes différentes pour exactement le même gâteau au chocolat.
- Recette 1 : Utilise du cacao en poudre.
- Recette 2 : Utilise des barres de chocolat fondues.
- Recette 3 : Utilise un ordre de mélange dans le bol différent.
- Recette 4 : Utilise une température de four différente.

Si le chef est vraiment un maître, il devrait pouvoir cuire un gâteau parfait, quelle que soit la recette utilisée.
La découverte du papier : Les modèles d'IA ont échoué à ce test. Ils étaient excellents pour cuire le gâteau lorsqu'ils utilisaient une recette qui ressemblait à celle qu'ils écrivent habituellement (leur propre « style »). Mais lorsqu'on leur donnait une recette écrite par une autre IA (un « style » différent), ils faisaient souvent des erreurs, même si les mathématiques étaient identiques. Ils étaient « obsédés par le style » plutôt que par la logique.

Analogie 2 : Le « réalisateur de film » vs le « spoiler » (Transparence du processus)

Imaginez que vous regardez un film.

Test standard : On demande à l'IA : « Qui gagne à la fin du film ? » Elle répond : « Le héros gagne. » Correct !
Test CoRE : On demande à l'IA : « À la minute 45, quand le héros se cache dans le placard, qu'est-ce que le méchant tient ? Et à la minute 60, quel est le score du héros ? »

Cela vérifie les états intermédiaires.
La découverte du papier : Les modèles d'IA répondaient souvent correctement à la question « Qui gagne ? », mais ils hallucinaient les détails du milieu. Ils devinaient la fin basée sur des motifs, mais ils ne regardaient pas vraiment le film étape par étape. Ils exécutaient le code superficiellement sans vraiment comprendre le voyage.

Comment ils ont construit CoRE

Pour rendre ce test équitable et difficile, les chercheurs ont fait deux choses principales :

Généré de nombreuses versions : Ils ont utilisé différents modèles d'IA pour écrire du code pour les mêmes 60 problèmes. Cela a créé une bibliothèque de 255 versions différentes de code. Certaines étaient longues et désordonnées ; d'autres étaient courtes et ingénieuses. Mais elles faisaient toutes exactement la même chose.
Créé des questions de « quiz surprise » : Pour chaque morceau de code, ils ont généré des questions sur le milieu du processus.
- Arithmétique : « Quel est le nombre exact dans cette variable en ce moment ? »
- Logique : « Cette condition est-elle vraie ou fausse ? »
- État : « Combien de fois cette boucle a-t-elle tourné jusqu'à présent ? »
- Limite : « Que se passe-t-il juste au moment où la boucle s'arrête ? »

Ce qu'ils ont trouvé (Les résultats)

Ils ont testé 8 des modèles d'IA les plus intelligents disponibles (comme GPT-5, Claude, DeepSeek, etc.) en utilisant ce nouveau benchmark. Les résultats étaient surprenants :

Le fossé du « biais de style » : Les modèles comprenaient beaucoup mieux le code écrit par leur propre « famille » (par exemple, les modèles OpenAI comprenaient mieux le code OpenAI) que le code écrit par d'autres. Cela suggère qu'ils mémorisent les styles plutôt qu'ils n'apprennent une logique universelle.
Le fossé de « l'exécution superficielle » : De nombreux modèles obtenaient la bonne réponse finale mais échouaient au « quiz surprise » sur les étapes intermédiaires. Ils devinaient la destination sans connaître le chemin.
Le score « RCS » : Les auteurs ont créé un nouveau score appelé Reasoning Consistency Score (RCS) (Score de cohérence du raisonnement). Ce score pénalise les modèles qui obtiennent la bonne réponse pour les mauvaises raisons. Si vous obtenez la bonne réponse mais échouez aux étapes intermédiaires, votre score tombe à zéro.

La Conclusion

Le papier conclut que obtenir la bonne réponse ne suffit pas. Le fait qu'une IA puisse prédire la sortie finale d'un extrait de code ne signifie pas qu'elle comprend comment le code fonctionne.

Les modèles d'IA actuels sont comme des acteurs qui mémorisent la dernière réplique d'une pièce de théâtre mais oublient le dialogue entre les deux. CoRE est le nouveau test qui les force à montrer leur travail, prouvant qu'ils « pensent » réellement à travers le code, et non qu'ils devinent simplement la fin.

En bref : CoRE expose le fait que les IA les plus intelligentes d'aujourd'hui écrivant du code « font semblant » en s'appuyant sur des motifs et des styles plutôt que sur un raisonnement authentique, étape par étape.

1. Énoncé du problème

Malgré les progrès rapides des grands modèles de langage (LLM) dans la génération de code, il reste incertain de savoir si ces modèles possèdent une véritable compréhension de la logique d'exécution du code ou s'ils se contentent de recourir à des heuristiques superficielles pour prédire des sorties correctes. Les benchmarks existants (par exemple, CruxEval, LiveCodeBench-O, REval) souffrent de deux défauts critiques :

Absence d'invariance d'implémentation : Ils évaluent généralement les modèles par rapport à une seule implémentation de code « canonique ». Cela ne permet pas de vérifier si un modèle peut raisonner de manière cohérente à travers des variations de code fonctionnellement équivalentes mais structurellement ou lexicalement distinctes.
Absence de transparence du processus : Ils se concentrent presque exclusivement sur la justesse de la sortie finale. Les modèles peuvent souvent produire la bonne réponse finale tout en hallucinant des états d'exécution intermédiaires, ce qui indique un manque de raisonnement véritable étape par étape.

Les auteurs soutiennent que les évaluations basées uniquement sur la sortie sont insuffisantes pour évaluer un raisonnement de code robuste et introduisent CoRE pour combler ces lacunes.

2. Méthodologie : Le benchmark CoRE

CoRE est construit à partir de 60 problèmes de codage sélectionnés parmi HumanEval et LiveCodeBench, conçus pour évaluer deux dimensions fondamentales : l'invariance d'implémentation et la transparence du processus.

A. Pipeline de construction

Implémentations de code diversifiées (Étape I) :
- Les auteurs ont utilisé sept LLM diversifiés pour générer plusieurs solutions pour chaque problème.
- Processus de nettoyage : Les solutions ont subi une validation d'exécution pour assurer l'équivalence fonctionnelle. Pour garantir la diversité, ils ont filtré en fonction d'une complexité cyclomatique élevée et d'une faible similarité Jaccard 1-gramme (diversité lexicale) entre les implémentations d'un même problème.
- Résultat : 255 implémentations de code uniques répartis sur 60 problèmes (en moyenne 4,3 implémentations par problème).
Sondes d'états intermédiaires (Étape II) :
- En utilisant le traçage d'exécution Python, les auteurs ont capturé les valeurs d'exécution de référence pour toutes les variables.
- Ils ont formulé des questions de sondage intermédiaire ciblant quatre dimensions de raisonnement :
  - Arithmétique : Précision numérique dans les opérations complexes.
  - Logique : Résolution de conditions booléennes imbriquées et de flux de contrôle.
  - État : Suivi de l'historique des variables à travers des chemins d'exécution profonds.
  - Limites : Points de transition critiques (par exemple, terminaisons de boucles).
- Résultat : 243 sondes intermédiaires (en moyenne 4,1 par problème), chaque sonde couvrant en moyenne 2,2 dimensions de raisonnement.

B. Protocole d'évaluation et métriques

Les auteurs proposent un protocole d'évaluation holistique qui va au-delà de la simple exactitude :

Cohérence stricte de la sortie ( $I$ ) : Un indicateur binaire (1 ou 0) où le modèle doit prédire la sortie correcte pour chaque implémentation diversifiée d'un problème.
Poids de fidélité du processus ( $W_s$ ) : Le ratio des sondes d'états intermédiaires correctement répondues.
Score de cohérence du raisonnement (RCS) : La métrique principale définie comme $RCS = I \times W_s$ $R C S = I \times W_{s}$ .
- Cette formulation garantit que si un modèle échoue à l'invariance d'implémentation (c'est-à-dire qu'il se trompe sur une variante) ou s'il repose sur des heuristiques superficielles (faible $W_s$ ), le score final est fortement pénalisé ou annulé.

3. Contributions clés

Benchmark CoRE : Un benchmark rigoureux comprenant 1 978 échantillons qui évalue conjointement l'invariance d'implémentation et la transparence du processus, présentant une complexité (complexité cyclomatique moyenne de 5,0) et une diversité supérieures à celles des benchmarks existants.
Identification de limitations fondamentales : L'étude révèle deux modes d'échec critiques chez les LLM de pointe :
- Fossé de robustesse (surapprentissage stylistique) : Les modèles performent significativement mieux sur du code généré par leur propre famille ou des styles familiers (par exemple, les modèles OpenAI sur du code OpenAI) par rapport à du code fonctionnellement équivalent provenant d'autres styles.
- Exécution superficielle : Les modèles arrivent fréquemment à des sorties finales correctes tout en hallucinant des états intermédiaires, prouvant qu'ils reposent sur une correspondance entrée-sortie plutôt que sur une simulation d'exécution véritable.
Protocole d'évaluation holistique : L'introduction du Score de cohérence du raisonnement (RCS) fournit une méthode pour distinguer le raisonnement véritable des raccourcis heuristiques.

4. Résultats expérimentaux

Les auteurs ont évalué huit LLM de pointe (incluant GPT-5, o3, Claude-4.5, DeepSeek-V3.2 et Qwen-3) en utilisant diverses stratégies d'incitation (IO, Chaîne de pensée, Chaîne de code, RHDA).

Fossé de performance : Il existe un décalage massif entre la justesse de la sortie finale et le raisonnement intermédiaire. Par exemple, GPT-5 a atteint une exactitude stricte de sortie de 84,62 % ( $I$ ) mais seulement 18,96 % de fidélité du processus ( $W_s$ ) dans des conditions d'incitation standard.
Biais stylistique : L'analyse des cartes thermiques (Fig. 5) montre une dominance diagonale forte, où les modèles obtiennent les scores les plus élevés sur le code généré par leur propre famille. Cela confirme le surapprentissage stylistique.
Impact des incitations : Bien que la Chaîne de pensée (CoT) et la Chaîne de code (CoC) aient amélioré la fidélité du processus, elles n'ont pas entièrement éliminé le fossé de robustesse ni l'exécution superficielle.
Faiblesses dimensionnelles : Les modèles ont eu le plus de difficultés avec l'Arithmétique (précision numérique) et l'État (maintien de l'historique des variables), les scores moyens de fidélité du processus étant souvent inférieurs à 50 % dans le cadre IO.
Efficacité du RCS : La métrique RCS a efficacement filtré les modèles qui semblaient compétents basés uniquement sur la sortie, mais qui échouaient sur la cohérence du raisonnement.

5. Signification

L'article modifie fondamentalement le paradigme de l'évaluation du raisonnement en code. Il démontre qu'une sortie correcte n'implique pas un raisonnement correct. En exposant la fragilité des LLM actuels — spécifiquement leur vulnérabilité aux biais stylistiques et leur incapacité à suivre les états intermédiaires — CoRE fournit une norme nécessaire pour développer des modèles qui comprennent véritablement l'exécution du code. Les résultats suggèrent que l'entraînement et l'évaluation futurs des LLM doivent privilégier un raisonnement étape par étape fidèle et une robustesse à travers des implémentations diversifiées plutôt que de simplement optimiser pour la justesse de la sortie finale.