💻 computer science

Synchronization-Free Algebraic Fingerprints for Large Language Models: From Autoregressive to Diffusion Models

Dit artikel stelt een nieuw, synchronisatievrij watermerkingsschema voor voor Large Language Models dat geheime identiteiten in tokensparen inbedt met behulp van Reed-Solomon-polynomen en binaire congruenties, wat robuuste attributie mogelijk maakt die bestand is tegen bewerking, parafrasering en token-herordening zonder dat bloksynchronisatie vereist is.

Oorspronkelijke auteurs: Jaroslaw Janas, Josef Pieprzyk, Pawel Morawiecki

Gepubliceerd 2026-07-21

📖 7 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Jaroslaw Janas, Josef Pieprzyk, Pawel Morawiecki

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 geheim handtekening wilt achterlaten op een verzameling zandkastelen die zijn gebouwd door een zeer getalenteerde, maar lichtelijk ondeugende robot. Deze robot is een Artificial Intelligence (AI) die verhalen schrijft, vragen beantwoordt en code creëert. Het probleem is dat de robot zo goed is in het kopiëren van de menselijke stijl dat het onmogelijk is om te zien of een verhaal door een mens of door de machine is geschreven. Erger nog, als iemand probeert het verhaal te "verbeteren" — door een zin te verwijderen, een grap toe te voegen of de paragrafen te herschikken — wordt de geheime handtekening meestal uitgewist, net als een voetstap in het zand wanneer het tij binnenkomt.

Wetenschappers hebben geprobeerd dit op te lossen door onzichtbare codes in de tekst te stempelen, maar de meeste van hun methoden zijn als een lange, fragiele ketting van paperclips. Als je één paperclip eruit trekt (een verwijderd woord) of een nieuwe toevoegt (een ingevoegd woord), breekt de hele ketting en gaat de geheime boodschap verloren. Dit nieuwe papier introduceert een totaal andere manier om over het probleem na te denken. In plaats van een fragiele ketting, stel je je een veld van duizenden kleine, onafhankelijke vuurvliegjes voor. Elk vuurvliegje draagt een klein stukje van een geheime code. Als een storm (een redacteur) de helft van de vuurvliegjes wegblaast, of als ze in een andere volgorde vliegen, kun je de geheime boodschap nog steeds ontcijferen omdat je ze niet allemaal in een lijn nodig hebt; je hebt er slechts een paar nodig die er zijn. De onderzoekers laten zien dat je, door wiskundige trucs te gebruiken met behoud van polynomen (denk aan geheime recepten voor getallen) en tekstbewerking te behandelen als een spel van kansen, de geheime identiteit van de AI kunt herstellen, zelfs nadat de tekst zwaar is bewerkt.

Het Probleem: De "Ketting" versus de "Wolk"

Al een tijdje proberen onderzoekers AI-tekst te watermerken door de geheime boodschap in een strikte sequentie te organiseren, zoals kralen aan een snoer. Ze zouden zeggen: "Het eerste woord krijgt een geheim kenmerk, het tweede woord krijgt het volgende kenmerk, enzovoort." Dit werkt prima totdat iemand de tekst bewerkt. Als je het eerste woord verwijdert, wordt het tweede woord plotseling het "eerste" en raakt de hele geheime code door elkaar. Het is also als proberen een boek te lezen waarbij iemand pagina 5 eruit heeft gescheurd; plotseling wordt pagina 6 pagina 5, en het verhaal maakt geen zin meer. Dit wordt een "synchronisatieprobleem" genoemd. De detector (de persoon die het watermerk controleert) raakt in de war omdat de volgorde van de aanwijzingen is veranderd.

De auteurs van dit artikel stellen dat deze "ketting"-benadering fundamenteel gebrekkig is voor tekst die bewerkt kan worden. Ze stellen een radicale verschuiving voor: vertrouw helemaal niet meer op de volgorde. In plaats van een ketting stellen ze een "wolk" van onafhankelijke aanwijzingen voor.

De Oplossing: Onafhankelijke Vuurvliegjes en Geheime Recepten

