💻 computer science

Machine-Checked Arithmetic Bit Complexity of the Kannan-Bachem Smith Normal Form in Lean 4

Dit artikel presenteert een formalisering in Lean 4 van het Kannan-Bachem Smith normale vorm algoritme voor niet-singuliere gehele matrices, waarbij machine-gecontroleerde bewijzen van correctheid worden geleverd en vaste polynomiale grenzen worden vastgesteld voor zowel de rekenkundige bitcomplexiteit van de berekening als de omvang van de uitvoer.

Oorspronkelijke auteurs: Junye Ji (University of Washington)

Gepubliceerd 2026-07-27

📖 7 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Junye Ji (University of Washington)

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 meester-archivaris bent in een bibliotheek waar elk boek een gigantische, complexe puzzel is gemaakt van getallen. Soms moet je de pagina's van deze puzzels herschikken om een verborgen, eenvoudiger patroon eronder te vinden. Dit is de wereld van de lineaire algebra, een tak van de wiskunde die gaat over rasters van getallen (matrices) en hoe deze getransformeerd kunnen worden. Denk aan een matrix als een spreadsheet van gehele getallen. Net zoals je een slordige lijst met namen alfabetisch zou sorteren om een patroon te vinden, proberen wiskundigen deze getallenrasters te sorteren in een "Smith Normaalvorm"—een superzuivere, diagonale versie waarbij de getallen groter en groter worden naarmate je de lijn naar beneden volgt, en waarbij elk getal het volgende getal perfect deelt.

Maar hier komt de adder onder het gras: hoewel het sorteren van de getallen eenvoudig te beschrijven is, kan het daadwerkelijke rekenwerk een nachtmerrie zijn. Terwijl je de rijen en kolommen herschikt om ze op te schonen, kunnen de getallen binnenin zo enorm groot worden dat ze je computer laten crashen of dat het een miljoen jaar duurt om te berekenen. Decennialang wisten wiskundigen hoe ze deze rasters moesten sorteren (een methode genaamd het Kannan–Bachem-algoritme), maar ze hadden absolute zekerheid nodig dat het proces niet in een oneindige lus zou blijven hangen en dat de getallen niet uit de hand zouden lopen. Deze paper stapt in die leemte, niet alleen om te zeggen "het werkt," maar om een digitaal, onbreekbaar bewijs te bouwen dat het werkt, en om precies te tellen hoeveel "computationele energie" het kost om dit te doen.

De Digitale Dubbelcheck

In deze paper neemt Junye Ji van de University of Washington het Kannan–Bachem-algoritme—een slim recept voor het sorteren van integer matrices—en bouwt een machine-gecontroleerd bewijs hiervan met behulp van een tool genaamd Lean 4. Denk aan Lean 4 als een superstrikte, robotische bibliothecaris die een wiskundig bewijs weigert te accepteren, tenzij elke stap logisch waterdicht is. Als je probeert een "misschien" of een "het werkt waarschijnlijk wel" binnensluipen, slaat de robot de deur dicht. Ji schreef niet alleen de code; hij dwong de robot om te verifiëren dat de code altijd klaar is, nooit crasht en telkens het exacte juiste antwoord produceert.

Het doel was om te bewijzen dat voor elk vierkant raster van niet-nul gehele getallen, dit algoritme het in staat is om het te transformeren naar de zuivere, diagonale "Smith Normaalvorm", terwijl het ook de exacte stappen bijhoudt die zijn gemaakt om daar te komen. Het resultaat is niet alleen een "ja, het werkt"-notitie; het is een volledig, geverifieerd pakket dat het uiteindelijke gesorteerde raster bevat, de "voorwaartse" kaart van hoe je daar komt, en de "achterwaartse" kaart om terug te keren naar het origineel. Het is alsoam een schatkaart en een retourtje te hebben, beide geverifieerd door een robot om te garanderen dat je niet verdwaalt in het bos van gigantische getallen.

De "Pivot" Dans en de Krimpende Getallen

