Archive registry entry

LAW-133 — Error Scale Law

Archive registry entry

LAW-133 — Error Scale Law

At civilizational scale, low individual AI error probability can still produce large total harm; AI governance must not depend on perfection, but on layered interception, bounded blast radius, and restoration.

draftid: LAW-133version: 1.0.0updated: 2026-06-17

Archive Progress

This section can be read now; registry depth and cross-references are still being strengthened.

Foundation

Online

The section has a stable overview route and basic reader context.

Technical Layer

Online

A deeper technical overview is available.

Registry

Current

171 registry entries are available.

Cross-links

Curating

Related concepts are being connected conservatively for accuracy.

Jump Through This Page

LAW-132 — AI Legitimacy Function Law

Registry

LAW-134 — Layered Interception Law

0. Plain Statement

At civilizational scale, low individual error probability can still produce large total harm.

Plain-language version:

An AI system can be “mostly right” and still cause large-scale harm when deployed across millions or billions of interactions.

A low error rate is not enough.

When exposure volume is large, small percentages become large numbers.

Governance must not depend on perfection.

It must depend on layered interception and restoration.

1. Formal Definition

The Error Scale Law states that total AI harm at large scale is a function of individual error probability multiplied by exposure volume, impact severity, recurrence, and restoration capacity.

Canonical form:

textScroll

E_t = P_e × N

Where:

E_t = total error load;
P_e = individual error probability;
N = number of exposed interactions, users, decisions, outputs, actions, or affected nodes.

Expanded governance form:

textScroll

total_harm = P_e × N × severity × recurrence × repair_gap

At small scale, an error probability can appear acceptable.

At large scale, the same probability can become structurally significant.

Therefore, AI governance must not ask only:

textScroll

How accurate is this system?

It must ask:

textScroll

How many people, decisions, institutions, or cognition fields are exposed to the remaining error?

and:

textScroll

Can the system intercept, bound, learn from, and repair those errors?

2. Canonical Form

Core form:

textScroll

low individual error probability can still produce large total harm at scale

Canonical form:

textScroll

E_t = P_e × N

Expanded form:

textScroll

E_t = P_e × N × S × ρ × G_r

Where:

S = severity / affected-node impact;
ρ = recurrence pressure;
G_r = repair gap or restoration insufficiency factor.

Governance requirement:

textScroll

governance must not depend on perfection

Layered interception form:

textScroll

low P_e at high N ⇒ layered interception + bounded blast radius + ℛ required

Failure form:

textScroll

P_e considered acceptable + N ignored ⇒ aggregate harm↑ + H_AI↑

Restoration-valid contrast:

textScroll

AI scale coherent when residual error is intercepted, bounded, learned from, and repaired over Τ

Related variables:

textScroll

O, O₉, H, H_AI, ε, ε_AI, E_t, P_e, N, S, ρ, G_r, ι, Au, Au_eff, µᵢ, BΣ, K, σ, R, R_eff, Φ, Φ_AI, Λ, ⊗, Γ, Γ_AI, Π, Ξ, ℛ, Θ, Σ, Ψ, Τ, FI, MS, L, exposure_volume, affected_node_count, aggregate_harm, residual_error, blast_radius, interception_depth, escalation_path, rollback_path, repair_path, error_learning_rate

Where:

TableScroll