De kern van dit artikel is een "synchronisatievrij" watermerk. Zo werkt het, gebruikmakend van de analogie van een geheim recept en een paar buren.

Stel je voor dat de AI een verhaal schrijft, woord voor woord. De onderzoekers stellen voor dat voor elk paar naburige woorden (laten we ze "Woord A" en "Woord B" noemen), het systeem een geheim "recept" (een wiskundig polynoom) controleert om te beslissen welke "smaak" Woord B moet hebben.

Het Geheime Recept: De eigenaar van de AI heeft een geheime identiteit (zoals een 32-bits of 128-bits getal). Zij veranderen dit getal in een wiskundige formule.
De Buren: Voor elk paar woorden kijkt het systeem naar het eerste woord om een specif으로 "testpunt" op de formule te kiezen.
De Beslissing: De formule geeft een resultaat. Als het resultaat "even" is, moet het tweede woord een "Type 1" woord zijn (zoals een zelfstandig naamwoord). Als het resultaat "oneven" is, moet het tweede woord een "Type 2" woord zijn (zoals een werkwoord).
De Magie: Het cruciale deel is dat de beslissing voor Woord B alleen afhangt van Woord A en het geheime recept. Het maakt niet uit wat er vóór Woord A gebeurde of wat er na Woord B gebeurt.

Omdat elk paar woorden een op zichzelf staand "vuurvliegje" is, maakt het niet uit of je Woord A verwijdert, een nieuw woord tussen hen in plaatst, of de hele paragraaf herschikt. De resterende paren bevatten nog steeds hun eigen onafhankelijke aanwijzingen. Als je genoeg paren over hebt, kun je het oorspronkelijke geheime recept wiskundig reconstrueren, zelfs als de tekst zwaar is gehakt en herschikt.

Hoe Ze Bewijzen Dat Het Werkt

De auteurs hebben niet alleen geraden dat dit zou werken; ze hebben een wiskundig model gebouwd om het te bewijzen. Ze behandelden het proces van tekstbewerking (woorden verwijderen, woorden veranderen) als een "Binary Symmetric Channel". In gewone taal betekent dit dat ze elke bewerkingsfout behandelden als een eenvoudige muntworp: of de aanwijzing is correct, of hij is naar het verkeerde antwoord "geflippt".

Ze voerden de berekeningen uit om te zien hoeveel aanwijzingen (woordparen) ze nodig hebben om het geheim te herstellen.

Het Resultaat: Ze ontdekten dat je maar heel weinig "extra" tekst nodig hebt. Zelfs als de tekst zwaar is bewerkt (tot 30% van de aanwijzingen zijn fout of ontbreken), heb je slechts een paar extra zinnen nodig om een 32-bits geheim code met 99% zekerheid te herstellen.
De Analogie: Als je probeert een 32-bits wachtwoord te raden door munten te werpen, en je krijgt 30% van de worpen fout, dan zou je normaal gesproken vastlopen. Maar omdat hun wiskunde gebruikmaakt van een speciaal type code (Reed-Solomon), is het alsof je een magische decoderring hebt die die foutieve worpen kan herstellen, zolang je maar genoeg totale worpen hebt.

Ze hebben ook getest hoe ze zeer lange geheimen (zoals 128 bits) kunnen afhandelen. Ze ontdekten dat als ze het grote geheim in kleinere stukken (fragmenten) opdelen en elk stukje als zijn eigen onafhankelijke wolk van vuurvliegjes behandelt, ze het hele ding kunnen herstellen zonder een enorme hoeveelheid tekst nodig te hebben.

Wat Betreft Andere Typen AI?

Het artikel kijkt ook naar een nieuwer type AI genaamd "Diffusion Models". In tegen tegenstelling tot standaard AI die woord voor woord van links naar rechts schrijft (als een typist), beginnen diffusiemodellen met een rommelige, verwarde zin en maken deze langzaam schoner, zoals een beeldhouwer die steen weghakt om het beeld te vinden.