Het hart van het algoritme is een dans genaamd stabilisatie. Stel je voor dat je een rommelige kamer probeert te organiseren. Je kiest een specifieke plek op de vloer (de "pivot") en probeert alles anders in die rij en kolom te laten verdwijnen. Soms wordt de wiskunde rommelig en kun je niet alles perfect laten verdwijnen. Wanneer dat gebeurt, geeft het algoritme niet op; het voert een speciale beweging uit waarbij de huidige pivot wordt vervangen door een kleiner getal (een "proper divisor").

De paper bewijst een cruciaal feit: elke keer dat deze speciale beweging plaatsvindt, wordt het aantal bits (de binaire "grootte") van de pivot strikt kleiner. Het is als een spel waarbij je een zware steen mag inruilen voor een lichter kiezelsteentje, en je kunt nooit een kiezelsteen inruilen voor een zwaardere steen. Omdat je niet eeuwig kleiner kunt blijven maken (je komt uiteindelijk bij nul uit), moet het spel eindigen. De auteurs bewezen dat deze "afdaling" gegarandeerd is, wat betekent dat het algoritme nooit in een oneindige lus terecht zal komen.

De Kosten Tellen: De "Trace"

Een van de meest opwindende delen van dit werk is hoe ze de kosten hebben geteld. Meestal, wanneer we zeggen dat een algoritme "snel" is, bedoelen we misschien dat het een paar seconden duurt. Maar hier wilden de auteurs de exacte rekenkundige kosten weten in termen van binaire operaties. Ze creëerden een "flat trace", wat een soort bonnetje is dat elke enkele kleine wiskundige operatie (optelling, vermenigvuldiging, deling) opsomt die de computer heeft uitgevoerd.

Ze bewezen dat de totale kosten van dit bonnetje groeien met een polynomiale snelheid. In gewone mensentaal betekent dit dat zelfs als je input-matrix enorm groot wordt, de tijd die nodig is om het op te lossen niet naar oneindig explodeert; het zal op een voorspelbare, beheersbare manier groeien. Ze hebben zelfs de specifieke "graad" van deze groei berekend. De paper onthult dat de kosten begrensd worden door een polynoom met een graad van 2.150.687 (voor het uitgevoerde werk) en 98.990 (voor de grootte van de output).

Nu lijken die getallen angstaanjagend groot, maar de auteurs leggen heel zorgvuldig uit wat ze betekenen. Dit zijn geen "scherpe" exponenten (zoals zeggen dat het precies $n^2$ stappen kost); het zijn conservatieve getuigen. Zie ze als een veiligheidsmarge. Als je een brug bouwt, bereken je misschien dat deze 100 ton moet kunnen dragen, maar je ontwerpt hem om 1.000 ton te dragen, gewoon voor de zekerheid. Deze enorme getallen zijn de "1.000 ton" van de wiskundige wereld—garanties dat het algoritme veilig en efficiënt is, zelfs als de prestaties in de echte wereld veel beter zijn.

Wat is Er Buiten Gelaten?

Het is belangrijk om te weten wat deze paper niet heeft gedaan. De auteurs waren zeer specifiek over de grenzen van hun bewijs. Ze telden alleen de rekenkundige operaties (de wiskunde zelf). Ze hebben niet geteld hoe lang het duurt voor de computer de gegevens in het geheugen laadt, de tijd die het kost om de resultaten te printen, of de overhead van de programmeertaal zelf. Ze hebben ook niet bewezen dat dit de snelste manier is om matrices te sorteren; ze hebben alleen bewezen dat deze specifieke manier veilig is, gegarandeerd klaar is, en niet meer middelen gebruikt dan hun berekende polynomiale limieten.

Het Eindoordeel

Dus, wat is de kernboodschap? Deze paper is een triomf van formele verificatie. Het neemt een complex, decennia-oud wiskundig recept en legt het voor aan een robot om elke stap te controleren. De robot bevestigt dat het recept altijd werkt, altijd klaar is en nooit getallen creëert die zo groot zijn dat ze het systeem breken. Het biedt een "certificaat" van juistheid dat de gesorteerde matrix, de transformatiemappen en een wiskundig bewezen garantie bevat over hoeveel werk het kostte om daar te komen.