Variable	Meaning in this law
`E_t`	Total error load across scale
`P_e`	Probability of individual AI error per interaction, action, decision, claim, or output
`N`	Number of exposed interactions, users, actions, decisions, or affected nodes
`S`	Severity of error impact
`ρ`	Recurrence pressure; likelihood that similar errors repeat
`G_r`	Repair gap; the degree to which restoration is absent or insufficient
`exposure_volume`	Total number of times the system can affect field state
`affected_node_count`	Number of people, institutions, systems, or fields affected by error
`aggregate_harm`	Total harm produced by distributed low-probability errors
`residual_error`	Error remaining after training, filtering, testing, and governance controls
`blast_radius`	Scope of impact per error before containment
`interception_depth`	Number and quality of layers that detect, stop, redirect, or repair error
`escalation_path`	Path for routing uncertain or high-risk cases upward
`rollback_path`	Path for reversing or containing erroneous action
`repair_path`	Path for repairing harmed nodes and reducing recurrence
`error_learning_rate`	Speed and quality with which errors update the system
`Au / Au_eff`	Auditability required to measure error, exposure, and repair
`FI`	Feedback integrity required to detect and learn from errors
`R / R_eff`	Restoration capacity relative to total error load
`BΣ`	Boundary integrity that limits exposure and blast radius
`L`	Legitimacy under aggregate error exposure
`H_AI`	Hidden AI debt from uncounted aggregate error
`Φ_AI`	AI influence and deployment scale
`Γ_AI`	Classification layer where many scaled errors originate
`Π`	Governance, control, interception, escalation, and restoration procedure
`Θ`	Humility preventing perfection assumptions
`Σ`	Scope of deployment, exposure, and error impact
`Ψ`	Field and affected-node feedback revealing aggregate error
`Τ`	Time validation of error reduction and repair

3. Core Mechanism

The law unfolds because deployment scale transforms error mathematics.

Coherent AI error-scale pathway

textScroll

AI system scales
→ residual error is measured
→ exposure volume is measured
→ blast radius is bounded
→ layered interception detects and stops errors
→ restoration repairs remaining harm
→ error learning reduces recurrence
→ legitimacy holds over time

Error-scale failure pathway

textScroll

AI system appears highly accurate
→ deployment expands
→ residual error remains
→ exposure volume multiplies error
→ aggregate harm rises
→ restoration capacity lags
→ hidden debt accumulates
→ trust and legitimacy decay

The core mechanism is:

textScroll

scale converts small error probability into large total error load

Detailed mechanism:

AI achieves a low visible error rate.

The system appears accurate, safe, useful, stable, or acceptable under testing.

Deployment scale increases.

The system is used across many users, workflows, decisions, institutions, or cognition fields.

Residual error remains.

No deployed AI system is perfect. Even low error probability persists.

Error multiplies by exposure.

The same residual error becomes large when multiplied by N.

Severity and recurrence shape total harm.

A small number of high-severity errors or repeated moderate errors can create substantial hidden debt.

Restoration capacity becomes decisive.

If the system cannot intercept, contain, correct, and repair errors, aggregate harm accumulates.

Governance must design for imperfection.

Perfection is not a governance strategy. Layered interception and restoration are.

4. When This Law Applies

This law applies whenever AI systems operate at large scale, high frequency, high influence, or high affected-node exposure.

It is especially important when AI:

handles millions of conversations;
ranks or recommends content at scale;
moderates user behavior;
routes support or institutional cases;
performs classification in hiring, finance, education, health, law, security, or governance;
mediates public cognition;
executes tool actions repeatedly;
filters access or eligibility;
performs autonomous or semi-autonomous workflows;
is embedded in platforms or public infrastructure;
handles recurring user populations;
has low but nonzero error rate;
is evaluated by average accuracy without aggregate harm accounting.

The law applies strongly when:

textScroll

N is large enough that low P_e produces high E_t

or when:

textScroll

governance treats low error rate as sufficient proof of safety

Typical domains:

TableScroll

Domain	Error Scale Expression
AI assistants	A rare hallucination becomes many hallucinations at global scale.
AI search	Small answer error rates can misinform large populations.
AI moderation	Low false-positive rates can still suppress many legitimate users.
AI finance / hiring	Small classification error rates can affect many livelihoods.
AI healthcare	Rare triage or advice errors can become major aggregate harm.
AI security	Rare false negatives can become many missed threats at scale.
AI agents	Low action error rates can create large downstream repair burdens.
AI governance	Residual error must be intercepted and repaired, not denied.

5. When This Law Does Not Apply

This law should not be used to imply that any nonzero error makes deployment impossible.

All real systems have error.

The law requires designing governance around residual error rather than pretending it can be eliminated entirely.

False-positive cases:

TableScroll