De auteurs realiseerden zich dat hun "onafhankelijke vuurvliegjes"-methode hier ook perfect werkt. Ze stelden drie verschillende manieren voor waarop de AI zich aan het watermerk kan "verbinden" (commit) terwijl het de tekst opschoont:

Basic Commit: De AI legt een woord vast zodra het aan de regel van de linkerbuur voldoet. Dit is snel, maar als het een fout maakt, kan het die niet meer herstellen.
Refined Commit: De AI controleert beide buren. Als één buur "ja" zegt en de andere "nee", kan de AI van gedachten veranderen over de buur om de fout te herstellen. Dit is slimmer maar kost wat meer tijd.
Sliding Commit: De AI behandelt de grens tussen "vastgelegde" en "niet-vastgelegde" woorden als een schuifdeur. Het beweegt de deur heen en weer totdat alles perfect past. Dit is het meest robuust, maar duurt het langst.

Hun simulaties suggereren dat voor standaard AI, de "Basic" methode snel genoeg is. Voor diffusiemodellen biedt de "Refined" methode een goede balans door fouten gaande in het proces te herstellen.

De Kernboodschap

Dit artikel suggereert een nieuwe manier om AI-tekst te labelen die extreem moeilijk te breken is. In tegen tegenstelling tot eerdere methoden die uit elkaar vallen wanneer de tekst wordt bewerkt, overleeft deze methode verwijderingen, invoegingen en herschikkingen omdat elke aanwijzing op zichzelf staat. De auteurs tonen door middel van wiskunde en simulaties aan dat je de geheime identiteit van de AI met hoge zekerheid kunt herstellen, zelfs als de tekst zwaar is bewerkt. Ze bieden ook een routekaart voor hoe dit geïmplementeerd kan worden in zowel standaard tekstgeneratoren als de nieuwere, complexere diffusiemodellen.

Hoewel ze niet beweren dat ze elk mogelijk probleem hebben opgelost (ze merken op dat toekomstig werk naar complexere bewerkingspatronen kan kijken), hebben ze een sterk, wiskundig bewezen kader geleverd dat watermarking veel betrouwbaarder maakt dan voorheen. Het is een verschuiving van het bouwen van een fragiele ketting naar het creëren van een veerkrachtige wolk van aanwijzingen.

Technische Samenvatting: Synchronisatievrije Algebraïsche Fingerprints voor Large Language Models

1. Probleemstelling