Voor een nieuwsgierige tiener is dit als het kijken naar iemand die een robot bouwt die niet alleen een Rubik's Cube oplost, maar ook een juridisch contract schrijft waarin staat dat de robot nooit vast zal komen te zitten, de kubus nooit zal breken en dit binnen een specifiek aantal zetten zal doen, ongeacht hoe verwarrend de kubus begint te zijn. Het verandert een "misschien" in de wiskunde in een "zekerheid", geverifieerd door de strengste rechter die men zich kan voorstellen.

Technische Samenvatting: Machine-gecontroleerde rekenkundige bitcomplexiteit van de Kannan–Bachem Smith Normaalvorm in Lean 4

Probleemstelling
Het artikel behandelt de formele verificatie van het Kannan–Bachem-algoritme voor het berekenen van de Smith normaalvorm (SNF) van niet-singulaire vierkante gehele matrices. Hoewel de existentie van de SNF een standaardresultaat is in de algebra, ligt de algoritmische uitdaging in het beheersen van de tussenliggende coëfficiëntgroei. Standaard Gaussische eliminatie of GCD-gebaseerde methoden kunnen gehele getallen produceren met een exponentiële bitlengte ten opzichte van de invoergrootte. De Kannan–Bachem-procedure (1979) biedt een polynoomtijd-oplossing door af te wisselen tussen Hermite normaalvorm-fasen en de binaire grootte van de actieve pivot strikt te verkleinen bij mislukkingen van deelbaarheid. Het specifieke probleem dat hier wordt aangepakt, is de machine-gecontroleerde verificatie van de correctheid van dit algoritme, de terminatie ervan, en de rekenkundige bitcomplexiteit binnen de Lean 4 proof assistant, inclusief de generatie van expliciete certificaten (het transformeren van matrices en hun inversen) en een geverifieerd kostenmodel.

Methodologie
De auteurs formaliseren het algoritme in Lean 4 met behulp van de mathlib-bibliotheek. De aanpak maakt onderscheid tussen structurele operaties (matrixindexering, lijstmanipulatie) en rekenkundige primitieven (optelling, vermenigvuldiging, deling op teken-magnitude gehele getallen).

Gereinstrumenteerde Executie: Het algoritme wordt geïmplementeerd als een "waarde-producerende geïnstrumenteerde executie". Elke rekenkundige operatie geeft een "plat spoor" (flat trace) uit van aangewezen bladeren (bijv. GCD, quotiënt/rest, groottevergelijkingen). Deze sporen registreren de exacte operanden en de kosten van de operatie, waardoor de totale kosten in een enkele waarde kunnen worden samengevoegd.
Zelf-begrenzende Codecs: Invoer- en uitvoermatrices worden gecodeerd met geverifieerde prefix-vrije codecs. De uitvoer bestaat uit vijf matrices: de Smith-vorm $S$ , de unimodulaire vermenigvuldigers $U$ en $V$ , en hun inversen $U^{-1}$ en $V^{-1}$ . De coderinglengte wordt gedefinieerd als het aantal bits in een teken-magnitude representatie, inclusief framing-bits.
Recursieve Structuur:
- Preparatie: Zorgt ervoor dat de leidende hoofdminoren niet nul zijn met behulp van Birds delingvrije determinant-algoritme.
- Stabilisatie: Een recursieve functie stabilizeFrom die de eerste kolom en rij leegt. Dit steunt op een "pivot-descent" argument: als een deelbaarheidstest faalt, vindt het algoritme een juiste deler, waarbij de binaire grootte van de pivot strikt afneemt.
- Uiterlijke Recursie: Zodra de eerste rij en kolom zijn geleegd en de pivot de resterende blok verdeelt, recurreert het algoritme op de lager-rechts gelegen $(n-1) \times (n-1)$ submatrix.
Kostenanalyse: De complexiteitsanalyse is losgekoppeld van de Lean-runtime. Het theorem begrenst de "rekenkundige kosten" (som van de kosten van primitieve bladeren) en de "output coderinglengte" (bits vereist om de vijf matrices te serialiseren).

