Effectiveness of LLM-based Software Diversity for Reliability Improvement -- an Empirical Study

Titel: Effectiviteit van op LLM gebaseerde software-diversiteit voor betrouwbaarheidsverbetering – een empirische studie

Probleemstelling
Software-diversiteit is een gevestigde strategie voor het verminderen van common-mode fouten in fouttolerante systemen, met name door middel van N-versie programmeren (NVP). Traditionele diversiteit is echter kostbaar, omdat het meerdere onafhankelijke menselijke implementaties, validatie en onderhoud vereist. Hoewel Large Language Models (LLM's) een schaalbare, goedkope methode bieden voor het genereren van diverse code-implementaties, blijft het onduidelijk of door LLM gegenereerde programma's de noodzakelijke fout-diversiteit vertonen om de systeembetrouwbaarheid te verbeteren. Specifiek is het onbekend of LLM's gecorreleerde fouten introduceren die vergelijkbaar zijn met die van menselijke ontwikkelaars, of dat ze complementaire foutprofielen bieden die kunnen worden benut voor betrouwbaaringswinsten.

Methodologie
De auteurs voerden een empirische studie uit waarbij historische, door mensen geschreven programma's werden vergeleken met grote pools van door LLM gegenereerde code over drie specificaties: 3n+1, Factors and Factorials en Factovisors.

• Datasets:
  • Menselijke baseline: Programma's afkomstig uit de UVa Online Judge repository, ontwikkeld vóór de alomtegenwoordigheid van LLM's om een contaminatievrije baseline te garanderen.
  • LLM-generatie: Grote pools van code gegenereerd met behulp van 14 moderne LLM's (5 commerciële API's en 9 lokale open-weight modellen) over vier programmeertalen (C, C++, Java, Pascal) en vijf temperatuurinstellingen (0,5 tot 1,5).
• Evaluatiekader:
  • De programma's werden gecompileerd en uitgevoerd in een gesandboxed omgeving tegen uitgebreide testsuites.
  • Filtering: Programma's die niet konden compileren, crashten of alle testgevallen faalden (PFD=1), werden uitgesloten. Alleen geldige programma's (Perfect of Partial) werden behouden.
  • Metrieken: Betrouwbaarheidsverbetering werd gemeten met de betrouwbaarheidsverbeteringsratio ($R$), gedefinieerd als de gemiddelde Probability of Failure on Demand (PFD) van individuele programma's gedeeld door de gemiddelde PFD van 1-uit-2 paren.
  • Configuraties: De studie analyseerde:
    1. Homogene paren: Getrokken uit dezelfde populatie (bijv. mens-mens of LLM-LLM).
    2. Heterogene paren: Getrokken uit verschillende populaties (bijv. verschillende talen, of mens-LLM).
    3. Cross-source: Specifiek het paren van door mensen geschreven programma's met door LLM gegenereerde programma's.

Belangrijkste bijdragen

1. Eerste toepassing van klassieke kaders op LLM-code: Dit is de eerste studie die de klassieke Eckhardt-Lee (EL) en Littlewood-Miller (LM) betrouwbaarheidsanalyse-kaders toepast op grote populaties van door LLM gegenereerde code, en deze direct vergelijkt met historische, door mensen geschreven baselines.
2. Systematische karakterisering van LLM-diversiteit: De studie karakteriseert de door LLM gegenereerde diversiteit over controleerbare dimensies (modelfamilie, temperatuur, programmeertaal) en kwantificeert hun impact op betrouwbaaringswinsten.
3. Analyse van Mens-LLM heterogeniteit: Het biedt een eerste empirisch beeld van de vraag of LLM's bestaande menselijke foutpatronen reproduceren of complementaire diversiteit bieden wanneer ze met menselijke code worden gepaard.

Resultaten

