The Path Not Taken: Duality in Reasoning about Program Execution

Titel: The Path Not Taken: Dualiteit in Redeneren over Programma-uitvoering

Auteurs: Eshgin Hasanov et al. (University of Central Florida)

---

1. Het Probleem

Grote Taalmodellen (LLMs) tonen indrukwekkende vaardigheden in coderingstaken, maar hun toepassing in de praktijk wordt beperkt door een gebrek aan echt begrip van programma-uitvoering. Bestaande benchmarks focussen voornamelijk op het voorspellen van programma-eigenschappen gebaseerd op specifieke invoer (zoals uitvoer of code-coverage) langs één enkele uitvoeringspad.

De auteurs identificeren drie kritieke tekortkomingen in de huidige evaluatiemethoden:

• Enige Pad-Beperking: Bestaande benchmarks evalueren modellen vaak slechts onder één testgeval (één uitvoeringspad). Dit geeft een te smal beeld van het dynamische redeneervermogen, aangezien programma's veel verschillende paden kunnen doorlopen afhankelijk van de invoer.
• Oppervlakkige Patronen: Modellen kunnen succesvol lijken door oppervlakkige patronen na te bootsen zonder de onderliggende causale logica van de uitvoering te begrijpen.
• Gegevensvervuiling (Data Contamination): Benchmarks met vaste invoer-uitvoerparen kunnen tijdens het trainingsproces worden "uit het hoofd geleerd", wat de betrouwbaarheid van de evaluatie ondermijnt.

Er is behoefte aan een evaluatieframework dat de inherente dualiteit van programma-uitvoering test: het vermogen om zowel vooruit te redeneren (wat gebeurt er?) als achteruit te redeneren (wat moet er veranderen om een ander resultaat te krijgen?).

---

2. Methodologie: DEXBENCH

De auteurs introduceren DEXBENCH, een benchmark die is ontworpen om de dualiteit in redeneren over programma-uitvoering te operationaliseren. Het framework bestaat uit twee complementaire taken die samen een "dual-path" redenering vormen:

A. Forward Reasoning (Voorwaartse Redenering)

• Taak: Gegeven een programma $P$ en een invoer $I_{exec}$, voorspel het waarneembare gedrag (bijv. code-coverage of uitvoer).
• Formulering: $R_{exec}: (P, I_{exec}) \mapsto \phi(\tau_{exec})$.
• Doel: Test het vermogen van het model om de toestand van het programma te volgen en te updaten langs het daadwerkelijke uitvoeringspad.

B. Backward Reasoning (Achterwaartse / Counterfactual Redenering)

• Taak: Gegeven een programma $P$, een oorspronkelijke invoer $I_{exec}$ en een doelstelling $\phi^*$ (bijv. het bereiken van een specifieke, niet-bezochte tak in de code), genereer een gemuteerde invoer $I_{cf}$ die leidt tot dit doel.
• Formulering: $R_{cf}: (P, I_{exec}, \phi^*) \mapsto I_{cf}$.
• Doel: Test het vermogen om causaal terug te redeneren: welke veranderingen in de invoer zijn nodig om het uitvoeringspad te laten divergeren naar een alternatief pad?

C. Dual-Path Reasoning (De Kern)

De echte evaluatie vindt plaats wanneer een model beide taken correct moet uitvoeren voor hetzelfde paar van uitvoeringspad en contrafactueel pad. Een succesvolle evaluatie vereist dat het model:

1. Het oorspronkelijke gedrag correct voorspelt.
2. Een nieuwe invoer genereert die het gedrag verandert naar de gewenste doelstelling.
   Dit voorkomt dat modellen de taken als losgekoppeld zien en dwingt hen een consistente causale representatie van de uitvoeringsflow te behouden.

Benchmarkspecificaties:

• Bron: DEXBENCH bevat 445 unieke instanties afkomstig uit drie datasets: CruxEval, HumanEval en PythonSaga.
• Complexiteit: De programma's variëren in complexiteit (van simpele conditionals tot recursie en diepe nesting).
• Selectie: Alleen programma's met minstens één voorwaarde/lus en een testgeval dat minder dan 100% code-coverage oplevert, zijn geselecteerd om ruimte te laten voor contrafactuele paden.

---

3. Belangrijkste Resultaten