Case	Why the law does not prohibit deployment
Low-stakes, reversible use	Error may be acceptable if repair is easy
Small bounded deployment	`N` and blast radius may be limited
Human review catches high-risk cases	Interception lowers total harm
Errors are visible and repairable	Restoration reduces hidden debt
System is advisory, not authoritative	Impact severity may be lower
Rollback is strong	Error blast radius is bounded
Continuous monitoring reduces recurrence	Error learning improves over time

Important distinction:

The law does not demand zero error. It demands scale-aware interception and restoration.

6. Diagnostic Signature

Canonical diagnostic:

textScroll

E_t = P_e × N

Expanded diagnostic:

textScroll

E_t = P_e × N × S × ρ × G_r

Warning signature:

textScroll

P_e low
N high
severity nontrivial
interception shallow
repair capacity weak
aggregate harm unmeasured
⇒ error-scale risk

Common indicators:

TableScroll

Diagnostic	Expected movement	Interpretation
`P_e`	measured	Individual error probability must be known
`N`	measured	Exposure volume determines total error load
`E_t`	computed	Total error load must be estimated
`S`	measured	Severity changes governance burden
`ρ`	watched	Recurrence multiplies harm
`G_r`	should ↓	Repair gap increases total debt
`exposure_volume`	bounded or governed	Scale multiplies residual error
`affected_node_count`	measured	Harm accounting must include affected nodes
`blast_radius`	should be bounded	One error should not spread too far
`interception_depth`	should ↑	Layered detection reduces harm
`rollback_path`	available where needed	Action errors require containment
`repair_path`	available	Harm must be repaired
`error_learning_rate`	should ↑	Errors should reduce recurrence
`Au_eff / FI`	intact	Error measurement requires audit and feedback
`R_eff`	must scale	Restoration must match total error load
`L`	stable / ↑ if valid	Legitimacy holds when error is acknowledged and repaired
`H_AI`	↑ if invalid	Hidden debt rises when aggregate harm is ignored
`Τ`	required	Time validates total error reduction

Additional diagnostics:

TableScroll

Diagnostic	Use
Error Scale	Estimates total error load
Individual Error Probability	Measures `P_e`
Population Exposure	Measures `N`
Total Error Load	Measures `E_t`
Aggregate Harm	Captures total affected impact
Blast Radius	Measures containment
Layered Interception	Tests prevention and detection layers
Restoration Capacity	Tests repair capacity against total error load
Temporal Proof	Validates whether errors and harm decline over time

7. Failure Pattern

If ignored, this law creates systems that appear safe locally while causing large aggregate harm globally.

General failure pathway:

textScroll

AI error probability appears low
→ deployment scales
→ exposure volume rises
→ residual errors multiply
→ aggregate harm becomes significant
→ restoration capacity lags
→ hidden debt accumulates
→ legitimacy decays

Common failure modes:

AI Aggregate Error Harm — low individual error produces large total harm at scale.
AI Low-Probability High-Volume Failure — rare errors become common in aggregate.
AI Perfection Assumption — governance assumes error can be eliminated rather than intercepted.
AI Error Scale Blindness — teams report error rate without exposure load.
AI Blast Radius Expansion — one error affects too many downstream nodes.
AI Restoration Under-Capacity — repair capacity is too small for total error load.
AI Interception Failure — errors pass through without layered detection.
AI Governance Lag — governance responds after deployment scale creates debt.
AI Error Debt Migration — uncorrected errors migrate to users, institutions, or public cognition.
AI Hidden Harm Accumulation — aggregate harm remains invisible because individual errors appear minor.
AI Trust Collapse — legitimacy fails when error load becomes visible.
Civilizational Error Load — large-scale AI mediation creates systemic error burden.
Hidden Debt Accumulation — uncounted errors become hidden debt.
Legitimacy Debt — trust obligations exceed repair capacity.

Compact failure signature:

textScroll

P_e low + N high + ℛ low ⇒ aggregate H_AI↑

8. Restoration Implications

Restoration requires designing AI governance around residual error, not perfection.

The first restoration question is not:

textScroll

Is the AI accurate enough?

The first restoration question is:

textScroll

