💬 NLP

LogicIF: Towards Complex Logic Instruction Following

Dit artikel introduceert LogicIFGen, een geautomatiseerd framework voor het genereren van verifieerbare logica-rijke instructies vanuit code, en LogicIFEval, een benchmark van 426 dergelijke taken, om aan te tonen dat huidige state-of-the-art LLM's aanzienlijk moeite hebben met het opvolgen van complexe logische instructies.

Oorspronkelijke auteurs: Mian Zhang, Shujian Liu, Sixun Dong, Ming Yin, Yebowen Hu, Xun Wang, Simin Ma, Song Wang, Sathish Reddy Indurthi, Haoyun Deng, Zhiyu Zoey Chen, Kaiqiang Song

Gepubliceerd 2026-07-21

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Mian Zhang, Shujian Liu, Sixun Dong, Ming Yin, Yebowen Hu, Xun Wang, Simin Ma, Song Wang, Sathish Reddy Indurthi, Haoyun Deng, Zhiyu Zoey Chen, Kaiqiang Song

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een robot leert om een recept te volgen. Als het recept zegt "voeg twee eieren toe," is de robot meestal wel goed in dat. Maar wat als het recept een complex, meer pagina's tellend verhaal is met loops, "als dit gebeurt, doe dan dat," en het bijhouden van een dozijn verschillende ingrediënten die tegelijkertijd veranderen? Dit is de wereld van Large Language Models (LLM's), de superintelligente AI-chatbots waar je misschien over hebt gehoord. Deze modellen zijn geweldig in het schrijven van gedichten of het beantwoorden van trivia, maar ze zijn in essentie patronenherkenningsmachines. Ze zijn getraind om het volgende woord in een zin te voorspellen, niet noodzakelijkerwijs om te handelen als een strikte, logische computer die een stapsgewijs plan volgt zonder een slag over te slaan. Wetenschappers vragen zich al lang af: kunnen deze AI-"hersenen" daadwerkelijk instructies opvolgen die zwaar zijn op logica, zoals een complex bordspel-regelboek of een computerprogramma, zonder in de war te raken of dingen te verzinnen?

Deze vraag is belangrijk omdat we AI steeds serieuzere taken laten doen—zoals het debuggen van code, het plannen van wetenschappelijke experimenten of het beheren van complexe taken—waardoor de instructies moeilijker worden. Ze stoppen met simpele verzoeken te zijn en worden ingewikkelde logische puzzels. Als een AI de logica niet kan volgen, geeft hij je misschien vol vertrouwen het verkeerde antwoord, wat gevaarlijk is wanneer je iets echts probeert te bouwen. De paper die je nu gaat lezen, duikt diep in dit exacte probleem door te testen of de slimste AI van vandaag daadwerkelijk door een logische doolhof kan "denken" of dat hij gewoon de uitgang raadt.

De Paper: LogicIF – Kan AI de regels volgen?

De auteurs van deze paper, een team van onderzoekers van universiteiten en Zoom, besloten AI op de proef te stellen met een nieuwe uitdaging die zij LogicIF (Logic Instruction Following) noemen. Zie dit als een "logica-sportschool" voor AI. In plaats van de AI te vragen een verhaal te schrijven, vragen ze het om te handelen als een menselijke rekenmachine die een zeer specifieke, ingewikkelde set regels volgt die in gewone Engelse taal zijn geschreven.

Om deze tests te creëren, bouwde het team een slimme machine genaamd LogicIFGen. Stel je voor dat je een geheime code (een computerprogramma) hebt die iets lastigs doet, zoals een lijst met getallen sorteren terwijl een lopende telling bijhoudt hoe vaak het de getallen heeft verwisseld. De machine neemt deze code, verbergt de code zelf, en vertaalt het naar een lange, gedetailleerde, conversationele instructiehandleiding. Het is alsof je een complex videospel-niveau neemt en een gids schrijft die zegt: "Spring eerst over de rode kuil. Als je een blauwe munt ziet, pak hem dan op. Als je die niet ziet, ga dan naar links." De AI moet deze gids lezen en doen alsof hij het personage in het spel is, waarbij hij stap voor stap beweegt om het juiste resultaat te bereiken, en dat alles zonder de originele code te zien.

De onderzoekers hebben met deze machine twee hoofdzaken gecreëerd:

LogicIFEval (De Test): Een benchmark met 426 lastige instructies. Deze zijn afkomstig van uitdagende programmeerpuzzels gevonden op concurrerende codingsites. De instructies zijn zo ontworpen dat ze "verifieerbaar" zijn, wat betekent dat er één enkel, correct antwoord is dat gecontroleerd kan worden door de originele code uit te voeren.
LogicIFTrain (De Oefening): Een enorme trainingsset met 27.324 instructies. Dit is als een oefenwerkboek voor de AI om te leren hoe hij deze complexe regels moet volgen.

De Grote Ontdekking: AI heeft moeite met logica
Toen ze de test draaiden op 21 van de meest geavanceerde AI-modellen (inclusief grote namen van OpenAI, Anthropic en Google), waren de resultaten een beetje een waarschuwing. Zelfs de slimste modellen, zoals de top-tier "denkende" modellen, kregen slechts ongeveer 85% van de instructies goed. Maar hier komt de crux: de meeste andere modellen, inclusief sommige zeer populaire open-source modellen, scoorden onder de 60%. Sommigen van hen haalden zelfs minder dan 10%.

Het blijkt dat hoewel deze AI's er geweldig in zijn om slim te klinken, ze vaak falen wanneer ze de opdracht krijgen om strikt een keten van logische stappen te volgen. Ze slaan stappen over, verliezen de draad van hun "score" (zoals het vergeten hoeveel keer ze een loop hebben uitgevoerd), of raden gewoon het uiteindelijke antwoord zonder daadwerkelijk het werk te verrichten. De paper vond dat naarmate de instructies ingewikkelder werden (meer loops, meer "als-dan"-regels), de prestaties van de AI scherp daalden.

Waarom "Denken" Helpt (Maar Geen Toverstaf Is)
De onderzoekers merkten iets interessants op: modellen die de ruimte kregen om hardop te "denken" voordat ze hun definitieve antwoord gaven, presteerden beter. Het is alsof je een student vertelt: "Neem even de tijd om je stappen op te schrijven voordat je het wiskundeprobleem oplost." Deze "denkende" modellen vertraagden, planden hun zetten en vermeden enkele vallen. Echter, zelfs met deze extra tijd maakten ze nog steeds fouten, wat bewees dat het volgen van complexe logica een moeilijke vaardigheid is die nog niet volledig beheerst wordt.

Het Goede Nieuws: We Kunnen Ze Trainen
De paper stopte niet alleen bij het aanwijzen van het probleem; het bood ook een oplossing. Het team gebruikte hun enorme oefenset (LogicIFTrain) om een kleiner AI-model te onderwijzen met behulp van een techniek genaamd Reinforcement Learning. Ze beloonden het model alleen wanneer het zowel het uiteindelijke antwoord goed had én alle tussenliggende stappen correct bijhield.

Het resultaat? Het getrainde model werd een logica-kampioen. Het verbeterde zijn score op de test met 16,7 punten. Nog verrassender was dat deze training niet alleen hielp bij logische puzzels. Het model werd ook beter in andere zaken, zoals het oplossen van wiskundeproblemen, het schrijven van code en het beantwoorden van lastige algemene kennisvragen. Het suggereert dat het leren volgen van strikte logica is als het leren fietsen: zodra je de balans beheerst, kun je ook andere dingen beter doen.

Wat Dit Betekent
De paper concludeert dat hoewel huidige AI-modellen krachtig zijn, ze een aanzienlijke blinde vlek hebben als het gaat om complexe, stapsgewijze logica. Ze vertrouwen vaak op het raden van patronen in plaats van het proces werkelijk te simuleren. Echter, door code te gebruiken om deze logische instructies te genereren en modellen te trainen om aandacht te besteden aan elke afzonderlijke stap, kunnen we hun vermogen om helder na te denken aanzienlijk vergroten. Het is een herinnering aan het feit dat voor AI om echt een behulpzame partner te worden in complexe taken, het niet alleen moet leren wat het moet zeggen, maar ook hoe het moet denken.

Technische Samenvatting: LogicIF: Naar Complexe Logische Instructie-opvolging

Probleemstelling