• Homogene betrouwbaarheid: Door LLM-gegenereerde programma's leveren over het algemeen hogere betrouwbaarheidsverbeteringen op in het hoog-betrouwbare spectrum (bijv. voor 3n+1, bereikten LLM's een ~11.500x verbetering bij PFD $10^{-7}$ versus ~1.900x voor mensen). Echter, net als menselijke programma's, zijn LLM-programma's niet fout-onafhankelijk; hun betrouwbaarheidscurves blijven begrensd door de theoretische onafhankelijkheidslijn, wat wijst op inherente foutcorrelatie.
• Taaldiversiteit: Het dwingen van LLM's om code in verschillende talen te genereren, verhoogt de betrouwbaaringswinsten aanzienlijk. Heterogene LLM-koppelingen (bijv. C++ en Java) presteren vaak beter dan menselijke taal-diversiteit, waardoor de empirische metingen dichter bij de strikte onafhankelijkheidsgrens komen.
• Cross-source (Mens-LLM) diversiteit:
  • Afgedwongen heterogeniteit: De meest significante betrouwbaaringswinsten werden behaald door een strikte heterogene architectuur af te dwingen (één menselijk programma gekoppeld aan één door LLM gegenereerd programma). Deze configuratie presteerde consequent beter dan zowel pure menselijke als pure LLM baselines.
  • Negatieve correlatie: In specifieke gevallen (bijv. 3n+1 bij bepaalde drempelwaarden) kruiste de afgedwongen mens-LLM koppeling de theoretische onafhankelijkheidslijn, wat duidt op negatieve foutcorrelatie waarbij de twee bronnen elkaars zwakheden actief compenseren.
  • Verschillen in Model Tier: Het koppelen van mensen aan Commerciële LLM's bood over het algemeen robuuste betrouwbaaringsverbeteringen. Het koppelen van mensen aan kleinere Lokale modellen leverde soms mathematisch extreme verbeteringsfactoren op (bijv. >2,9 miljoen), maar de auteurs merken op dat dit vaak misleidend is, gedreven door de hoge foutmarge van het lokale model in plaats van echte complementaire diversiteit.
• Temperatureffecten: Het verhogen van de generatietemperatuur verhoogde de diversiteit binnen de LLM-pool (wat de homogene LLM-koppelingen verbeterde), maar had geen invloed op de heterogene cross-source betrouwbaarheid, wat suggereert dat temperatuur de distributie van AI-fouten verandert maar de fundamentele cognitieve kloof tussen AI en menselijk redeneren niet overbrugt.

Betekenis en Claims
Het artikel claimt dat LLM's een schaalbare, goedkope bron zijn van heterogene programma's waarvan de diversiteit kan worden ingezet voor betrouwbaarheidsverbetering. De auteurs benadrukken echter dat LLM's de klassieke uitdaging van gecorreleerde softwarefouten niet elimineren. In plaats daarvan bieden ze een nieuw mechanisme om diversiteit te induceren.

De studie concludeert dat de meest effectieve architecturale strategie voor betrouwbaarheid niet simpelweg het poolen van menselijke en AI-outputs is, maar het afdwingen van structurele heterogeniteit (bijv. het paren van een door mens geschreven component met een door LLM gegenereerde component). Deze aanpak kan betrouwbaaringswinsten opleveren die zowel de pure menselijke als de pure AI baselines overtreffen, en in sommige gevallen zelfs negatieve foutcorrelatie bereikt. De bevindingen suggereren dat LLM's multi-versie softwareontwikkeling kunnen ondersteunen door de systematische generatie en evaluatie van heterogene programma's praktisch te maken.

Bedreigingen voor de Validiteit
De auteurs erkennen dat de menselijke corpus bestaat uit competitieve programmeeroplossingen uit een pre-LLM tijdperk, wat mogelijk niet volledig representatief is voor moderne "geaugmenteerde" ontwikkeling. Daarnaast zijn de testsuites specifief voor taken binnen competitief programmeren, en de resultaten zijn afhankelijk van deze specifieke moeilijkheidsgraden. De studie merkt ook op dat LLM's tijdens de training blootgesteld kunnen zijn aan vergelijkbare specificaties, hoewel de specifieke menselijke corpus die in de geanalyseerde vorm werd gebruikt, niet publiek was.