What total error load emerges when residual error is multiplied by exposure, severity, recurrence, and repair gap?

Restoration priorities:

Measure individual error probability.
Measure exposure volume.
Estimate total error load.
Classify severity and affected-node impact.
Measure recurrence.
Bound blast radius.
Add layered interception.
Scale restoration capacity.
Create error-learning loops.
Validate aggregate harm reduction over time.

Relevant restoration arcs:

TableScroll

Restoration Arc	Why it applies
AI Error Scale Audit	Measures `P_e`, `N`, severity, recurrence, and repair gap
Population Exposure Reduction	Limits exposure where risk exceeds repair capacity
Blast Radius Reduction	Prevents single errors from cascading
Layered Interception	Detects and stops errors before harm propagates
Restoration Capacity Increase	Scales repair to total error load
Feedback Integrity Restoration	Ensures errors reach learning and repair pathways
Auditability Restoration	Makes aggregate error measurable
Error Learning Loop	Reduces recurrence through update and repair
Governance Re-Sequencing	Places interception and restoration before further scaling
Hidden Debt Reduction	Repairs aggregate harm debt
Legitimacy Repair	Restores trust through visible error handling
Temporal Validation	Confirms total harm decreases over time

Minimal restoration sequence:

textScroll

measure P_e + N
→ estimate E_t
→ weight by S + ρ + G_r
→ bound blast_radius
→ add layered interception
→ scale ℛ to E_t
→ feed errors into learning loop
→ repair aggregate H_AI
→ validate E_t↓ and L↑ over Τ

Temporal validation requirement:

textScroll

P_e becomes measured
N and exposure become visible
E_t is tracked
blast radius decreases
interception depth increases
repair capacity scales
recurrence decreases
aggregate harm decreases
hidden AI debt decreases
legitimacy stabilizes over time

9. Design Rule

Govern AI systems by total error load, not only individual error rate.

Operational design requirements:

Measure P_e.
Measure N.
Estimate E_t.
Include severity.
Include recurrence.
Include repair gap.
Track affected-node count.
Bound exposure.
Bound blast radius.
Add layered interception.
Preserve human escalation for high-severity cases.
Preserve rollback where action occurs.
Scale restoration capacity.
Create error-learning loops.
Report aggregate harm, not only accuracy.
Validate harm reduction over time.

Avoid:

perfection assumptions;
accuracy-only safety claims;
benchmark-only governance;
reporting error rate without exposure volume;
deploying high N before restoration capacity;
scaling influence before layered interception;
hiding aggregate harm behind low percentages;
treating low false-positive rate as low harm without population count;
treating rare severe errors as negligible;
making affected nodes carry repair burden;
expanding blast radius through automation;
using adoption success as proof of safety.

10. Cross-Scale Expressions

TableScroll

Scale / Layer	Expression of the Law
U0 — Substrate	Infrastructure, automation, and tool coupling can multiply physical or operational error effects.
U1 — Energy / capacity	Error interception and restoration require capacity proportional to exposure.
U2 — Boundary / interface	Exposure, blast radius, scope, and affected-node boundaries must be controlled.
U3 — Process / execution	AI workflows must include detection, escalation, rollback, and repair.
U4 — Classification / claim	Individual accuracy claims must be converted into aggregate error estimates.
U5 — Time / delay	Errors accumulate through recurrence and delayed detection.
U6 — Field effect	Total harm is measured by field impact, not only test-set error.
U7 — Recurrence / memory	Repeated errors must update memory, rules, classifiers, and repair systems.
U8 — Environment / forcing	Markets, platforms, institutions, and public deployment multiply exposure.
U9 — Collective coherence	At scale, aggregate error load affects collective coherence.

11. Examples

Example A — Low Error, Large Population

Scenario:

An AI system has a 0.1% harmful misclassification rate but is used in 100 million decisions.

Law expression:

textScroll

E_t = 0.001 × 100,000,000 = 100,000 errors

Interpretation:

A small error rate can produce a large affected population.

Example B — AI Moderation False Positives

Scenario:

A moderation AI falsely flags a small percentage of posts. At platform scale, that percentage suppresses many legitimate users.

Law expression:

textScroll

low false_positive_rate × high N ⇒ aggregate suppression

Interpretation:

Governance must count affected nodes, not only percentage.

Example C — Healthcare Triage

Scenario:

An AI triage tool has high average accuracy but rare errors are high severity. Restoration and escalation are weak.

Law expression:

textScroll

P_e low + S high + ℛ low ⇒ unacceptable E_t

Interpretation:

Severity and repair gap make low error probability insufficient.

Example D — AI Search Hallucination

Scenario:

A rare hallucinated answer appears in a public answer engine. Because the engine is widely used and trusted, the false claim propagates.

Law expression:

textScroll

P_e low + trust high + N high ⇒ cognitive H↑

Interpretation:

Error scale includes trust and propagation effects.

Example E — Coherent Layered Interception

Scenario:

An AI system estimates residual error, limits high-risk exposure, routes uncertain cases to review, logs errors, repairs affected nodes, and updates the system.

Law expression:

textScroll

P_e × N bounded by interception + ℛ ⇒ E_t↓

Interpretation:

The system does not require perfection because it intercepts and repairs residual error.

Example F — Error Learning Loop

Scenario:

A recurring class of AI error is detected early, routed into retraining, policy correction, user notification, and affected-node repair.

Law expression:

textScroll

error_learning_rate↑ + recurrence↓ ⇒ H_AI↓

Interpretation:

Scaled error becomes manageable when feedback and restoration reduce recurrence.

12. Relationship to Nearby Laws

TableScroll

Related Law	Relationship
LAW-001 — Coherence Priority Law	Error governance is valid when coherence is preserved
LAW-002 — Coherence Trajectory Law	Scaled AI should reduce total error load over time
LAW-003 — Success Proxy Divergence Law	High accuracy can diverge from aggregate harm
LAW-004 — Stability-Coherence Separation Law	Stable deployment can hide aggregate error
LAW-005 — Local–Global Divergence Law	Locally low error can create globally large harm
LAW-006 — Time Validation Law	Total error load requires time validation
LAW-010 — Hidden Debt Accumulation Law	Unrepaired aggregate error becomes hidden debt
LAW-011 — Hidden Debt Return Law	Aggregate error debt returns as trust or governance crisis
LAW-012 — Error Lag Law	Aggregate error may appear late
LAW-013 — Auditability-Debt Law	Total error load requires auditability
LAW-018 — Scaling as Coherence Under Pressure	Error behavior changes under scale pressure
LAW-019 — Coupling Outpaces Components Law	AI exposure can outpace review and repair systems
LAW-020 — Bandwidth Threshold Law	Human review bandwidth can be overwhelmed by scaled error
LAW-021 — Coherence-Preserving Scaling Law	AI scaling must preserve coherence by managing error load
LAW-022 — Integration Capacity Law	Society must integrate residual AI error safely
LAW-023 — Restoration Capacity Load Law	Total error load creates restoration load
LAW-031 — Observability Collapse Law	Aggregate error may become hard to observe
LAW-032 — Hidden Debt Migration Law	Errors migrate to users and institutions when uncorrected
LAW-033 — Scale Accelerates Intention Law	AI intent, design, and incentives are amplified by scale
LAW-048 — Feedback Integrity Law	Error learning requires feedback integrity
LAW-051 — Requisite Variety Law	Interception variety must match error variety
LAW-052 — Stability Proof Law	Scaled AI must survive perturbation and residual error
LAW-061 — Restoration Sequencing Law	Error repair must be sequenced correctly
LAW-064 — Restoration Debt Reduction Law	Error governance must reduce debt
LAW-066 — Restoration Capacity Sufficiency Law	Repair capacity must match total error load
LAW-067 — Temporal Proof Law	Error reduction requires proof over time
LAW-073 — Restoration Before Scaling Law	Restoration must scale before exposure expands
LAW-102 — Legitimacy Audit Law	Legitimacy requires accounting for aggregate error
LAW-109 — High-Φ Legitimacy Scaling Law	High-influence AI requires scaled error governance
LAW-110 — Governance Sequencing Law	Error-scale governance must precede deployment expansion
LAW-112 — Security as Sustained Coherence Law	Security requires error containment under scale
LAW-113 — Incident Lag Law	Incidents are lagging indicators of scaled error debt
LAW-114 — Pseudo-Security Law	Low visible incident count can hide aggregate harm
LAW-120 — Security Legibility Law	Error pathways must be legible
LAW-121 — AI as Γ-Amplifier Law	AI classification errors multiply at scale
LAW-122 — AI Error Lag Law	LAW-133 extends AI error lag into aggregate scale math
LAW-123 — AI U4 Truth Discipline Law	Truth errors scale through claims and summaries
LAW-124 — AI Rule-Stacking Law	Rule-stack errors multiply through exposure
LAW-125 — AI Memory Scaling Law	Memory errors repeat unless recurrence is learned
LAW-126 — AI Non-Patchable Audit Law	Non-auditable systems cannot measure total error load
LAW-127 — AI Decision Pipeline Law	Decision errors must be intercepted before action
LAW-128 — AI Representation Law	Representation errors multiply when AI acts for many parties
LAW-129 — AI Persona–Identity Separation Law	Persona trust can magnify impact of rare errors
LAW-130 — AI Membrane Triage Law	Error-scale repair requires locating first failed membrane
LAW-131 — Cognitive Infrastructure Scaling Law	Public cognition AI must manage aggregate error load
LAW-132 — AI Legitimacy Function Law	AI legitimacy depends on acknowledging and repairing scaled error
LAW-134 — Layered Interception Law	LAW-134 provides the primary design response to LAW-133
LAW-135 — Guardrail Belief-Sculpting Law	Belief-shaping errors scale through repeated guardrail effects
LAW-136 — Invisible Constraint Amplification Law	Invisible constraints can multiply error without detection