Hoewel Large Language Models (LLMs) bekwaamheid hebben getoond in het opvolgen van instructies met betrekking tot responsformat en inhoudelijke beperkingen, blijft hun vermogen om instructies met rijke, complexe logische structuren op te volgen onderbelicht. Real-world taken vereisen vaak dat modellen complexe logische stromen simuleren die sequenties, lussen, nesting en recursie omvatten. Bestaande benchmarks richten zich doorgaans op het voldoen aan beperkingen (constraint satisfaction) in plaats van de precieze uitvoering van meerstaps logische processen. Er is een kritiek gat in het begrip of LLMs in staat zijn om elke logische stap binnen een complexe instructie getrouw te simuleren zonder gebruik te maken van code-executie of externe tools.

Methodologie

LogicIFGen: Geautomatiseerde Instructiegeneratie

Om het tekort aan verifieerbare, logica-rijke instructies aan te pakken, stellen de auteurs LogicIFGen voor, een schaalbaar framework dat instructies synthetiseert vanuit codefuncties. De pipeline omvat:

Anonimisering en State Tracking: Originele codefuncties worden geanonimiseerd (door semantische variabelenamen te vervangen door generieke identificatoren) en uitgebreid met state trackers. Deze trackers zijn variabelen die ontworpen zijn om specifieke runtime-toestanden te loggen (bijv. iteratie-aantallen, maximale lijstlengtes, verwijderingsaantallen) om ervoor te zorgen dat het model de interne logische flow bijhoudt, en niet alleen de uiteindelijke outputs.
Natuurlijke Taalgeneratie: Een LLM vertaalt de geanonimiseerde, state-augmented code naar gedetailleerde, conversationele instructies in natuurlijke taal. Deze instructies zijn zo geformuleerd dat ze een model door een stapsgewijze uitvoering leiden zonder toegang tot de broncode.
Verificatie en Verfijning: Een multi-turn verificatiemodule controleert de gegenereerde instructies iteratief tegen de code om te garanderen dat alle operaties, lussen en edge cases volledig worden gedekt.
Kwantificering van Complexiteit: Het framework maakt gebruik van Python's Abstract Syntax Tree (AST) om een Kwantificeerbare Instructiecomplexiteitsscore te berekenen op basis van cyclomatische complexiteit ( $C$ ), nesting diepte ( $D$ ), aantal functie-aanroepen ( $F$ ) en functielengte ( $L$ ), gewogen als: $Score = D \times 3 + F \times 2 + C \times 1 + L \times 0.5$ .
Gold Label Generatie: Testgevallen worden uitgevoerd op de geanonimiseerde code om de grondwaarheid-outputs en state tracker-waarden te genereren.

Benchmarks en Trainingssets

Met behulp van LogicIFGen hebben de auteurs twee primaire datasets geconstrueerd:

LogicIFEval: Een benchmark bestaande uit 426 verifieerbare, door mensen gecontroleerde instructies afgeleid van uitdagende simulatieproblemen uit competitieve programmering (CodeForces en POJ). Het bevat 3.050 testgevallen en is gestratificeerd in Easy, Medium en Hard moeilijkheidsgraden.
LogicIFTrain: Een volledig gesynthetiseerde trainingsset met 27.324 verifieerbare instructies die een breed spectrum aan logische complexiteiten beslaat, afgeleid van de code_contests dataset.

Evaluatieprotocol

Modellen worden geëvalueerd op hun vermogen om zowel de correcte uiteindelijke output als de correcte state tracker-waarden voor alle bijbehorende testgevallen te produceren. Cruciaal is dat modellen verboden zijn om code te schrijven of externe tools te gebruiken; ze moeten de logica puur door tekstgeneratie uitvoeren. De evaluatie maakt onderscheid tussen "Thinking" modellen (die een expliciete redeneerspoor genereren) en "NoThinking" (NT) modellen.

Belangrijkste Bijdragen

LogicIF Taakdefinitie: Het artikel definieert formeel Logic Instruction Following (LogicIF), een taak die vereist dat modellen elke logische stap in complexe instructies simuleren, wat het onderscheidt van traditionele constraint-gebaseerde instructie-opvolging.
LogicIFGen Framework: Een nieuw, geautomatiseerd framework voor het genereren van verifieerbare, logica-rijke instructies vanuit code, voorzien van state trackers om de tussenliggende logische flow te superviseren en hallucinatie van resultaten te voorkomen.
LogicIFEval Benchmark: Een rigoureuze benchmark van 426 complexe taken met menselijke verificatie (97,79% inter-annotator overeenstemming), die aantoont dat huidige state-of-the-art modellen aanzienlijk moeite hebben met hoge complexiteit in de logica.
LogicIFTrain en RLVR: Een grootschalige trainingsdataset en de demonstratie dat Reinforcement Learning from Verifiable Rewards (RLVR) op deze data de prestaties van modellen aanzienlijk verbetert.

