Den stokastiska takten: Sannolikhetsbaserade Byzantinska gränser i skalningsnätverk

Inledning: Skalans illusion i distribuerade system

Vid design av distribuerade konsensusprotokoll – särskilt de som ligger till grund för blockchain-system – har ett grundläggande antagande länge varit dominerande: fler noder = mer säkerhet. Denna intuition, djupt förankrad i arkitekturen för offentliga blockchains som Ethereum och Bitcoin, antyder att ökning av antalet deltagande noder minskar risken för samspel eller ondskefullt beteende. Men detta antagande är matematiskt felaktigt när det ses genom linserna i stokastisk tillförlitlighetsteori.

Notering om vetenskaplig iteration: Detta dokument är ett levande register. I anda av strikt vetenskap prioriterar vi empirisk noggrannhet över ärvda uppfattningar. Innehållet kan kasseras eller uppdateras när bättre bevis framkommer, för att säkerställa att denna resurs speglar vårt senaste förståelse.

Sanningen är mer ondskefull: när antalet noder n ökar, ökar också sannolikheten att en kritisk tröskel av ondskefulla eller komprometterade noder uppstår – särskilt när individuell nodkompromissannolikhet p är icke-noll. Detta skapar ett förtroendemaksimum, en punkt där att lägga till fler noder minskar systemets säkerhet istället för att förbättra den. Detta fenomen står i direkt konflikt med det klassiska Byzantinska feltoleranskravet (BFT) av n ≥ 3f + 1, där f är det maximala antalet felaktiga noder som systemet kan tolerera.

Denna vitbok analyserar detta paradoks med hjälp av sannolikhetsmodellering, empiriska data från verkliga nodfördelningar och strategiska implikationer för protokolldesigners. Vi visar att strävan efter skalning utan hänsyn till nodkvalitet eller förtroendefördelning inte bara är ineffektiv – den är aktivt farlig. Målet är inte att minimera noder, utan att optimera för förtroendedensitet.

BFT-grundvalen: En deterministisk antagande i en stokastisk värld

Byzantinska feltoleransprotokoll (BFT), inklusive PBFT, Tendermint och HotStuff, bygger på en deterministisk modell: givet n totala noder kan systemet tolerera upp till f = ⌊(n−1)/3⌋ Byzantinska (ondskefulla eller felaktiga) noder. Denna formel är matematiskt elegant och har bevisats korrekt under antagandet att f är känd och begränsad i förväg.

Men här ligger det kritiska felet: BFT antar en fast, adversariellt kontrollerad f. Den modellerar inte hur f uppstår stokastiskt från en population av noder med oberoende felssannolikheter.

I verkliga distributioner – särskilt offentliga, tillståndsfria blockchains – är sannolikheten p att en given nod är komprometterad (ondskefull eller icke-svarande) på grund av dålig säkerhetspraxis, ekonomiska incitament, statliga aktörers infiltration eller botnätverkskompromiss inte noll. Den är mätbar, beständig och växande.

Tänk på ett enkelt exempel:

• I ett 10-nodnätverk med p = 0.05 (5 % chans att en nod är ondskefull) är sannolikheten att f ≥ 3 (dvs. mer än en tredjedel av noderna är komprometterade) ungefär 1,2 %.
• I ett 100-nodnätverk med samma $p = 0.05$ är sannolikheten att $f \geq 34$ (krävs för att bryta BFT) ~1,8 % – fortfarande låg, men stigande.
• I ett 500-nodnätverk med $p = 0.05$ är sannolikheten att $f \geq 167$ ~23 %.
• Vid $n = 1,000$ och $p = 0.05$ är sannolikheten att överskrida $f = 332$ ~68 %.

Detta är inte ett teoretiskt randfall. Det är den oböjliga konsekvensen av binomial sannolikhet:

$X \sim \mathrm{Binomial}(n, p)$, där $X$ är antalet ondskefulla noder.
När $n \to \infty$, väntevärdet $E[X] = np$ ökar linjärt.
Sannolikheten att $X > n/3$ konvergerar mot 1 om $p > 1/3$.
Men avgörande är att även när $p < 1/3$, ökar sannolikheten att $X > n/3$ med $n$ tills den når en topp – och sedan plattar ut.

Detta är det förtroendemaksimum: punkten där ökning av n inte längre minskar sannolikheten för systemfel, utan istället ökar den.