Belangrijkste Bijdragen

Formalisering van Kannan–Bachem: Een volledige formalisering van het 1979-algoritme, inclusief de constructie van de transformerende matrices $U, V$ en hun inversen, wat tweerichtingsverificatie van de equivalentie $UAV = S$ mogelijk maakt.
Geverifieerde Rekenkundige Kosten: Het artikel bewijst dat de totale rekenkundige kosten en de outputgrootte begrensd zijn door vaste polynomen van de invoergrootte. In tegen tegenstelling tot eerdere formalisaties die zich wellicht richten op algebraïsche correctheid of operatietellingen, volgt dit werk expliciet de bitcomplexiteit via een "polynoom-envelop calculus".
Expliciete Getuigen: De formalisering produceert concrete, machine-gecontroleerde constanten voor de polynoomgrenzen. De graad van de kostenpolynoom is geverifieerd als $d_c = 2.150.687$ en de graad van de outputcodering als $d_o = 98.990$ . De coëfficiënten zijn $C_c = 2^{d_c}$ en $C_o = 2^{d_o}$ . De auteurs merken op dat dit conservatieve getuigen zijn afgeleid van generieke afsluitingsregels, en geen scherpe exponenten.
Trace-uitlijning: Een rigoureus bewijs dat de geïnstrumenteerde executie (gebruikt voor kostenanalyse) definitioneel gelijk is aan de zuivere wiskundige functie, wat garandeert dat de kostenanalyse direct van toepassing is op het logische gedrag van het algoritme.

Resultaten
Het hoofddocument (Theorem 2.1) stelt vast dat voor elke niet-singulaire $n \times n$ gehele matrix $A$ :

Het algoritme termineert en $S, U, U^{-1}, V, V^{-1}$ teruggeeft.
De teruggegeven matrices voldoen aan de voorwaartse en achterwaartse transformatievergelijkingen ($UAV=S$, $U^{-1}SV^{-1}=A$ ) en de inverse identiteiten.
$S$ is in Smith normaalvorm en is gelijk aan een canonieke referentiematrix gedefinieerd in de bibliotheek.
De rekenkundige kosten worden begrensd door $C_c (|encmat(A)| + 1)^{d_c}$ .
De gecodeerde outputlengte wordt begrensd door $C_o (|encmat(A)| + 1)^{d_o}$ .

De terminatie wordt bewezen via een wel-gegronde relatie op de binaire grootte van de actieve pivot ($Nat.size(|pivot|)$), die bij elke recursieve daling strikt afneemt.

Significantie
Het artikel claimt significantie door een verenigde verificatie te bieden van een uitvoerbaar geheel getal-reductie-algoritme, zijn inverse certificaten, en de rekenkundige kosten binnen één enkel formeel framework. Terwijl Coq en Isabelle ontwikkelingen de existentie van SNF hebben bewezen in bredere algebraïsche contexten, richt dit werk zich specifiek op de casus van vierkante gehele matrices om de efficiëntie en correctheid van een specifieke, uitvoerbare implementatie (Kannan–Bachem) te verifiëren. De methodologie wordt gepresenteerd als een precedent voor het verifiëren van efficiënte gehele implementaties en polynoomtijd-analyse, waarbij een parallel wordt getrokken met de geverifieerde LLL-algoritme in Isabelle/HOL. Het werk demonstreert dat machine-gecontroleerde bitcomplexiteitsanalyse, inclusclusief de generatie van expliciete polynoomgrenzen met concrete coëfficiënten, haalbaar is voor niet-triviale lineaire algebra-algoritmen.

De Digitale Dubbelcheck

De "Pivot" Dans en de Krimpende Getallen

De Kosten Tellen: De "Trace"

Wat is Er Buiten Gelaten?

Het Eindoordeel

Meer zoals dit