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

1. Probleemstelling

Ondanks de snelle vooruitgang van Large Language Models (LLM's) in codegeneratie, blijft het onduidelijk of deze modellen een werkelijk begrip hebben van de uitvoeringslogica van code of zich enkel baseren op oppervlakkige heuristieken om correcte uitvoer te voorspellen. Bestaande benchmarks (zoals CruxEval, LiveCodeBench-O, REval) kampen met twee kritieke gebreken:

1. Gebrek aan Implementatie-invariantie: Ze evalueren modellen doorgaans tegenover één enkele "canonieke" code-implementatie. Dit test niet of een model consistent kan redeneren over functioneel equivalente maar structureel of lexicaal verschillende codevariaties.
2. Gebrek aan Procestransparantie: Ze richten zich bijna uitsluitend op de juistheid van de uiteindelijke uitvoer. Modellen kunnen vaak het juiste eindantwoord produceren terwijl ze tussentijdse uitvoerstaten hallucineren, wat wijst op een gebrek aan echt stap-voor-stap redeneren.

De auteurs betogen dat evaluaties die enkel de uitvoer betrekken ontoereikend zijn voor het beoordelen van robuust code-redeneren en introduceren CoRE om deze hiaten op te vullen.

2. Methodologie: De CoRE Benchmark

CoRE is opgebouwd uit 60 programmeerproblemen geselecteerd uit HumanEval en LiveCodeBench, ontworpen om twee kernaspecten te evalueren: Implementatie-invariantie en Procestransparantie.

A. Constructiepijplijn

1. Diverse Code-implementaties (Fase I):

   • De auteurs gebruikten zeven diverse LLM's om meerdere oplossingen voor elk probleem te genereren.
   • Schoonmaakproces: Oplossingen ondergingen uitvoeringsvalidatie om functionele equivalentie te waarborgen. Om diversiteit te garanderen, filterden ze op hoge Cyclomatic Complexity en lage 1-gram Jaccard Similariteit (lexicale diversiteit) tussen implementaties van hetzelfde probleem.
   • Resultaat: 255 unieke code-implementaties verspreid over 60 problemen (gemiddeld 4,3 implementaties per probleem).

2. Tussentijdse State-probes (Fase II):

   • Met behulp van Python-uitvoeringstracing legden de auteurs ground-truth runtime-waarden voor alle variabelen vast.
   • Ze formuleerden tussentijdse probe-vragen die gericht waren op vier redeneerdimensies:
     • Aritmetiek: Numerieke precisie in complexe bewerkingen.
     • Logica: Oplossing van geneste booleaanse voorwaarden en controleflow.
     • State: Het bijhouden van variabelegeschiedenis over diepe uitvoeringspaden.
     • Grens: Kritieke overgangspunten (bijvoorbeeld loopbeëindigingen).
   • Resultaat: 243 tussentijdse probes (gemiddeld 4,1 per probleem), waarbij elke probe gemiddeld 2,2 redeneerdimensies bestrijkt.

B. Evaluatieprotocol en Metrieken

De auteurs stellen een holistisch evaluatieprotocol voor dat verder gaat dan eenvoudige nauwkeurigheid:

• Strenge Output-consistentie ($I$): Een binair indicator (1 of 0) waarbij het model de correcte uitvoer moet voorspellen voor elke diverse implementatie van een probleem.
• Procesfideliteitsgewicht ($W_s$): De verhouding van correct beantwoorde tussentijdse state-probes.
• Redeneerconsistentiescore (RCS): De primaire metriek gedefinieerd als $RCS = I \times W_s$.
  • Deze formulering zorgt ervoor dat als een model faalt in implementatie-invariantie (d.w.z. één variant fout heeft) of zich baseert op oppervlakkige heuristieken (lage $W_s$), de uiteindelijke score zwaar wordt bestraft of tot nul wordt herleid.

3. Belangrijkste Bijdragen

1. CoRE Benchmark: Een rigoureuze benchmark bestaande uit 1.978 samples die gezamenlijk implementatie-invariantie en procestransparantie evalueert, met hogere complexiteit (gemiddelde cyclomatic complexity van 5,0) en diversiteit dan bestaande benchmarks.
2. Identificatie van Fundamentele Beperkingen: De studie onthult twee kritieke faalmodi in frontier LLM's:
   • Robuustheidsgap (Stijloverfitting): Modellen presteren aanzienlijk beter op code gegenereerd door hun eigen familie of vertrouwde stijlen (bijvoorbeeld OpenAI-modellen op OpenAI-code) in vergelijking met functioneel equivalente code uit andere stijlen.
   • Oppervlakkige Uitvoering: Modellen komen vaak tot correcte einduitvoer terwijl ze tussentijdse staten hallucineren, wat bewijst dat ze vertrouwen op input-output-mapping in plaats van echte uitvoeringssimulatie.
3. Holistisch Evaluatieprotocol: De introductie van de Reasoning Consistency Score (RCS) biedt een methode om echt redeneren te onderscheiden van heuristische shortcuts.

4. Experimentele Resultaten

De auteurs evalueerden acht frontier LLM's (waaronder GPT-5, o3, Claude-4.5, DeepSeek-V3.2 en Qwen-3) met verschillende prompting-strategieën (IO, Chain-of-Thought, Chain-of-Code, RHDA).

• Performantiegap: Er is een enorme disconnectie tussen de nauwkeurigheid van de uiteindelijke uitvoer en het tussentijdse redeneren. Bijvoorbeeld, GPT-5 behaalde een strenge outputnauwkeurigheid van 84,62% ($I$), maar slechts 18,96% procesfideliteit ($W_s$) onder standaard prompting.
• Stijlbias: Heatmap-analyse (Fig. 5) toont een sterke diagonale dominantie, waarbij modellen de hoogste scores behalen op code gegenereerd door hun eigen familie. Dit bevestigt stijl-overfitting.
• Impact van Prompting: Hoewel Chain-of-Thought (CoT) en Chain-of-Code (CoC) de procesfideliteit verbeterden, elimineerden ze de robuustheidsgap of de oppervlakkige uitvoering niet volledig.
• Dimensie-zwaktes: Modellen hadden de meeste moeite met Aritmetiek (numerieke precisie) en State (het bijhouden van variabelegeschiedenis), met gemiddelde procesfideliteitsscores die vaak onder de 50% lagen in de IO-setting.
• RCS-effectiviteit: De RCS-metriek filterde effectief modellen eruit die competent leken op basis van uitvoer alleen, maar faalden op redeneerconsistentie.

5. Betekenis

Het artikel verschuift fundamenteel het paradigma van code-redeneerevaluatie. Het toont aan dat correcte uitvoer niet impliceert dat het redeneren correct is. Door de broosheid van huidige LLM's bloot te leggen – specifiek hun vatbaarheid voor stijlbias en hun onvermogen om tussentijdse staten bij te houden – biedt CoRE een noodzakelijke standaard voor het ontwikkelen van modellen die code-uitvoering werkelijk begrijpen. De bevindingen suggereren dat toekomstige LLM-training en -evaluatie prioriteit moeten geven aan trouw stap-voor-stap redeneren en robustheid over diverse implementaties in plaats van alleen te optimaliseren voor de nauwkeurigheid van de uiteindelijke uitvoer.