Experimentele Resultaten

Prestaties op LogicIFEval

Experimenten op 21 frontier LLM's onthullen significante tekortkomingen in het opvolgen van logische instructies:

Algemene Prestaties: De meeste modellen behalen minder dan 60% nauwkeurigheid. Het best presterende model, gpt-5, behaalt 84,98% (gemeten aan de hand van de intersectie van correcte outputs en state trackers).
Open-Source Kloof: Open-source modellen blijven aanzienlijk achter bij propriëtaire modellen. Zo scoren Qwen3-32B-NT, Gemma-3-27B en Llama-3.3-70B onder de 10%.
Thinking Modellen: Modellen die expliciete denkprocessen integreren (bijv. Claude-4-Sonnet, o-series) presteren substantieel beter dan hun non-thinking tegenhangers (bijv. Claude-4-Sonnet-NT verbetert van 43,9% naar 69,72%).
Complexiteit Correlatie: Prestaties nemen af naarmate de logische complexiteit toeneemt. Bijvoorbeeld, gpt-5 daalt van 90,85% op Easy taken naar 74,10% op Hard taken.
State Tracking vs. Output: De output-nauwkeurigheid overtreft consequent de state tracker-nauwkeurigheid, wat suggereert dat modellen vaak de juiste antwoorden vinden via shortcuts of alternatieve logische paden in plaats van de bedoelde stappen getrouw te simuleren.

Foutanalyse

De auteurs identificeren vijf primaire foutmodi:

Control Flow Misexecution (CFM): Onjuiste loop-iteraties of branching (meest frequent in open-source modellen).
Instruction Misinterpretation (IM): Misinterpretatie van de intentie of hallucinatie van stappen.
State Tracking Errors (STE): Falen in het bijhouden van interne variabelen (counters, flags).
Missing Logic Elements (MLE): Weglating van vereiste componenten.
Misordered Execution (ME): Uitvoeren van stappen in de verkeerde volgorde.
Analyse toont een positieve correlatie tussen logische complexiteit en de frequentie van fouten, met name voor CFM en STE.

Trainingsresultaten

Het finetunen van Qwen3-1.7B op LogicIFTrain middels RLVR levert substantiële winst op:

In-Domain: +16,7 punten op LogicIFEval.
Out-of-Domain Generalisatie: Significante verbeteringen op diverse benchmarks, waaronder ZebraLogic (+31,4), HumanEval (+4,6), MATH-500 (+4,3) en GPQA-Diamond (+3,1).

Betekenis en Claims

Het artikel claimt dat LogicIF een fundamentele vaardigheid is die een breed scala aan geavanceerde cognitieve vermogens versterkt. De auteurs stellen dat het vermogen om precisie-rijke logische instructies op te volgen verschillend is van en complementair is aan algemene redeneer- of programmeervaardigheden.

Belangrijke claims zijn onder meer:

Huidige Beperkingen: Zelfs state-of-the-art LLM's hebben moeite met het getrouw uitvoeren van complexe, meerstaps logische instructies, wat wijst op een "substantiële tekortkoming" in deze specifieke capaciteit.
Waarde van State Trackers: Het superviseren van tussenliggende state variabelen is cruciaal om te verifiëren dat modellen de beoogde logica volgen in plaats van de uiteindelijke uitkomsten te raden.
Generalisatie: Trainen op logica-rijke instructies via RLVR verbetert niet alleen het opvolgen van instructies, maar fungeert ook als een "fundamentele boost" voor redeneren, coderen en algemene kennis-taken. Dit suggereert dat het beheersen van universele logische structuren (lussen, recursie, conditional statements) "atomaire operaties" biedt voor hogere orde cognitie.
Rol van 'Thinking': Expliciete denkprocessen lijken het opvolgen van instructies voor logica-rijke taken te verbeteren door doelbewuste, stapsgewijze simulatie te stimuleren in plaats van patroonherkenning.

De auteurs concluderen dat LogicIFGen en de bijbehorende benchmarks een noodzakelijk instrument bieden voor het evalueren en verbeteren van de logische getrouwheid van LLM's, waarbij de vrijgegeven data en modellen dienen als een bron voor toekomstig onderzoek in dit domein.