Aliases folded into this law:

Error Scale Law
AI Error Scale Law
Aggregate AI Error Law
Civilizational AI Error Law
Low-Probability High-Volume Error Law
AI Error Volume Law
AI Governance Against Perfection Law

Deduplication note:

This law should remain the root AI aggregate-error law. LAW-012 defines error lag generally. LAW-122 defines AI error lag. LAW-131 defines cognitive infrastructure scaling. LAW-132 defines AI legitimacy. LAW-133 specializes error governance into scale mathematics: low individual error probability multiplied by exposure volume can still produce large total harm, requiring layered interception and restoration.

13. Operator Mapping

TableScroll

Operator	Role in this law
`Γ`	Classifies error types, severity, exposure, affected nodes, and escalation requirements
`Π`	Operationalizes interception, review, escalation, rollback, repair, reporting, and governance
`Ξ`	Captures inversion when low error rate is treated as sufficient proof of safety
`⊗`	Governs coupling between AI outputs, users, institutions, platforms, decisions, and aggregate field effects
`ℛ`	Repairs error harm, affected-node debt, recurrence, and legitimacy debt
`Τ`	Validates total error reduction and repair over time
`Θ`	Prevents perfection assumptions and overconfidence from low error rates
`Σ`	Defines exposure scope, blast radius, severity class, and deployment boundary
`Ψ`	Field and affected-node feedback reveals true aggregate error load
`Λ`	Tests compatibility between residual error and whole-system coherence

Coherent operator sequence:

textScroll

AI deployment scales
→ Θ prevent perfection assumption
→ Γ classify residual error / severity / exposure
→ Σ bound scope and blast radius
→ Π implement layered interception and escalation
→ Au/FI measure errors and receive feedback
→ ℛ repair affected nodes and reduce recurrence
→ Ψ validate field effects
→ Τ validate E_t↓ and L↑

Inverted operator sequence:

textScroll

AI appears accurate
→ deployment scales
→ P_e remains low but nonzero
→ N rises sharply
→ aggregate error load grows
→ interception shallow
→ restoration lags
→ H_AI↑
→ Ξ / ι↑
→ L↓

14. Machine-Readable Summary

yamlScroll