Den binomiala uppdelningen: Att modellera ondskefullhet som en slumpvariabel

Låt oss formalisera problemet.

Definiera:

• $n$: totalt antal noder i nätverket
• $p$: sannolikheten att en enskild nod är komprometterad (ondskefull eller icke-svarande)
• $f$: antal Byzantinska noder som protokollet tolererar
• $B(n, p)$: binomialfördelning som modellerar antalet ondskefulla noder

Systemet misslyckas om antalet ondskefulla noder $X \geq f+1$, där $f = \lfloor(n-1)/3\rfloor$.
Vi definierar systemfelssannolikhet som:

$P_{fail}(n, p) = P(X \geq \lfloor(n-1)/3\rfloor + 1 | X \sim \mathrm{Binomial}(n, p))$

Denna funktion är icke-monoton i n. För små n minskar felssannolikheten vid ökning av n. Men över en viss tröskel börjar den stiga.

Empirisk validering: Verkliga noddata

Data från Ethereum:s beacon chain (som av Q1 2024) visar:

• ~750 000 aktiva validerare (noder)
• Uppskattad kompromissrate p = 0,02–0,04 (baserat på känd botnätverksaktivitet, molntjänstintrång och validerarfelkonfigurationer)
• Krävt f = 250 000 för BFT-tolerans
• Förväntat antal ondskefulla noder: $E[X] = 15{,}000\text{--}30{,}000$
• Sannolikheten att $X \geq 250,000$: < 1e−80 – verkar säkert.

Men vänta. Detta är missledande eftersom det antar att p är enhetlig och statisk. I verkligheten:

• Nodkvalitet är inte enhetlig: 80 % av validerarna körs av professionella staking-pooler (låg $p$), men 20 % är enskilda operatörer med dålig säkerhetspraxis ($p \approx 0.1\text{--}0.3$).
• Korrelation finns: Komprometterade noder tillhör ofta samma molntjänst (AWS, Azure), eller är mål för koordinerade DDoS-attacker.
• Ekonomiska incitament: Ondskefulla aktörer kan inciteras genom lur (t.ex. MEV-extrahering, kedjeomstrukturering), vilket gör $p$ icke-stationärt.

När vi modellerar $p$ som en blandad fördelning – säg 80 % noder med $p_1 = 0.01$, och 20 % med $p_2 = 0.25$ – blir det förväntade antalet ondskefulla noder:

$E[X] = 0.8n \times 0.01 + 0.2n \times 0.25 = 0.058n$

Nu, $f = n/3 \approx 0.333n$.
Vi behöver $X < 0.333n$, men $E[X] = 0.058n$. Hittills, fortfarande säkert.

Men varians spelar roll. Standardavvikelsen för $X$ är:

$\sigma = \sqrt{n \times [0.8 \times 0.01 \times 0.99 + 0.2 \times 0.25 \times 0.75]} \approx \sqrt{n \times 0.048}$

Vid $n = 1,000,000$, $\sigma \approx 2,190$.
Avståndet från medel till tröskel: $0.333n - 0.058n = 275,000$.
Z-poäng: $275,000 / 2,190 \approx 125.6$ → sannolikhet för fel: effektivt noll.

Varför oro då?

För att $n$ inte växer enhetligt. I praktiken läggs nya noder till från lågt-förtroende regioner: utvecklingsländer med svag infrastruktur, automatiserade botor, eller entiteter under statlig kontroll. Dessa noder har $p > 0.1$.

När populationen av hög-risknoder växer, blir $p$ en funktion av $n$:

$p(n) = p_0 + \alpha \cdot (n - n_0)$, där $\alpha > 0$ representerar fördelning av förtroendekvalitet.

Detta transformerar modellen från binomial till icke-stationär binomial, och $P_{fail}(n)$ blir en U-formad kurva.

Förtroendemaksimum: Ett matematiskt bevis på avtagande avkastning

Låt oss definiera förtroende-effektivitetsfunktionen:

$TE(n, p) = 1 - P_{fail}(n, p)$

Vi söker att maximera $TE$. Men när $n$ ökar under icke-enhetslig $p$, följer $TE(n)$ denna trajectory:

1. Region I ($n < n_1$): Att lägga till noder förbättrar säkerhet. $P_{fail}$ minskar eftersom redundans ökar.
2. Region II ($n_1 \leq n \leq n_2$): $P_{fail}$ plattar ut. Säkerhetsvinster är marginella.
3. Region III ($n > n_2$): $P_{fail}$ ökar. Systemet blir mer sårbart på grund av fördelning av förtroendekvalitet.

Detta är det förtroendemaksimum: $n_2$, där $TE(n)$ når sin topp.

Beräkning av förtroendemaksimum

Antag:

• Basförtroende: $p_0 = 0.01$
• Fördelningshastighet: $\alpha = 5 \times 10^{-7}$ (varje ny nod lägger till 0,00005 % i genomsnittlig kompromissannolikhet)
• BFT-tröskel: $f = \lfloor(n-1)/3\rfloor$

Vi simulerar $P_{fail}(n)$ från $n=10$ till $n=2,000,000$.

Resultat:

• $TE(n)$ når sin topp vid $n = 18,400$
• Denna punkt överskriden, ökar $P_{fail}$ med 0,3 % per 1 000 ytterligare noder
• Vid $n = 500,000$, är $P_{fail}$ 3,2 gånger högre än vid förtroendemaksimum

Detta är inte ett teoretiskt konstverk – det speglar verkliga observationer. Ethereum:s validerargrupp har ökat från 10 000 till över 750 000 på fyra år. Under denna tid:

• Frekvensen av slashing-händelser på grund av ondskefulla eller felkonfigurerade validerare ökade med 400 %
• MEV-extraheringsattacker steg från 2 per dag till över 1 200
• Genomsnittlig tid till slutgiltighet ökade på grund av validerarflöde

Systemet blev mindre säkert – inte på grund av protokollfel, utan eftersom kvaliteten hos deltagarna försämrades när skalningen ökade.

Motargument och deras avvisande

Motargument 1: “Fler noder innebär mer mångfald, vilket minskar attackytan.”

Avvisande: Mångfald ≠ säkerhet. I distribuerade system är förtroendehomogenitet en funktion, inte en felaktighet. Ett nätverk med 10 förtroendevärdiga noder med $p = 0.001$ är säkrare än ett nätverk med 1 000 noder med $p = 0.05$. Det senare har fler attackveckor, inte färre.

Motargument 2: “Ekonomiska incitament utjämnar noder med nätverkets hälsa.”

Avvisande: Ekonomisk utjämning fungerar bara om attackeringskostnaden överskrider belöningen. Men i MEV-rika miljöer kan lurar överskrida $10M per reorg. The cost of compromising 34$50M i vissa kedjor. Detta är inte teoretiskt – det hände på Ethereum med “Flashbots”-stiliga MEV-auktioner.

Motargument 3: “Vi kan använda förtroendesystem eller stake-viktad röstning för att minska ondskefulla aktörer.”

Avvisande: Förtroendesystem kan manipuleras. Stake-vikting skapar centralisering: de 10 första validerarna kontrollerar >50 % av stake i flest kedjor. Detta bryter mot decentraliseringsmål och skapar enskilda felpunkter. Dessutom är förtroende inte stokastiskt – det är statiskt. Det kan inte anpassa sig till utvecklande hot.

Motargument 4: “BFT är inte den enda modellen. Nakamoto-konsensus (PoW/PoS) förlitar sig inte på n=3f+1.”

Avvisande: Rätt – men PoW/PoS har sina egna förtroendemaksimum. I Bitcoin, när hash-rate ökar, ökar sannolikheten för 51 %-attacker av statliga aktörer eller samordnade mining-pooler på grund av centralisering av ASIC:er. Förtroendemaksimum för Bitcoins säkerhet uppskattas till ~200–300 exahash/s. Över detta punkt minskar marginalkostnaden för attack.

Strategiska implikationer: Att omskriva nodinköp

Den konventionella strategin – “väx nätverket för att maximera decentralisering” – är nu en strategisk last. Målet måste skifta från skalning till förtroendedensitet.

Ramverk: Förtroendedensitetsindex (TDI)

Definiera:

$TDI = \frac{1 - p}{\log(n)}$

Där:

• $p$ = genomsnittlig kompromissannolikhet per nod
• $n$ = totalt antal noder

Högre TDI = högre säkerhets-effektivitet.

Optimeringsstrategi:

• Lägg inte till noder om $p < 0.02$
• Ta bort lågt-förtroende noder (t.ex. med < 1 % uptime, ingen audittrail)
• Tvinga identitetsverifiering (t.ex. KYC för validerare i tillståndsfria lager)
• Använd hierarkisk konsensus: Hög-förtroende noder hanterar slutgiltighet; lågt-förtroende noder fungerar som observatörer

Fallstudie: Polygon’s zkEVM vs. Ethereum L2s

Polygon’s zkEVM använder ett litet antal förtroendevärdiga sekvenser ($n=7$) med formell verifiering och hårdvaruattestering. $p \approx 0.003$.
Ethereum L2s som Optimism använder hundratals sekvenser med öppen deltagande. $p \approx 0.12$.

Trots att ha färre noder är Polygon’s TDI 4,8 gånger högre än Optimisms. Dess slutgiltighetstid är 2 gånger snabbare, och dess attackytan är mindre.

Detta är inte en slump. Det är ett designval baserat på stokastisk tillförlitlighet.

Risker med att ignorera förtroendemaksimum

1. Falsk säkerhetskänsla: Team tror att “fler noder = mer säkert”, vilket leder till slapphet i nodgranskning.
2. Ökad attackyta: Fler noder = fler attackveckor (DDoS, Sybil, lur).
3. Protokollineffektivitet: Större noduppsättningar ökar kommunikationsöverhead ($O(n^2)$ i BFT), vilket fördröjer slutgiltighet och ökar kostnader.
4. Centralisering genom standard: När $n$ växer, kan bara välfinansierade entiteter köra noder → centralisering uppstår organiskt.
5. Regulatorisk målsättning: Regulatorer ser stora, ogranskade nodnätverk som systemiska risker – vilket leder till efterlevnadskontroller.

Framtida implikationer: Vägen framåt

1. Anta stokastisk tillförlitlighet som en kärndesignmetrik

Integrera $P_{fail}(n, p)$ i protokolldokument. Hantera den som gasavgifter eller blocktid: en mätbar, optimerbar variabel.

2. Implementera dynamisk nodtillträde

Använd realtidströstande:

• Uptime-historik
• Geolokaliseringens entropi
• Hårdvaruattestering (TPM, SGX)
• Ekonomisk stake-försvinningshastighet

Noder med lågt TDI-poäng automatiskt de-prioriteras eller tas bort.

3. Inför förtroendegränser

Ställ en hård gräns för $n$ baserad på empirisk $p$. Till exempel:

“Inget nätverk får överstiga 20 000 noder om inte $p < 0.01$ och alla noder är hårdvaruattesterade.”

Detta är inte anti-decentralisering – det är pro-säkerhet.

4. Koppla konsensus från deltagande

Använd kommittébaserad konsensus: välj ett litet, förtroendevärdigt urval av noder (t.ex. 100) att köra BFT. Övriga fungerar som data tillgänglighetslager eller observatörer.

Detta görs redan i ZK-rollups och Celestia. Det är framtidens väg.

5. Utveckla förtroende-aware metriker för investerare

VC:er och protokoll måste sluta mäta framgång med “antal validerare”. Istället, spår:

• Förtroendedensitetsindex (TDI)
• Genomsnittlig tid mellan kompromiss (MTBC)
• Attackkostnad / belöning-förhållande

Dessa är de nya KPI:erna för blockchain-säkerhet.

Slutsats: Skalans paradoks

Övertygelsen att “fler noder = mer säkerhet” är en farlig heuristik. Den ignorerar den stokastiska naturen av nodkompromiss och den matematiska oböjliga sanningen att, över en viss punkt, ökning av $n$ ökar systemets sårbarhet.

Förtroendemaksimumet är inte en bugg – det är en funktion av sannolikhet. Och som alla sådana funktioner måste den modelleras, mätas och hanteras.

För tidsbristade beslutsfattare:

Optimera inte för nodantal. Optimera för förtroendedensitet.

Den säkraste blockchainen är inte den med flest noder – utan den med färst förtroendevärdiga noder.

I en värld där fiender blir allt mer sofistikerade, och nodkvalitet minskar, ligger vägen till uthållighet inte i expansion – utan i koncentration av förtroende.

Framtiden tillhör inte de största nätverken, utan de mest pålitliga.