De auteurs hebben 13 LLMs geëvalueerd (9 open-source en 4 gesloten-source/propriëtaire modellen), variërend van kleine (<10B parameters) tot zeer grote modellen (>70B parameters).

A. Asymmetrie in Prestaties

• Sterke prestaties in alleen voorwaartse of alleen achterwaartse redenering vertalen zich niet automatisch naar succes in de gezamenlijke (dual-path) evaluatie.
• Veel modellen slagen in één taak maar falen in de andere, wat aangeeft dat ze geen holistisch begrip van de uitvoeringsflow hebben.

B. Schaalwetten en Modelgrootte

• Kleine modellen (<10B): Falen consequent in dual-path redenering, voornamelijk door het niet kunnen voorspellen van code-coverage.
• Middelgrote modellen (20B-30B): Toon aanzienlijke verbeteringen.
• Grote modellen (>30B): Grotere grootte garandeert geen betere prestaties. Bijvoorbeeld, binnen de Qwen-familie presteerde het 32B-model beter in dual-path redenering dan het 72B-model.

C. Impact van "Reasoning"-Post-Training

• Modellen die specifiek zijn getraind voor redeneren (bijv. QwQ-32B, Magistral Small) presteren vaak slechter dan hun niet-redenerende tegenhangers (Qwen2.5-32B, Mistral Small 24B) in deze specifieke taken.
• Dit suggereert dat bestaande "reasoning"-post-training niet goed generaliseert naar het redeneren over dynamische code-uitvoering.

D. Prestaties van Gesloten-Source Modellen

• Gesloten modellen (Claude Sonnet 4, Grok-4 Reasoning, GPT-5 Mini) presteren over het algemeen het beste, met Claude Sonnet 4 als leider.
• Echter, zelfs de beste modellen tonen een daling in prestaties naarmate de programmacomplexiteit toeneemt (CruxEval < HumanEval < PythonSaga).

E. Foutanalyse

• Forward Redenering: Falen komt vaak door instructie-misverstanden, het overslaan van statements of hallucinaties.
• Backward Redenering: Falen wordt vaak veroorzaakt door semantische fouten (bijv. verkeerd begrijpen van API-gedrag zoals split() vs splitlines()) of het niet kunnen genereren van een geldige invoer.
• Modellen die goed zijn in het voorspellen van uitvoer, falen vaak bij het genereren van de juiste invoer voor een contrafactueel pad, en vice versa.

---

4. Bijdragen en Significantie

Primaire Bijdragen

1. Concept van Dualiteit: De paper introduceert het concept dat het begrijpen van programma-uitvoering inherent dualistisch is en vereist zowel voorwaartse als achterwaartse causale redenering.
2. DEXBENCH Benchmark: Een nieuw, robuust en uitbreidbaar benchmark dat 445 gepaarde instanties bevat voor het evalueren van dynamisch codebegrip.
3. Empirisch Bewijs: Het demonstreert dat huidige benchmarks onvoldoende zijn en dat "reasoning"-specialisatie niet altijd leidt tot beter begrip van code-uitvoering.

Significantie voor de Gemeenschap

• Robuustere Evaluatie: DEXBENCH biedt een strengere test dan bestaande benchmarks, omdat het voorkomt dat modellen oppervlakkige patronen gebruiken of specifieke invoer-uitvoerparen memoriseren.
• Inzicht in Causaal Redeneren: Het benadrukt dat voor echte software-engineering taken (zoals debugging, fuzzing en testen) modellen niet alleen moeten weten wat er gebeurt, maar ook waarom het gebeurt en hoe ze het kunnen veranderen.
• Toekomstige Richting: De bevindingen suggereren dat de huidige richting van "reasoning-focused" post-training mogelijk niet de juiste aanpak is voor dynamisch codebegrip en dat nieuwe trainingsstrategieën nodig zijn.

Conclusie

Het paper concludeert dat het evalueren van LLMs op basis van enkelvoudige uitvoeringspaden misleidend is. De voorgestelde dual-path aanpak (DEXBENCH) biedt een systematisch kader om het vermogen van modellen om causale relaties in code te begrijpen, te meten. De resultaten tonen aan dat er nog een aanzienlijke kloof bestaat tussen het kunnen voorspellen van uitvoer en het kunnen manipuleren van invoer om gewenste uitvoeringspaden te bereiken, zelfs voor de meest geavanceerde modellen.