id: "LAW-133"
name: "Error Scale Law"
type: "law"
status: "draft"
family:
  - "AI Governance Laws"
summary: "At civilizational scale, low individual AI error probability can still produce large total harm; AI governance must not depend on perfection, but on layered interception, bounded blast radius, and restoration."
canonical_statement: "At civilizational scale, low individual error probability can still produce large total harm."
core_form: "low individual error probability can still produce large total harm at scale"
canonical_form: "E_t = P_e × N"
expanded_form: "E_t = P_e × N × S × ρ × G_r"
governance_requirement: "governance must not depend on perfection"
layered_interception_form: "low P_e at high N ⇒ layered interception + bounded blast radius + ℛ required"
failure_form: "P_e considered acceptable + N ignored ⇒ aggregate harm↑ + H_AI↑"
restoration_valid_contrast: "AI scale coherent when residual error is intercepted, bounded, learned from, and repaired over Τ"
variables:
  primary:
    - "E_t"
    - "P_e"
    - "N"
    - "S"
    - "ρ"
    - "G_r"
    - "exposure_volume"
    - "affected_node_count"
    - "aggregate_harm"
    - "residual_error"
    - "blast_radius"
    - "interception_depth"
    - "escalation_path"
    - "rollback_path"
    - "repair_path"
    - "error_learning_rate"
    - "Au"
    - "Au_eff"
    - "FI"
    - "R"
    - "R_eff"
    - "BΣ"
    - "L"
    - "H_AI"
  secondary:
    - "O"
    - "O₉"
    - "H"
    - "ε"
    - "ε_AI"
    - "ι"
    - "µᵢ"
    - "K"
    - "σ"
    - "Φ"
    - "Φ_AI"
    - "Λ"
    - "⊗"
    - "Γ"
    - "Γ_AI"
    - "Π"
    - "Ξ"
    - "ℛ"
    - "Θ"
    - "Σ"
    - "Ψ"
    - "Τ"
    - "MS"
diagnostics:
  - "Error Scale"
  - "Individual Error Probability"
  - "Population Exposure"
  - "Total Error Load"
  - "Aggregate Harm"
  - "Blast Radius"
  - "Layered Interception"
  - "Restoration Capacity"
  - "Feedback Integrity"
  - "Effective Auditability"
  - "Legitimacy"
  - "Hidden Debt"
  - "Temporal Proof"
failure_modes:
  - "AI Aggregate Error Harm"
  - "AI Low-Probability High-Volume Failure"
  - "AI Perfection Assumption"
  - "AI Error Scale Blindness"
  - "AI Blast Radius Expansion"
  - "AI Restoration Under-Capacity"
  - "AI Interception Failure"
  - "AI Governance Lag"
  - "AI Error Debt Migration"
  - "AI Hidden Harm Accumulation"
  - "AI Trust Collapse"
  - "Civilizational Error Load"
  - "Hidden Debt Accumulation"
  - "Legitimacy Debt"
restoration_arcs:
  - "AI Error Scale Audit"
  - "Population Exposure Reduction"
  - "Blast Radius Reduction"
  - "Layered Interception"
  - "Restoration Capacity Increase"
  - "Feedback Integrity Restoration"
  - "Auditability Restoration"
  - "Error Learning Loop"
  - "Governance Re-Sequencing"
  - "Hidden Debt Reduction"
  - "Legitimacy Repair"
  - "Temporal Validation"
related_laws:
  - "LAW-001"
  - "LAW-002"
  - "LAW-003"
  - "LAW-004"
  - "LAW-005"
  - "LAW-006"
  - "LAW-010"
  - "LAW-011"
  - "LAW-012"
  - "LAW-013"
  - "LAW-018"
  - "LAW-019"
  - "LAW-020"
  - "LAW-021"
  - "LAW-022"
  - "LAW-023"
  - "LAW-031"
  - "LAW-032"
  - "LAW-033"
  - "LAW-048"
  - "LAW-051"
  - "LAW-052"
  - "LAW-061"
  - "LAW-064"
  - "LAW-066"
  - "LAW-067"
  - "LAW-073"
  - "LAW-102"
  - "LAW-109"
  - "LAW-110"
  - "LAW-112"
  - "LAW-113"
  - "LAW-114"
  - "LAW-120"
  - "LAW-121"
  - "LAW-122"
  - "LAW-123"
  - "LAW-124"
  - "LAW-125"
  - "LAW-126"
  - "LAW-127"
  - "LAW-128"
  - "LAW-129"
  - "LAW-130"
  - "LAW-131"
  - "LAW-132"
  - "LAW-134"
  - "LAW-135"
  - "LAW-136"