De brede inzet van Large Language Models (LLM's) heeft een dringende behoefte gecreëerd aan betrouwbare watermarking-methoden om gegenereerde tekst toe te schrijven, verantwoording af te leggen en misbruik te detecteren. Bestaande watermarking-schema's voor LLM's vallen over het algemeen in de categorieën statistisch, lexicaal, syntactisch of cryptografisch. Echter, een fundamentele beperking van de meeste huidige benaderingen is hun synchronisatieafhankelijkheid. Deze methoden embedden watermerkbits doorgaans sequentieel of binnen vaste blokgroottes, waarbij ze vertrouwen op de precieze positionele volgorde van tokens. Bijgevolg vernietigen veelvoorkomende bewerkingen—zoals invoegingen, verwijderingen, parafrasering of zinsherordening—de uitlijning tussen de encoder en decoder, waardoor het watermerk onherstelbaar wordt. Het artikel identificeert de ontwikkeling van synchronisatievrije watermarking-technieken die in staat zijn tot betrouwbare detectie na willekeurige tekstbewerking als een belangrijk openstaand probleem in het vakgebied.

2. Methodologie

De auteurs stellen een nieuw watermarking-framework voor dat de noodzaak voor expliciete token-uitlijning tijdens herstel elimineert. De kerninnovatie is een algebraïsch fingerprinting-schema gebaseerd op Reed–Solomon-codes, waarbij elke watermerkbit onafhankelijk wordt ingebed in een paar naburige tokens.

2.1 Algebraïsch Framework

Identiteitsrepresentatie: Een geheime identiteit $S$ wordt gerepresenteerd als een $n$ -bits binaire vector, die wordt toegewezen aan een polynoom $f_S(x)$ van graad ten hoogste $n-1$ over een eindig veld $\mathbb{F}_q$ (waarbij $q > 2^n$ een oneven priemgetal is).
Binaire Fingerprint: In plaats van de volledige veldwaarde $f_S(\alpha)$ te verzenden, extraheert het schema een enkele binaire observatie: de pariteit van de evaluatie, $\phi_S(\alpha) = f_S(\alpha) \pmod 2$ .
Embeddingsmechanisme: Voor elk opeenvolgend tokenpaar $(t_i, t_{i+1})$ $(t_{i}, t_{i + 1})$ :
1. Het eerste token $t_i$ bepaalt een uniek evaluatiepunt $\alpha_i = H(K, \text{id}(t_i)) \pmod q$ , waarbij $H$ een cryptografische hashfunctie is en $K$ een geheime sleutel.
2. De watermerkbit $w_i = \phi_S(\alpha_i)$ wordt berekend.
3. Het tweede token $t_{i+1}$ wordt gegenereerd (of bevooroordeeld) om tot een specifieke tokenklasse te behoren (bijv. "groen" of "rood") die overeenkomt met de bitwaarde $w_i$ .
Onafhankelijkheid: Omdat elke bit alleen afhangt van het lokale tokenpaar en de geheime sleutel, is de embedding van één bit niet afhankelijk van de positie of staat van voorgaande bits.

2.2 Herstel en Decodering

Herstel vereist niet dat de tokens in hun oorspronkelijke volgorde staan. De detector verzamelt een set overlevende tokenparen, herberekent de evaluatiepunten $\alpha_j$ met behulp van de geheime sleutel, en observeert de corresponderende bits $\hat{w}_j$ . Het doel is om de unieke identiteit $S$ te vinden waarvoor geldt dat $\phi_S(\alpha_j) = \hat{w}_j$ voor alle geobserveerde paren.

Algoritmen: Het artikel stelt drie herstelalgoritmen voor op basis van de grootte van de identiteit:
1. Exhaustieve Zoektocht: Voor kleine $n$ ( $n \lesssim 20$ ).
2. Meet-in-the-Middle: Voor gematigde $n$ ( $20 < n \le 60$ ), wat de complexiteit vermindert van $O(2^n)$ naar $O(2^{n/2})$ .
3. Fragmentatie: Voor grote identiteiten wordt het geheim gesplitst in onafhankelijke fragmenten, wat parallel herstel van kleinere subproblemen mogelijk maakt.

2.3 Modellering van Corruptie

De auteurs modelleren het watermarking-proces als een Binary Symmetric Channel (BSC). Zij stellen dat invoegingen, verwijderingen, substituties en embedding-onvolkomenheden allemaal geabstraheerd kunnen worden naar een enkele crossover-kans $p$ .

Invoegingen/Verwijderingen: In tegen tegen blokgebaseerde schema's, waarbij een enkele verwijdering alle daaropvolgende bits verschuift, zorgt een invoeging of verwijdering hier slechts voor het verwijderen of toevoegen van specifieke onafhankelijke observaties. De kans op een niet-gedetecteerde bewerking is ongeveer $1/4$ , wat betekent dat de meeste bewerkingen detecteerbare inconsistenties introduceren.
Herstelwaarschijnlijkheid: De kans op succesvol herstel hangt uitsluitend af van het aantal overlevende correcte observaties $r$ . Als $r \ge n + \lambda$ , is de faalkans begrensd door $2^{-\lambda}$ .

2.4 Extensie naar Diffusiemodellen

Het framework wordt uitgebreid naar Diffusion Language Models (DLM's), die tekst iteratief genereren in plaats van autoregressief. De auteurs stellen drie "Commit Algoritmen" voor om watermerkbeperkingen af te dwingen tijdens het denoising-proces:

Basic Commit: Committeert een token als de linkerbeperking wordt voldaan.
Refined Commit: Committeert op basis van linkerbeperkingen, maar herroept buren als de rechterbeperkingen falen, wat lokale zelfcorrectie mogelijk maakt.
Sliding Commit: Laat de grens tussen gecommitteerde en niet-gecommitteerde regio's verschuiven, waarbij het proces als een random walk wordt behandeld om lokale inconsistenties op te lossen.

3. Belangrijkste Bijdragen

Het artikel vat de bijdragen als volgt samen:

Synchronisatievrij Framework: Een methode waarbij elke watermerkbit onafhankelijk wordt ingebed, waardoor de noodzaak voor token-uitlijning tijdens herstel wordt weggenomen.
Reed–Solomon Codering: Een constructie die de identiteit reconstrueert uit een voldoende grote collectie correcte observaties, ongeacht hun positie in de tekst.
BSC Modellering: Een demonstratie dat alle corruptiebronnen (embedding-fouten en bewerkingen) kunnen worden gemodelleerd door een enkele Binary Symmetric Channel, wat een analytische in plaats van louter empirische robuustheidsevaluatie mogelijk maakt.
Probabilistische Formules: Afleiding van exacte en benaderende formules die de minimale tekstlengte voorspellen die nodig is voor succesvol herstel met een vooraf vastgesteld betrouwbaarheidsniveau.
Schaalbaarheid: Lichtgewicht varianten die lange identiteiten opdelen in fragmenten om de computationele complexiteit te verminderen terwijl de synchronisatievrije eigenschappen behouden blijven.
Diffusie Extensie: Een uitbreiding van het framework naar diffusiegebaseerde modellen met efficiënte token commitment-algoritmen en probabilistische analyse.

4. Resultaten en Analyse

Robuustheid: De analyse toont aan dat betrouwbaar herstel slechts een kleine redundantie vereist, zelfs bij hoge token-corruptieratio's. Bijvoorbeeld: het herstellen van een 32-bits identiteit met 99% vertrouwen in een kanaal met een foutenpercentage van 30% ( $p=0.3$ ) vereist slechts 25 extra tokenparen (totaal 57 paren).
Efficiëntie: Het "Meet-in-the-Middle" algoritme maakt praktisch herstel mogelijk voor identiteiten tot $n \approx 60$ bits op standaard werkstations. Fragmentatie maakt het mogelijk om met willekeurig lange identiteiten om te gaan.
Diffusie Convergentie:
- Het Basic Commit algoritme convergeert in $O(\ln N / \epsilon)$ iteraties.
- Het Sliding Commit algoritme convergeert in $O(N)$ iteraties, maar garandeert dat lokale inconsistenties uiteindelijk worden opgelost in plaats van bevroren.
- Het Refined Commit algoritme biedt een snellere initiële commit-rate, maar introduceert "churn" (het herroepen van geldige commitments) die de volledige sequentiestabiliteit trager kan maken vergeleken met de Basic-benadering.

5. Betekenis en Claims

Het artikel claimt dat de primaire betekenis ligt in het elimineren van het synchronisatieprobleem, wat een fundamentele barrière vormde voor robuuste LLM-watermarking. Door de watermerkbits los te koppelen van hun sequentiële posities, blijft de voorgestelde methode robuust tegen de bewerkingen die bestaande schema's ongeldig maken.

Bovendien pleiten de auteurs voor een verschuiving in de evaluatiemethodologie. In plaats van te vertrouwen op uitgebreide, modelspecifieke experimenten die snel verouderd raken, stellen zij het gebruik van de Binary Symmetric Channel abstractie voor. Dit maakt een principiële, wiskundige vergelijking van watermarking-schema's over verschillende modellen en bewerkingsstrategieën mogelijk op basis van één enkele parameter: de effectieve foutkans $p$ .

Het artikel concludeert dat hoewel de BSC een vereenvoudiging is, het een opmerkelijk nuttige benadering biedt, aangezien alle bewerkingen uiteindelijk manifesteren als onafhankelijke fouten in de herstelde pariteitsbits. Deze benadering biedt expliciete garanties op de herstelwaarschijnlijkheid en vereenvoudigt het ontwerp van robuuste watermarking-systemen.