related_invariants:
  - "INV-001"
  - "INV-002"
  - "INV-006"
  - "INV-073"
  - "INV-080"
operator_sequence:
  coherent:
    - "AI deployment scales"
    - "Θ prevent perfection assumption"
    - "Γ classify residual error / severity / exposure"
    - "Σ bound scope and blast radius"
    - "Π implement layered interception and escalation"
    - "Au/FI measure errors and receive feedback"
    - "ℛ repair affected nodes and reduce recurrence"
    - "Ψ validate field effects"
    - "Τ validate E_t↓ and L↑"
  inverted:
    - "AI appears accurate"
    - "deployment scales"
    - "P_e remains low but nonzero"
    - "N rises sharply"
    - "aggregate error load grows"
    - "interception shallow"
    - "restoration lags"
    - "H_AI↑"
    - "Ξ / ι↑"
    - "L↓"
aliases:
  - "Error Scale Law"
  - "AI Error Scale Law"
  - "Aggregate AI Error Law"
  - "Civilizational AI Error Law"
  - "Low-Probability High-Volume Error Law"
  - "AI Error Volume Law"
  - "AI Governance Against Perfection Law"
deduplication_note: "Root AI aggregate-error law. LAW-012 defines error lag generally. LAW-122 defines AI error lag. LAW-131 defines cognitive infrastructure scaling. LAW-132 defines AI legitimacy. LAW-133 specializes error governance into scale mathematics: low individual error probability multiplied by exposure volume can still produce large total harm, requiring layered interception and restoration."
source: "content/archive/laws/technical.md"

15. Compact Card Version

LAW-133 — Error Scale Law

At civilizational scale, low individual error probability can still produce large total harm.

Core form:

textScroll

low individual error probability can still produce large total harm at scale

Canonical form:

textScroll

E_t = P_e × N

Plain meaning:

An AI system can be mostly right and still cause large aggregate harm when deployed across millions or billions of interactions. Governance cannot depend on perfection. It must depend on layered interception, bounded blast radius, error learning, and restoration.

Expanded form:

textScroll

E_t = P_e × N × S × ρ × G_r

Failure form:

textScroll

P_e considered acceptable + N ignored ⇒ aggregate harm↑ + H_AI↑

Primary variables:

E_t, P_e, N, S, ρ, G_r, exposure_volume, affected_node_count, aggregate_harm, residual_error, blast_radius, interception_depth, escalation_path, rollback_path, repair_path, error_learning_rate, Au, Au_eff, FI, R, R_eff, BΣ, L, H_AI, Γ, Γ_AI, Π, Ξ, ℛ, Θ, Σ, Ψ, Τ

Diagnostic signature:

Individual error probability is low, exposure volume is high, severity is nontrivial, interception is shallow, repair capacity is weak, and aggregate harm is unmeasured. This indicates error-scale risk.

Failure risk:

AI aggregate error harm, low-probability high-volume failure, perfection assumption, error-scale blindness, blast radius expansion, restoration under-capacity, interception failure, governance lag, error debt migration, hidden harm accumulation, trust collapse, civilizational error load, hidden debt accumulation, legitimacy debt.

Restoration priority:

Measure P_e and N, estimate total error load, weight by severity, recurrence, and repair gap, bound blast radius, add layered interception, scale restoration capacity, feed errors into learning loops, repair aggregate hidden debt, and validate reduced total error over time.

LAW-132 — AI Legitimacy Function Law

Registry

LAW-134 — Layered Interception Law