NEW MATHS DEBT THEORY
New Maths Debt Theory
Table of Contents
0. Definition
0.1 Mathematical Debt as Unpaid Obligation
0.2 Debt Distinguished from Error
0.3 Local Success versus Global Usability
0.4 The Purpose of Debt Theory
0.5 The Prevention of Theorem Laundering
1. Core Thesis
1.1 Mathematics Advances by Movement
1.2 Carrier Change as the Engine of Discovery
1.3 Every Productive Movement Creates Obligation
1.4 Paid Debt, Active Debt, Counterkernels, and New Theory
1.5 The Theorem as Statement plus Route plus Export Conditions
2. Scope of the Theory
2.1 Mathematical Transport across Domains
2.2 Epistemic Transport across Proof Media
2.3 Computational, Formal, Collaborative, and AI-Mediated Mathematics
2.4 Context-Sensitive Debt and Intended Use
2.5 Debt Theory as Proof-Ecology Architecture
3. Debt Sources
3.1 Transport Debt
3.2 Carrier Replacement Debt
3.3 Abstraction Debt
3.4 Analogy Debt
3.5 Compactness Debt
3.6 Asymptotic Debt
3.7 Formalization Debt
3.8 Computation Debt
3.9 Exposition Debt
3.10 Collaboration Debt
3.11 AI Generation Debt
3.12 Institutional Debt
3.13 The Shared Structure of All Debt Sources
4. Debt Classes
4.1 Transport Debt
4.1.1 Primitive Alignment
4.1.2 Invariant Preservation
4.1.3 Loss Accounting
4.1.4 Exception Transfer
4.1.5 Liftback and Displaced Proof
4.2 Carrier Replacement Debt
4.2.1 Revelation and Suppression
4.2.2 Native Constraint Mapping
4.2.3 Residue and Defect Mapping
4.2.4 Carrier Scope
4.2.5 Liftback Protocol
4.3 Abstraction Debt
4.3.1 Forgetting as Mathematical Power
4.3.2 Forgotten Data and Recovery Obligations
4.3.3 Irrelevant, Recoverable, and Dangerous Detail
4.3.4 Fake Generality
4.3.5 Closure of Abstraction Debt
4.4 Analogy Debt
4.4.1 Analogy as Route Generator
4.4.2 Shared Primitives and Shared Invariants
4.4.3 Broken Invariants and Failure Boundaries
4.4.4 Analogy Firewall
4.4.5 Analogy as Proof Route or Counterkernel
4.5 Compactness Debt
4.5.1 Finitary Problems and Infinitary Carriers
4.5.2 Qualitative Closure versus Quantitative Control
4.5.3 Extraction Obligations
4.5.4 Ineffective Constants and Hidden Dependence
4.5.5 Compactness as Qualified Certificate
4.6 Asymptotic Debt
4.6.1 Limiting Notation as Compression
4.6.2 Thresholds, Constants, and Lower-Order Terms
4.6.3 Exceptional Sets and Uniformity Ranges
4.6.4 Explicit Use versus Asymptotic Use
4.6.5 Asymptotic Claims as Conditional Export Objects
4.7 Formalization Debt
4.7.1 Formal Derivation versus Mathematical Intent
4.7.2 Theorem-Identity Audit
4.7.3 Definitions, Hypotheses, and Library Dependencies
4.7.4 Automation and Hidden Assumptions
4.7.5 Formal Proof as Certificate after Semantic Alignment
4.8 Computation Debt
4.8.1 Computation as Exploration, Evidence, or Proof Component
4.8.2 Algorithm, Input, Output, and Coverage
4.8.3 Precision, Error Bounds, and Environment Control
4.8.4 Independent Replay and Proof Certificates
4.8.5 Computation after Replay Closure
4.9 Exposition Debt
4.9.1 Simplification as Transmission
4.9.2 Audience Model and Omitted Structure
4.9.3 Diagrams, Analogies, and Nonliteral Reasoning
4.9.4 False Theorem-Memory
4.9.5 Recovery Path to Exact Statement
4.10 Collaboration Debt
4.10.1 Distributed Proof Production
4.10.2 Claim Provenance and Version Control
4.10.3 Parameter Tables, Code, Notes, and Discussions
4.10.4 Social Convergence versus Replay
4.10.5 Integrated Proof Artifact
4.11 AI Generation Debt
4.11.1 AI Output as Mathematical Packet
4.11.2 Semantic Overproduction
4.11.3 Packet Typing and Routing
4.11.4 Independent Verification and Liftback
4.11.5 AI under Certificate Discipline
5. Debt Lifecycle
5.1 Creation
5.2 Registration
5.3 Classification
5.4 Prioritization
5.5 Payment Attempt
5.6 Closure
5.7 Quarantine
5.8 Rejection
5.9 Counterkernel Materialization
5.10 Primitive Renewal
5.11 Hidden Debt versus Registered Debt
6. Debt Object Schema
6.1 Source Claim
6.2 Source Carrier and Target Carrier
6.3 Transport Map
6.4 Debt Type
6.5 Suppressed Data
6.6 Preserved Invariant
6.7 Suspected Loss
6.8 Required Payment
6.9 Current Status
6.10 Proof Obligations
6.11 Counterkernel Risks
6.12 Liftback Status
6.13 Replay Status
6.14 Terminal State
6.15 Debt Object as Actionable Mathematical Record
7. Architecture Modules
7.1 Debt Detector
7.2 Debt Classifier
7.3 Transport Auditor
7.4 Carrier Replacement Ledger
7.5 Abstraction Obligation Engine
7.6 Analogy Firewall
7.7 Compactness Extraction Engine
7.8 Asymptotic Constant Ledger
7.9 Formalization Identity Auditor
7.10 Computation Replay Engine
7.11 Exposition Simplification Ledger
7.12 Collaboration Provenance Engine
7.13 AI Packet Auditor
7.14 Counterkernel Forge
7.15 Certificate Closure Engine
7.16 Module Separation and Typed Failure
7.17 Architecture as Proof Economy
8. Debt Calculus
8.1 Conservation of Obligation
8.2 Additivity under Composition
8.3 Shared Payment and Debt Compression
8.4 Debt Displacement
8.5 Hidden Hypotheses and Reappearing Obligations
8.6 Productive Debt
8.7 Degenerative Debt
8.8 Debt Response under Audit
8.9 Debt Calculus as Mathematical Decision Structure
9. Integration with
9.1 Runtime Overview
9.2 Primitive Failure and Residue Detection
9.3 Carrier Selection as Debt Creation
9.4 Transport as Obligation Generation
9.5 Liftback as Debt Payment
9.6 Counterkernel as Failed-Payment Structure
9.7 Active Debt as Research Program
9.8 Debt Theory as Proof-Economy Engine
10. Export Rules
10.1 Export Allowed
10.2 Restricted Export
10.3 Export Forbidden
10.4 Export Status and Intended Use
10.5 Analogy, Computation, Formalization, Collaboration, and AI under Export Control
10.6 Safe Mathematical Travel
10.7 Export Rules as Permission Architecture
11. Debt Severity Matrix
11.1 Low-Severity Debt
11.2 Medium-Severity Debt
11.3 High-Severity Debt
11.4 Critical Debt
11.5 Context-Dependent Severity
11.6 Severity and Decision Action
11.7 From Epistemic Diagnosis to Governance
12. Output Objects
12.1 Debt Map
12.2 Debt Ledger
12.3 Proof Obligation List
12.4 Transport Audit
12.5 Carrier Loss Map
12.6 Exception Ledger
12.7 Constant Ledger
12.8 Formalization Identity Report
12.9 Computation Replay Report
12.10 Exposition Boundary Note
12.11 Collaboration Provenance Record
12.12 AI Packet Audit
12.13 Counterkernel Candidate
12.14 Liftback Certificate
12.15 Export Decision
12.16 Output Objects as Infrastructure for Reuse
13. Standard Workflow
13.1 Input Artifact and Intended Use
13.2 Claim Extraction
13.3 Carrier Analysis
13.4 Debt Registration
13.5 Classification and Severity Ranking
13.6 Payment Obligation Generation
13.7 Payment Attempt
13.8 Counterkernel Audit
13.9 Liftback Test
13.10 Export Status Assignment
13.11 Workflow as Accountable Mathematical Decision Process
14. Example Pattern: Entropy Proof
14.1 Combinatorial Object to Information-Theoretic Carrier
14.2 Entropy as Proof Carrier rather than Metaphor
14.3 Random Variables, Spread, Dependence, and Mutual Information
14.4 Conditional Copies and Decoupling
14.5 Entropy Inequality to Combinatorial Conclusion
14.6 Representational Obligations
14.7 Entropy Route Failure Modes
14.8 Entropy Proof Closure through Liftback
15. Example Pattern: Ultraproduct Proof
15.1 Finitary Failure Sequence
15.2 Passage to Nonstandard or Limiting Object
15.3 Compactness, Saturation, and Structural Visibility
15.4 Preservation of Relevant Properties
15.5 Finite Recovery and Extraction Debt
15.6 Qualitative Impossibility versus Quantitative Control
15.7 Ultraproduct Failure Modes
15.8 Ultraproduct Proof Closure
16. Example Pattern: AI Proof Sketch
16.1 AI Output as Generated Mathematical Packet
16.2 Claim Extraction
16.3 Packet Typing
16.4 Verification, Repair, Quarantine, and Discard
16.5 Semantic Overproduction
16.6 Independent Proof Reconstruction
16.7 AI Failure as Counterkernel Signal
16.8 AI under Debt Discipline
17. Final Compression
17.1 Every Mathematical Movement Creates Obligation
17.2 Paid Debt as Certificate
17.3 Registered Debt as Research Program
17.4 Impossible Debt as Counterkernel
17.5 Fertile Counterkernel as New Primitive
17.6 Hidden Debt as Fragility
17.7 Laundered Debt as False Authority
17.8 Mathematical Progress as Transport, Debt, Closure, and Theory Birth
18. Hard Locks
18.1 Analogy Is Not Proof
18.2 Compactness Is Not a Bound
18.3 Formalization Is Not Theorem Identity
18.4 Computation Is Not Certificate
18.5 Exposition Is Not Full Theorem
18.6 Collaboration Is Not Replay
18.7 AI Output Is Not Proof
18.8 Asymptotic Notation Is Not Explicit Control
18.9 Carrier Elegance Is Not Liftback
18.10 Public Consensus Is Not Certificate
18.11 Non-Convertibility of Epistemic Statuses
19. Architecture Summary
19.1 Debt Theory as Obligation Calculus
19.2 Epistemological Level
19.3 Systems Level
19.4 Decision-Science Level
19.5 Modern Mathematical Carriers and Hidden Obligations
19.6 Proof Economy and Export Strength
19.7 Final Criterion for Mathematical Exportability
19.8 Debt Theory as Internal Architecture of Reliable Mathematical Knowledge
NEW MATHS DEBT THEORY
Architecture Document
0. Definition
DEBT_THEORY :=
theory_of_all_unpaid_obligations_created_by(
mathematical_transport,
carrier_replacement,
abstraction,
analogy,
compactness,
asymptotics,
formalization,
computation,
exposition,
collaboration,
institutionalization,
AI_generation,
proof_compression,
theorem_reuse
)
Debt is not error. Debt is the exact obligation created whenever mathematics moves faster than its certificate ecology.
A theorem, method, proof, analogy, formalization, computation, or exposition creates debt when it exports a claim across carriers without fully paying the cost of transport, constants, hypotheses, exceptional cases, semantic alignment, replayability, or liftback.
MATH_DEBT := exported_structure
− paid_certificate_obligations
Debt Theory does not reject abstraction. It audits abstraction.
1. Core Thesis
Mathematics advances by transport:
old_carrier → new_carrier → stronger_visibility → theorem_pressure
But every transport creates obligations:
transport ⇒ debt
debt unpaid ⇒ hidden fragility
debt paid ⇒ certificate power
debt impossible ⇒ counterkernel / boundary genesis
Thus:
NEW_MATHS_DEBT_THEORY :=
transport_audit
+ carrier_debt_ledger
+ abstraction_obligation_calculus
+ liftback_verification
+ counterkernel_materialization
+ certificate_closure_runtime
2. Debt Sources
DEBT_SOURCES :=
TRANSPORT_DEBT
∨ CARRIER_REPLACEMENT_DEBT
∨ ABSTRACTION_DEBT
∨ ANALOGY_DEBT
∨ COMPACTNESS_DEBT
∨ ASYMPTOTIC_DEBT
∨ FORMALIZATION_DEBT
∨ COMPUTATION_DEBT
∨ EXPOSITION_DEBT
∨ COLLABORATION_DEBT
∨ AI_GENERATION_DEBT
∨ INSTITUTIONAL_DEBT
Each source has a standard obligation profile.
3. Debt Classes
3.1 Transport Debt
Created when a claim is moved between mathematical domains.
TRANSPORT_DEBT :=
claim_A in carrier_A
transported_to carrier_B
without fully proving:
primitive_alignment
invariant_preservation
loss_accounting
exceptional_case_mapping
liftback
Examples:
combinatorics → entropy
arithmetic → zeta
finite → ultraproduct
PDE → compactness
geometry → algebraic partition
random matrix → zeta analogy
Required payment:
PAY_TRANSPORT :=
define source primitive
define target primitive
prove invariant survives
quantify loss
identify forbidden residue
prove liftback
3.2 Carrier Replacement Debt
Created when the original object is replaced by a more powerful representation.
CARRIER_REPLACEMENT_DEBT :=
object O
replaced_by carrier C
where C exposes structure
but may suppress native constraints of O
Payment:
PAY_CARRIER :=
carrier_scope
native_constraint_map
residue_map
defect_map
liftback_certificate
Failure mode:
beautiful_carrier
without_native_liftback
⇒ false_export
3.3 Abstraction Debt
Created when details are suppressed to reveal structure.
ABSTRACTION_DEBT :=
removed_detail
+ preserved_pattern
+ unproven_recovery_path
Payment:
PAY_ABSTRACTION :=
specify forgotten_data
classify recoverable_vs_irrecoverable
prove abstraction faithful enough
record boundary cases
Abstraction is valid only if the forgotten structure is either irrelevant, recoverable, or explicitly quarantined.
3.4 Analogy Debt
Created when one structure is used as a guide for another.
ANALOGY_DEBT :=
A resembles B
⇒ route suggested
but transport not certified
Payment:
PAY_ANALOGY :=
shared primitive
shared invariant
broken invariant
failure boundary
counterexample search
licensed transport map
Hard rule:
analogy ≠ evidence
analogy = route-generator
3.5 Compactness Debt
Created when a finite/quantitative problem is solved through an infinitary or limiting object.
COMPACTNESS_DEBT :=
finite_parameter_storm
→ limit_object
→ qualitative_closure
− quantitative_extraction
Payment:
PAY_COMPACTNESS :=
growth bounds
effective constants
extraction procedure
finite recovery
exceptional sequence audit
Unpaid compactness debt appears as:
nonconstructive existence
ineffective constants
hidden ultrafilter dependence
lost quantitative range
3.6 Asymptotic Debt
Created by big-O, little-o, limiting regimes, genericity, and “sufficiently large.”
ASYMPTOTIC_DEBT :=
theorem_valid_as n→∞
but obligations hidden in:
threshold
constants
lower_order_terms
range
uniformity
exceptional_sets
Payment:
PAY_ASYMPTOTIC :=
explicit threshold
explicit constants
uniformity domain
error propagation
dependency ledger
Hard rule:
asymptotic_statement ≠ explicit_theorem
3.7 Formalization Debt
Created when a theorem is encoded into a proof assistant.
FORMALIZATION_DEBT :=
informal_theorem
→ formal_statement
where semantic identity may fail
Payment:
PAY_FORMALIZATION :=
theorem_identity_audit
hypothesis_alignment
definition_alignment
library_dependency_ledger
automation_trust_boundary
human_readback
Failure mode:
formal_proof_of_wrong_statement
3.8 Computation Debt
Created by numerical evidence, exhaustive search, symbolic computation, machine learning, or computer-assisted proof.
COMPUTATION_DEBT :=
computed_output
− certified_replay
Payment:
PAY_COMPUTATION :=
input specification
algorithm specification
precision/error bounds
reproducible environment
independent implementation
proof-producing certificate when possible
Hard rule:
computation ≠ theorem
unless replay + error + coverage close
3.9 Exposition Debt
Created when a result is simplified for communication.
EXPOSITION_DEBT :=
explanation
− exact dependency/proof/exception structure
Payment:
PAY_EXPOSITION :=
audience model
simplification ledger
analogy firewall
missing hypothesis tag
exact theorem pointer
misconception audit
Exposition can create false understanding if it exports intuition without boundary conditions.
3.10 Collaboration Debt
Created when proof work is distributed across people, comments, code, documents, and parameter tables.
COLLABORATION_DEBT :=
distributed_claim_fragments
− integrated_replay_certificate
Payment:
PAY_COLLABORATION :=
claim registry
dependency graph
version history
contributor provenance
parameter ledger
unresolved gap list
final replay document
Hard rule:
group_agreement ≠ proof
wiki_summary ≠ certificate
3.11 AI Generation Debt
Created when AI proposes definitions, lemmas, proofs, analogies, code, or exposition.
AI_DEBT :=
generated_candidate
− semantic/certificate alignment
Payment:
PAY_AI :=
primitive typing
claim extraction
hallucination audit
proof obligation list
independent verification
liftback check
human theorem-identity audit
Hard rule:
AI_output = packet
not certificate
4. Debt Lifecycle
DEBT_LIFECYCLE :=
creation
→ registration
→ classification
→ prioritization
→ payment_attempt
→ closure ∨ quarantine ∨ counterkernel ∨ boundary_genesis
States:
DEBT_STATE :=
UNREGISTERED
REGISTERED
ROUTED
PARTIALLY_PAID
PAID
QUARANTINED
CK_MATERIALIZED
BOUNDARY_GENESIS
5. Debt Object Schema
DebtObject :=
{
id,
source_claim,
source_carrier,
target_carrier,
transport_map,
debt_type,
created_by,
suppressed_data,
preserved_invariant,
suspected_loss,
required_payment,
current_status,
proof_obligations,
counterkernel_risks,
liftback_status,
replay_status,
terminal_state
}
Terminal states:
TERMINAL :=
CERTIFIED
∨ REJECTED
∨ QUARANTINED
∨ CK_MATERIALIZED
∨ NEW_PRIMITIVE_REQUIRED
6. Architecture Modules
DEBT_THEORY_ARCHITECTURE :=
DEBT_DETECTOR
⊕ DEBT_CLASSIFIER
⊕ TRANSPORT_AUDITOR
⊕ CARRIER_REPLACEMENT_LEDGER
⊕ ABSTRACTION_OBLIGATION_ENGINE
⊕ ANALOGY_FIREWALL
⊕ COMPACTNESS_EXTRACTION_ENGINE
⊕ ASYMPTOTIC_CONSTANT_LEDGER
⊕ FORMALIZATION_IDENTITY_AUDITOR
⊕ COMPUTATION_REPLAY_ENGINE
⊕ EXPOSITION_SIMPLIFICATION_LEDGER
⊕ COLLABORATION_PROVENANCE_ENGINE
⊕ AI_PACKET_AUDITOR
⊕ COUNTERKERNEL_FORGE
⊕ CERTIFICATE_CLOSURE_ENGINE
7. Module Specifications
7.1 DEBT_DETECTOR
Input:
claim/proof/method/analogy/computation/formalization/exposition
Output:
list of DebtObjects
Detection triggers:
uses analogy
uses compactness
uses asymptotic notation
changes carrier
suppresses constants
invokes computation
uses AI output
uses informal diagram
uses public collaboration state
uses theorem from adjacent field
7.2 DEBT_CLASSIFIER
Classifies debt into:
semantic
logical
quantitative
computational
formal
expository
institutional
collaborative
carrier
transport
Severity:
LOW :=
local cleanup needed
MEDIUM :=
theorem usable but export restricted
HIGH :=
theorem not safely reusable
CRITICAL :=
possible false theorem / wrong carrier / hidden CK
7.3 TRANSPORT_AUDITOR
Checks:
source primitive
target primitive
transport map
invariant survival
loss function
exception transfer
reverse liftback
Fails if:
claim survives only in target carrier
but not original object
7.4 CARRIER_REPLACEMENT_LEDGER
Records what the new carrier reveals and what it hides.
CarrierReplacement :=
old_carrier
new_carrier
exposed_structure
suppressed_structure
native_constraints
residue
liftback_protocol
7.5 ABSTRACTION_OBLIGATION_ENGINE
For every abstraction, asks:
what was forgotten?
can it be recovered?
is it irrelevant?
is it dangerous?
does it create fake generality?
Output:
faithful_abstraction
∨ lossy_abstraction
∨ invalid_abstraction
∨ new_boundary_object
7.6 ANALOGY_FIREWALL
Prevents analogy from being laundered into evidence.
ANALOGY_FIREWALL :=
shared_structure
∧ broken_structure
∧ failure_boundary
∧ counterexample_search
∧ licensed_export_only
7.7 COMPACTNESS_EXTRACTION_ENGINE
Converts qualitative compactness proof into finite-use certificate.
COMPACTNESS_EXTRACTION :=
infinitary_result
→ finite_bound
→ growth_function
→ explicit_parameter_range
→ replayable theorem
If extraction impossible:
mark theorem as qualitative_only
7.8 ASYMPTOTIC_CONSTANT_LEDGER
Tracks:
O-constants
thresholds
exceptional sets
uniformity ranges
dependency chains
lower-order terms
Used especially for:
analytic_number_theory
PDE
additive_combinatorics
probabilistic_combinatorics
sieve_theory
random_matrix_limits
7.9 FORMALIZATION_IDENTITY_AUDITOR
Checks whether the formal theorem is the intended theorem.
FORMALIZATION_IDENTITY :=
informal_statement
≡ formal_statement
under:
definitions
hypotheses
universe levels
coercions
hidden assumptions
library lemmas
7.10 COMPUTATION_REPLAY_ENGINE
Checks:
algorithm
input
output
precision
coverage
environment
independent rerun
proof certificate
Computation becomes theorem support only after replay closure.
7.11 EXPOSITION_SIMPLIFICATION_LEDGER
Tracks what was simplified away.
EXPOSITION_LEDGER :=
omitted hypotheses
omitted exceptions
analogy limits
nonliteral diagrams
dependency shortcuts
informal terminology
Purpose:
prevent intuition from becoming fake theorem-memory
7.12 COLLABORATION_PROVENANCE_ENGINE
For Polymath-style or distributed proof:
COLLAB_LEDGER :=
claim
owner
dependency
version
parameter
code
discussion
open gap
final replay
7.13 AI_PACKET_AUDITOR
Classifies AI output:
AI_PACKET :=
conjecture
proof_sketch
lemma_candidate
analogy
code
formalization_fragment
exposition
counterexample_candidate
Routes each packet to:
verify
repair
quarantine
discard
materialize_CK
7.14 COUNTERKERNEL_FORGE
When debt cannot be paid, search for the obstruction that explains why.
CK_FORGE :=
unpaid_obligation
→ minimal_failure_model
→ obstruction_object
→ counterexample_or_boundary_theory
Outputs:
artifact
artifact_class
impossibility_reason
new primitive
7.15 CERTIFICATE_CLOSURE_ENGINE
Final export gate.
CERT_CLOSE :=
all required debts paid
∧ liftback complete
∧ replay possible
∧ counterkernels excluded
∧ theorem identity stable
Otherwise:
NO_EXPORT
8. Debt Calculus
Debt is additive under composition but can compress under shared payment.
D(f∘g) ≤ D(f)+D(g)
Shared carrier payment:
if payment P closes debts d₁,...,dₙ
then:
D_total decreases by shared_cert_power(P)
Debt conservation principle:
structure cannot be transported for free
Debt displacement principle:
unpaid debt does not vanish;
it reappears as:
exception
hidden hypothesis
failed liftback
nonuniform constant
wrong theorem identity
counterexample
irreproducible computation
exposition misconception
Debt-positive theorem:
Any nontrivial carrier replacement creates at least one obligation:
invariant
loss
exception
liftback
Debt-negative theorem:
A fully native proof with no carrier change can still create exposition/formalization/collaboration debt,
but not transport debt.
9. Integration
:=
wrongness
→ carrier
→ transport
→ residue
→ liftback
→ CERT ∨ CK ∨ ACTIVE_DEBT
DEBT_THEORY adds:
every arrow has obligations
Expanded runtime:
DEBT :=
primitive_failure
→ residue_detection
→ carrier_selection
→ transport
→ debt_registration
→ debt_payment
→ counterkernel_audit
→ liftback
→ export_gate
Debt Theory upgrades from discovery engine to proof-economy engine.
10. Export Rules
Allowed export:
EXPORT_ALLOWED iff:
theorem_identity stable
∧ transport obligations paid
∧ carrier loss audited
∧ constants/ranges sufficient
∧ exceptions declared
∧ computation/formalization replayed
∧ exposition limits tagged
Restricted export:
EXPORT_RESTRICTED iff:
theorem usable only in declared regime
∧ debts registered
∧ downstream user warned
Forbidden export:
EXPORT_FORBIDDEN iff:
analogy used as evidence
∨ compactness lacks required liftback
∨ computation unreplayed
∨ formalization proves wrong object
∨ asymptotic claim used explicitly
∨ collaboration state mistaken for proof
∨ AI packet treated as certificate
11. Debt Severity Matrix
LOW:
local exposition debt
minor constant tracking
recoverable notation mismatch
MEDIUM:
missing range
unstated hypothesis
informal computational support
analogy boundary unclear
HIGH:
no liftback
compactness ineffective where explicit bound needed
formal theorem identity unclear
major exceptional set hidden
CRITICAL:
wrong carrier
false theorem risk
irreproducible computation used essentially
AI hallucination embedded
counterkernel likely
12. Output Objects
Debt Theory produces:
DEBT_MAP
DEBT_LEDGER
PROOF_OBLIGATION_LIST
TRANSPORT_AUDIT
CARRIER_LOSS_MAP
EXCEPTION_LEDGER
CONSTANT_LEDGER
LIFTBACK_CERTIFICATE
CK_CANDIDATE
EXPORT_DECISION
13. Standard Workflow
INPUT:
theorem/proof/method/analogy/computation/formalization/exposition
STEP 1:
identify carrier changes
STEP 2:
register debts
STEP 3:
classify severity
STEP 4:
generate payment obligations
STEP 5:
attempt payment
STEP 6:
audit counterkernels
STEP 7:
test liftback
STEP 8:
decide export status
Output:
CERTIFIED
∨ RESTRICTED_EXPORT
∨ ACTIVE_DEBT
∨ COUNTERKERNEL
∨ NEW_MATH_REQUIRED
14. Example Pattern: Entropy Proof
set_family
→ random_variable
→ entropy
→ conditional_copy
→ information_inequality
→ combinatorial conclusion
Debt created:
finite_range
spread condition
support recovery
entropy inequality validity
random-variable-to-set liftback
Export valid only if:
entropy statement
→ exact set-theoretic theorem
15. Example Pattern: Ultraproduct Proof
finite family of structures
→ ultraproduct
→ limit theorem
→ contradiction
→ finite theorem
Debt created:
ultrafilter dependence
quantitative extraction
growth function
effective bound
finite recovery
Export valid only if:
qualitative result sufficient
∨ extraction performed
16. Example Pattern: AI Proof Sketch
AI suggests lemma L
→ human recognizes route
→ formal/counterexample audit
→ proof obligation list
→ verified lemma
Debt created:
hallucination
semantic mismatch
hidden dependency
wrong theorem identity
unproven step
Export valid only if:
AI packet becomes independently replayable proof
17. Final Compression
DEBT_THEORYΩ :=
∀ move M in mathematics:
M creates obligation O
O unpaid ⇒ debt
debt hidden ⇒ fragility
debt routed ⇒ proof ecology
debt paid ⇒ certificate
debt impossible ⇒ counterkernel
counterkernel fertile ⇒ new maths
MATH_PROGRESS :=
create useful debt
pay decisive debt
materialize impossible debt
convert residue into carrier
18. Hard Locks
LOCKS :=
analogy ≠ proof
compactness ≠ bound
formalization ≠ theorem identity
computation ≠ certificate
exposition ≠ full theorem
collaboration ≠ replay
AI output ≠ proof
asymptotic ≠ explicit
carrier elegance ≠ liftback
public consensus ≠ certificate
19. Architecture Summary
NEW_MATHS_DEBT_THEORY :=
obligation calculus for mathematical transport.
It measures:
what was moved,
what was hidden,
what was lost,
what must be paid,
what cannot be paid,
what obstruction is born.
Its purpose:
prevent theorem laundering,
expose hidden fragility,
convert unpaid proof obligations into explicit research targets,
distinguish valid abstraction from fake export,
and turn impossible debt into new mathematics.
NEW MATHS DEBT THEORY
Architecture Document
0. Definition
Debt Theory is the systematic study of unpaid obligations created by mathematical movement. Mathematics does not remain in one register. It translates problems into new carriers, abstracts away detail, borrows analogies, invokes limiting regimes, compresses proof into notation, delegates search to computation, formalizes informal arguments, distributes reasoning across collaborators, and explains difficult structures through simplified expository surfaces. Each such movement can be legitimate, powerful, and necessary. None is free. Every movement creates an obligation to show that what was preserved is sufficient, what was lost is harmless, what was assumed is declared, what was approximated is controlled, and what was exported remains true in the original domain.
Mathematical debt is therefore not synonymous with error. Error is a failed obligation; debt is an obligation incurred by a valid or potentially valid act of proof-production, theory-building, or knowledge-transfer. A proof can be correct and still carry expository debt. A compactness argument can be correct and still carry quantitative debt. A formal proof can be mechanically valid and still carry theorem-identity debt if the formalized statement does not match the intended mathematical claim. A computational result can be reliable inside its execution environment and still carry replay debt. Debt marks the difference between local validity and global usability.
Debt Theory treats mathematical knowledge as an economy of transport and obligation. It records what is owed when a claim moves across carriers, audiences, machines, institutions, and proof ecologies. Its central object is not the theorem alone, but the theorem together with the unpaid conditions of its safe reuse. A mathematical result becomes fully exportable only when its debts are either paid, explicitly bounded, quarantined, or transformed into a material obstruction. The theory therefore converts hidden fragility into explicit structure.
1. Core Thesis
Mathematics advances by moving problems into forms where latent structure becomes visible. A combinatorial family becomes a random variable; a question about primes becomes a statement about a Dirichlet series; a finitary problem becomes an ultraproduct limit; a nonlinear PDE becomes an energy and compactness problem; a geometric incidence question becomes an algebraic partition; an arithmetic pattern becomes a nilsystem factor. These conversions are not peripheral techniques. They are the central mechanism by which difficult mathematics becomes tractable.
The core thesis of Debt Theory is that every such conversion creates an obligation. The new carrier exposes structure, but it also suppresses native constraints. The proof gains leverage, but incurs a duty to return to the original problem with losses, exceptions, constants, hypotheses, and semantic identity accounted for. Mathematical progress is therefore not only discovery of new structures; it is disciplined payment of the debts created by those structures.
This changes the epistemic unit of analysis. The relevant question is not merely whether a proof exists, but whether the route by which the proof exists is reusable, explicit, faithful, and stable under transport. A theorem proven by compactness carries different decision value from a theorem with explicit constants. A theorem proven by analogy-guided exploration carries different status from the analogy itself. A theorem embedded in a formal library carries different obligations from the same theorem used in informal reasoning. Debt Theory supplies the accounting system that distinguishes these statuses without collapsing them into a crude valid/invalid binary.
The thesis closes in a structural equivalence: proof power equals transported structure minus unpaid debt. Mathematics grows by generating useful debt, paying decisive debt, and materializing impossible debt as new mathematics.
2. Debt Sources
Debt arises wherever mathematical work crosses a boundary. The primary sources are transport, carrier replacement, abstraction, analogy, compactness, asymptotics, formalization, computation, exposition, collaboration, AI generation, institutionalization, and theorem reuse. Each source is a different mode of compression or displacement. Each mode suppresses some information in order to reveal or manipulate other information. Debt is the obligation to justify that this suppression does not corrupt the claim being exported.
Transport debt arises from movement between domains. Carrier replacement debt arises when the original object is represented by a more powerful but non-identical object. Abstraction debt arises when particulars are removed in favor of general pattern. Analogy debt arises when resemblance directs reasoning before transport is certified. Compactness debt arises when a finite problem is solved through an infinitary object. Asymptotic debt arises when thresholds, constants, lower-order terms, and exceptional sets are suppressed. Formalization debt arises when informal mathematical intent is encoded in a formal system. Computation debt arises when machine output supports a claim without full replay and error closure. Exposition debt arises when simplification creates intuition at the cost of exact boundary conditions. Collaboration debt arises when reasoning is distributed before it is integrated into a replayable proof. AI generation debt arises when candidate mathematical packets are produced without independent certificate. Institutional debt arises when prestige, consensus, publication status, or citation structure substitutes for direct obligation accounting.
The sources differ, but they share one invariant: a mathematical object has been made easier to see, use, communicate, verify, or manipulate by moving part of its burden elsewhere. Debt Theory identifies where the burden went.
3. Debt Classes
A debt class is a typed obligation profile. It specifies what was moved, what was hidden, what can fail, and what kind of payment closes the obligation. Classification prevents category error. A missing constant is not the same as an invalid analogy; an unreplayed computation is not the same as an ineffective compactness proof; a misleading exposition is not the same as a false theorem. Mathematical systems fail when these distinctions are blurred.
Debt classes are epistemic control structures. They allow a proof ecology to distinguish local proof validity, theorem identity, reusable explicitness, computational reproducibility, audience safety, and institutional trust. A theorem can be logically closed while remaining decision-poor for applications because its constants are ineffective. An exposition can be pedagogically useful while being unsafe as a theorem source. A computational search can be excellent as conjecture pressure and invalid as proof support. The class determines the correct discharge procedure.
The function of classification is not bureaucracy. It is compression of risk into exact form. Once a debt is typed, it can be routed: prove a missing lemma, extract a bound, audit a formalization, reproduce a computation, sharpen an analogy boundary, quarantine an informal explanation, or forge the counterkernel that shows the debt cannot be paid. Classification turns vague unease into a finite proof economy.
3.1 Transport Debt
Transport debt is created when a claim is moved from one mathematical carrier to another. This is the most basic debt of modern mathematics because powerful proof methods often operate by changing the native medium of the problem. Arithmetic is transported to analysis through zeta functions; combinatorics is transported to entropy; finitary structure is transported to ultralimits; group theory is transported to geometry; PDE behavior is transported to compactness and rigidity. The new carrier reveals a tractable invariant, but the original claim does not automatically follow from success in the new domain.
Transport debt consists of primitive alignment, invariant preservation, loss accounting, exception transfer, and liftback. Primitive alignment requires showing that the source and target objects encode the same relevant operation, relation, or obstruction. Invariant preservation requires proving that the feature used in the target carrier corresponds to a feature that matters in the source carrier. Loss accounting records distortion introduced by smoothing, limiting, averaging, localization, relaxation, or completion. Exception transfer ensures that exceptional cases in the target do not become invisible failures in the source. Liftback proves that the target conclusion returns to the original problem in the intended form.
Unpaid transport debt is the source of many false exports. A theorem valid for a smoothed model is used for the unsmoothed problem. A limiting object satisfies a qualitative property that does not give a finite bound. A random-matrix analogy matches local statistics but is treated as arithmetic evidence. A continuous relaxation solves a problem whose discrete integrality constraints never returned. Transport debt is paid only when the route back is as explicit as the route out.
3.2 Carrier Replacement Debt
Carrier replacement debt arises when an object is replaced by another object that is more analytically or conceptually powerful. A set family becomes an entropy distribution; a graph becomes an operator; a group becomes a Lie model; a finite configuration becomes a measure; a sequence becomes a dynamical system; a proof becomes a formal term. The replacement is valuable because it exposes a structure not visible in the original presentation. It is dangerous because the replacement may omit native constraints.
The debt of carrier replacement is the obligation to characterize both revelation and suppression. The new carrier reveals symmetries, compactness, convexity, spectral structure, probabilistic independence, or categorical functoriality. It may suppress integrality, finiteness, ordering, definability, computability, boundary behavior, exceptional configurations, or semantic intent. A faithful carrier replacement preserves enough structure to prove the desired theorem and has a controlled liftback to the native object. A lossy carrier replacement can still be useful if its loss is explicit and does not touch the exported claim. An invalid carrier replacement proves the right-looking theorem about the wrong object.
The central discipline is carrier scope. Every replacement must state the class of problems for which it is faithful, the residues it cannot see, and the exact procedure by which conclusions return to the original domain. A beautiful carrier without native liftback is not a proof environment; it is a projection.
3.3 Abstraction Debt
Abstraction debt is created when mathematical detail is deliberately forgotten. Abstraction is the engine of generality: it removes accidental features so that structural invariants can be manipulated. It turns examples into classes, calculations into morphisms, and techniques into theories. But abstraction also creates a recovery problem. The forgotten data must be irrelevant, recoverable, or explicitly excluded.
The debt of abstraction is paid by specifying what was forgotten and why the forgetting is safe. A topological abstraction forgets metric data; an algebraic abstraction forgets representation-specific details; a categorical abstraction forgets elementwise construction; an asymptotic abstraction forgets finite thresholds; a model-theoretic abstraction forgets computational explicitness. Each act can be correct inside its intended regime and wrong outside it. Fake generality arises when abstraction suppresses a condition that later reappears as an exception, obstruction, or counterexample.
Abstraction is valid when it increases structural control without laundering away the problem’s native constraints. It is invalid when the abstract theorem is exported as if it retained details that it deliberately discarded. The correct endpoint of abstraction is not vagueness but sharper obligation: the more general the structure, the more explicit the boundary of relevance must become.
3.4 Analogy Debt
Analogy debt is created when one mathematical structure guides reasoning about another before a transport map is certified. Analogy is indispensable for discovery because it proposes routes before proof exists. Function fields guide number fields; random matrices guide zeta statistics; entropy guides combinatorics; geometry guides group theory; physics guides PDE and topology. But analogy is a route generator, not evidence.
The debt of analogy is the obligation to identify shared primitives, shared invariants, broken invariants, failure boundaries, and counterexamples. A productive analogy has a precise overlap region and a precise fracture region. It shows what can be transported and what must be blocked. An unlicensed analogy becomes theorem laundering when resemblance is treated as support for a claim in the target domain. A licensed analogy becomes mathematics when the shared structure is formalized and the broken structure is quarantined.
Analogy debt is paid by converting likeness into a transport object or by exposing the reason transport fails. In both cases the analogy has done useful work. It either becomes a proof route or materializes a counterkernel. The only unacceptable state is analogy that continues to exert persuasive force after its obligations have been identified but not discharged.
3.5 Compactness Debt
Compactness debt arises when a quantitative or finitary problem is resolved through an infinitary limit, ultraproduct, compactness theorem, weak convergence argument, or contradiction by minimal counterexample. Compactness is powerful because it converts uncontrolled finite complexity into a structured limiting object. It removes parameter noise and reveals rigidity. Its debt is that qualitative closure in the limit does not automatically yield quantitative control in the original problem.
The obligation created by compactness is extraction. One must determine whether the result requires explicit bounds, and if so recover thresholds, constants, growth functions, moduli of continuity, rates of convergence, or finite witnesses. Ultraproduct proofs hide dependence inside the ultrafilter or limiting contradiction. Weak compactness may lose strong convergence. Profile decomposition may reveal bubbles while leaving interaction terms to be controlled. Minimal-counterexample arguments may prove nonexistence without describing usable margins.
Compactness debt is paid when the finite theorem needed downstream is recovered in a form strong enough for use. If only qualitative existence is required, the debt can be declared harmless. If applications require explicit ranges, the debt remains active until extraction is complete. Compactness proves that a structure cannot escape; extraction shows how far it had to run before it was caught.
3.6 Asymptotic Debt
Asymptotic debt is created by limiting language: big-O, little-o, sufficiently large, generic, almost all, negligible, high probability, and limiting distribution. Asymptotics are not defective; they are essential for identifying dominant structure. Their debt lies in suppressed thresholds, constants, dependencies, exceptional sets, lower-order terms, and uniformity ranges.
This debt becomes critical when an asymptotic theorem is exported into a domain requiring explicit control. Analytic number theory, probabilistic combinatorics, PDE estimates, algorithmic complexity, random matrix limits, and quantitative geometry all depend on whether constants are effective and ranges usable. A statement true for sufficiently large values can be useless if the threshold is beyond the regime of interest. A uniform estimate is stronger than a pointwise asymptotic. An exceptional set can be negligible in density but fatal for a structured application.
Asymptotic debt is paid by constant ledgers, threshold extraction, dependency tracking, error propagation, and declared uniformity. It is not necessary to make every theorem explicit. It is necessary to prevent implicit asymptotic claims from being used as explicit ones. The asymptotic symbol is a promissory note; Debt Theory records whether payment is required.
3.7 Formalization Debt
Formalization debt arises when informal mathematical reasoning is encoded into a proof assistant or formal logical system. Formalization increases reliability at the level of syntactic derivation. It does not automatically guarantee that the formal statement is the intended theorem, that the definitions match mathematical practice, or that the resulting object has the same conceptual identity as the informal target.
The central obligation is theorem identity. A formal proof is only as valuable as the match between the formal proposition and the mathematical claim it is meant to certify. Definitions, coercions, universe levels, implicit hypotheses, typeclass behavior, library lemmas, choice principles, computability assumptions, and hidden conventions can alter the theorem’s meaning. A machine can verify a proof of a statement that no mathematician intended to assert. Such a result is formally valid and epistemically misaligned.
Formalization debt is paid by bidirectional audit: the informal theorem must be mapped into the formal system, and the formal theorem must be read back into ordinary mathematical language. Library dependencies and automation boundaries must be recorded. The endpoint is not merely a checked term, but a stable identity between human mathematical intent and machine-verifiable structure.
3.8 Computation Debt
Computation debt is created when numerical calculation, exhaustive search, symbolic computation, SAT/SMT solving, computer algebra, simulation, machine learning, or automated exploration supports a mathematical conclusion. Computation can discover examples, eliminate cases, optimize constants, test conjectures, and serve as a proof component. Its debt is replay, coverage, precision, and interpretation.
A computed result depends on input specification, algorithmic correctness, implementation fidelity, hardware and software environment, numerical precision, stopping criteria, random seeds, data preprocessing, and output interpretation. Exhaustive search requires proof that the search space is complete and that pruning did not remove valid cases. Numerical evidence requires certified error bounds if it supports proof. Symbolic computation requires independent verification of algebraic transformations. Machine-learning output requires separation between pattern detection and theorem support.
Computation debt is paid by reproducible environments, independent implementations, formal certificates where possible, interval or exact arithmetic where needed, and clear separation between conjectural pressure and proof obligation. Computation becomes theorem support only when its execution can be replayed and its error model is closed. Otherwise it remains evidence, exploration, or packet generation.
3.9 Exposition Debt
Exposition debt is created whenever mathematics is simplified for transmission. Explanation is not a neutral copy of proof. It selects an audience model, suppresses dependencies, replaces formal conditions with intuition, uses diagrams, analogies, metaphors, historical narrative, or partial examples, and foregrounds what aids comprehension. This is necessary for communication, but it creates the risk that intuition will be mistaken for theorem.
The obligation of exposition is boundary marking. The reader must be able to distinguish exact theorem from motivating picture, proof from analogy, hypothesis from convenience, generic case from full result, and diagrammatic intuition from formal argument. Good exposition does not eliminate complexity by pretending it is absent; it stages complexity so that the reader can re-enter the exact theorem without carrying false simplifications.
Exposition debt is paid by declaring omitted hypotheses, analogy limits, nonliteral diagrams, dependency shortcuts, and precise theorem references. A simplified explanation is successful when it creates accurate access to the full structure. It fails when it produces durable misconception. Exposition is therefore part of the proof ecology: it governs how mathematical knowledge survives transmission.
3.10 Collaboration Debt
Collaboration debt is created when mathematical work is distributed across people, notes, comments, code, talks, messages, parameter tables, drafts, and institutional memory. Distributed proof ecology increases search power and error detection, but it fragments ownership, versioning, dependencies, and replay. A result can be socially accepted within a collaboration before it exists as an integrated proof object.
The obligation of collaboration is provenance and synthesis. Every claim fragment must be assigned a dependency status, contributor history, version, parameter value, computational support, unresolved gap state, and final replay location. Public agreement, comment-thread convergence, and wiki consolidation are not certificates by themselves. They are intermediate states in proof production.
Collaboration debt is paid when the distributed residue is converted into a linear or formally navigable proof whose dependencies can be replayed without relying on the social memory of the group. The mature collaborative theorem is not merely jointly believed; it is externally executable. Collaboration accelerates discovery, but final knowledge requires replayable integration.
3.11 AI Generation Debt
AI generation debt is created when an artificial system proposes conjectures, lemmas, proof sketches, analogies, code, formalization fragments, examples, counterexamples, or exposition. AI systems can search large semantic neighborhoods, recombine known patterns, surface candidate methods, and expose plausible routes. Their output is not automatically attached to theorem identity, proof validity, or semantic responsibility.
The obligation of AI output is packet audit. Each generated artifact must be typed: conjecture, lemma candidate, proof sketch, analogy, computation, formal fragment, exposition, or counterexample candidate. It must then be routed to verification, repair, quarantine, discard, or counterkernel extraction. The central danger is not that AI is always wrong; it is that AI can generate locally coherent mathematical language that lacks a certified connection to the intended claim.
AI debt is paid by primitive typing, claim extraction, hallucination audit, dependency identification, independent proof, formal or human replay, and liftback to the original problem. AI becomes useful when treated as a generator of mathematical packets under a certificate regime. It becomes dangerous when fluent generation is mistaken for closure.
4. Debt Lifecycle
The lifecycle of debt begins with creation and ends in certification, restriction, quarantine, counterkernel materialization, or new primitive formation. Creation occurs whenever a mathematical move suppresses an obligation. Registration converts implicit risk into an explicit object. Classification identifies the kind of obligation. Prioritization determines whether payment matters for the intended export. Payment attempts discharge the debt through proof, computation, extraction, formal audit, expository clarification, or dependency repair. Closure occurs only when the debt no longer threatens the claim’s use.
Not all debts should be paid immediately. Some are irrelevant to a theorem’s current regime. Some are too expensive relative to benefit. Some are harmless if the result is marked qualitative, asymptotic, informal, computational, or conjectural. The lifecycle therefore includes quarantine: a debt can remain active but contained. Quarantine is valid only when downstream users are prevented from treating the result as debt-free.
The most fertile terminal state is counterkernel materialization. When a debt cannot be paid, the failure often reveals a structural obstruction. The obstruction can invalidate a route, generate a counterexample, or force a new theory. In this sense, debt is not merely administrative residue. It is a discovery mechanism. A stubborn unpaid obligation marks the boundary where old mathematics lacks the carrier required to continue.
5. Debt Object Schema
A DebtObject is the atomic record of obligation. It binds a claim to the conditions under which that claim was moved, compressed, simplified, computed, formalized, or exported. Its fields identify the source claim, source carrier, target carrier, transport map, debt type, creator of the debt, suppressed data, preserved invariant, suspected loss, required payment, current status, proof obligations, counterkernel risks, liftback status, replay status, and terminal state.
The importance of the schema lies in its refusal to treat proof risk as a vague impression. A debt that cannot be named cannot be routed. A missing hypothesis, a hidden constant, a formalization mismatch, and an unreplayed computation become different objects with different closure conditions. The schema makes mathematical responsibility local without losing global context. It records not only what is believed, but what must still be true for that belief to be safely used.
The terminal states are certified, rejected, quarantined, counterkernel materialized, or new primitive required. Certification means all relevant obligations have been paid for the declared export. Rejection means the debt exposed failure. Quarantine means the claim remains usable only under restricted interpretation. Counterkernel materialization means the unpaid debt has become an obstruction object. New primitive required means the existing vocabulary cannot express the failure or closure condition adequately. The schema closes conceptually because every debt is forced into a status that governs reuse.
6. Architecture Modules
Debt Theory requires an architecture because mathematical debt is distributed across many layers of practice. The DEBT_DETECTOR identifies obligation triggers. The DEBT_CLASSIFIER types them. The TRANSPORT_AUDITOR checks movement between carriers. The CARRIER_REPLACEMENT_LEDGER records revelation and suppression. The ABSTRACTION_OBLIGATION_ENGINE evaluates forgotten structure. The ANALOGY_FIREWALL prevents resemblance from becoming evidence. The COMPACTNESS_EXTRACTION_ENGINE recovers finite content from limit arguments. The ASYMPTOTIC_CONSTANT_LEDGER tracks thresholds and ranges. The FORMALIZATION_IDENTITY_AUDITOR checks whether machine-verified statements match intended claims. The COMPUTATION_REPLAY_ENGINE verifies algorithmic support. The EXPOSITION_SIMPLIFICATION_LEDGER protects readers from false theorem-memory. The COLLABORATION_PROVENANCE_ENGINE integrates distributed reasoning. The AI_PACKET_AUDITOR routes generated mathematical artifacts. The COUNTERKERNEL_FORGE converts unpaid debt into obstruction. The CERTIFICATE_CLOSURE_ENGINE governs export.
The architecture is modular because no single audit catches all failures. Logical proof validity does not catch misleading exposition. Formal proof checking does not catch wrong theorem identity unless identity is audited. Numerical reproduction does not prove coverage. Expert consensus does not close compactness extraction. Each module corresponds to a distinct failure mode in mathematical knowledge production.
The modules together form a proof-economy system. They convert informal confidence into typed obligation, typed obligation into proof work, proof work into closure, and failed closure into obstruction. The architecture is complete when every mathematical movement is either licensed, restricted, or blocked.
7. Module Specifications
Module specification converts Debt Theory from vocabulary into execution. Each module has a defined input, operation, and output. The modules do not replace proof; they govern the conditions under which proof, computation, exposition, and collaboration become trustworthy knowledge. Their purpose is to prevent claims from moving across contexts with hidden obligations attached.
The modules form a pipeline but not a rigid sequence. A theorem can enter through computation, analogy, formalization, exposition, or collaboration. Once inside the system, the same invariants must be checked: what was claimed, what was preserved, what was lost, what remains unpaid, what blocks export, and what counts as closure. The module layer therefore provides a common grammar for heterogeneous mathematical labor.
The conceptual closure of the module system is that every mathematical artifact is treated as an object with a use-condition. A proof, diagram, program, analogy, AI sketch, and expository summary can all be valuable, but none is allowed to masquerade as a different kind of artifact without paying the relevant debt.
7.1 DEBT_DETECTOR
The DEBT_DETECTOR identifies moments where mathematical obligation is created. It scans claims, proofs, methods, analogies, computations, formalizations, expositions, and collaborative states for debt triggers. The most important triggers are carrier change, asymptotic suppression, compactness, analogy, computation, formal encoding, AI generation, diagrammatic reasoning, distributed proof state, and use of a theorem outside its native regime.
Detection is an epistemic triage function. It does not determine validity. It determines where validity is not yet enough. A proof that uses a limiting argument triggers compactness debt; a result stated with big-O triggers asymptotic debt; an explanation based on a physical analogy triggers analogy and exposition debt; a Lean theorem triggers formalization identity debt; a numerical search triggers computation debt. Detection turns invisible obligations into inspectable objects.
The detector closes its task when it produces a finite list of DebtObjects with enough information for classification. It is successful when no major mathematical movement remains unregistered.
7.2 DEBT_CLASSIFIER
The DEBT_CLASSIFIER assigns each detected obligation to a debt type and severity. Its categories include semantic, logical, quantitative, computational, formal, expository, institutional, collaborative, carrier, and transport debt. The classification determines the payment procedure. A semantic mismatch requires theorem-identity audit. A quantitative gap requires extraction or constant tracking. A collaborative gap requires provenance and replay. A carrier gap requires liftback.
Severity measures export danger. Low debt requires local cleanup. Medium debt permits use under warning. High debt blocks safe downstream reuse until repaired. Critical debt indicates possible false theorem, wrong carrier, irreproducible essential computation, AI hallucination embedded in proof, or likely counterkernel. Severity is not a moral grade; it is a decision variable.
Classification closes when the system knows both what kind of obligation exists and what consequence follows if it remains unpaid. The same mathematical artifact can carry multiple debts with different severities. The classifier prevents the strongest visible credential from hiding the weakest unpaid obligation.
7.3 TRANSPORT_AUDITOR
The TRANSPORT_AUDITOR checks whether a claim survives movement between carriers. It identifies the source primitive, target primitive, transport map, preserved invariant, loss function, exception transfer, and reverse liftback. This module is central because the highest-value mathematics often occurs precisely by transport.
The auditor asks whether the target theorem proves a claim about the original object or only about its representation. In entropy proofs, it checks that random-variable inequalities return to set-theoretic conclusions. In analytic number theory, it checks that zeta or Dirichlet-series statements return to arithmetic estimates. In ultraproduct arguments, it checks that the limit contradiction yields a finite theorem. In geometric partitioning, it checks that algebraic cases and scale losses return to the original incidence bound.
Transport audit closes only when the original claim is recovered with all declared losses and exceptions. If the claim survives only in the target carrier, export is forbidden. The transport auditor is the primary defense against elegant proofs of displaced problems.
7.4 CARRIER_REPLACEMENT_LEDGER
The CARRIER_REPLACEMENT_LEDGER records what a new carrier reveals and what it hides. Its object is not merely the carrier itself, but the relation between old and new carriers. It documents exposed structure, suppressed structure, native constraints, residues, defects, and liftback protocol.
Carrier replacement is often where discovery happens. Entropy reveals spread and dependence; spectral theory reveals operator structure; cohomology reveals obstruction; ultraproducts reveal limiting compactness; random matrices reveal universal local statistics; nilsystems reveal structured failure of uniformity. But every revelation has a shadow. The ledger records the shadow.
The module closes when the carrier’s jurisdiction is known. A carrier with declared scope can be used aggressively inside that scope. A carrier without a loss map remains unsafe. The ledger transforms carrier choice from intuitive craft into auditable mathematical infrastructure.
7.5 ABSTRACTION_OBLIGATION_ENGINE
The ABSTRACTION_OBLIGATION_ENGINE evaluates forgotten structure. It asks what was removed, whether it is recoverable, whether it is irrelevant, whether it is dangerous, and whether the abstraction creates fake generality. This is essential because abstraction is both the source of mathematical power and a frequent source of invalid export.
The engine distinguishes faithful abstraction from lossy abstraction, invalid abstraction, and boundary-generating abstraction. Faithful abstraction suppresses only irrelevant or recoverable detail. Lossy abstraction remains useful if the loss is declared and contained. Invalid abstraction suppresses a condition essential to the claim. Boundary-generating abstraction fails in a structured way that reveals a missing primitive.
The module closes when forgotten data has a status. It is no longer enough to say that a theorem is abstract. The engine requires a statement of what the abstraction owes to the concrete cases it represents.
7.6 ANALOGY_FIREWALL
The ANALOGY_FIREWALL prevents analogy from being laundered into evidence. It identifies shared structure, broken structure, failure boundary, counterexample pressure, and licensed export conditions. This module preserves the value of analogy by refusing to let it overclaim.
Analogy is epistemically asymmetric. It is excellent at generating routes and weak at certifying conclusions. A function-field analogue can reveal the right shape of a number-field conjecture while failing at archimedean, ramification, or zero-distribution constraints. Random matrix theory can predict spectral statistics without proving arithmetic zero placement. Physical intuition can suggest PDE structure without controlling weak solutions. The firewall preserves these distinctions.
The module closes when analogy has been converted into either a transport map, a bounded heuristic, or a counterkernel. A bounded heuristic can guide research without supporting theorem export. A transport map pays the debt. A counterkernel explains why the analogy fails. Unbounded analogy is blocked.
7.7 COMPACTNESS_EXTRACTION_ENGINE
The COMPACTNESS_EXTRACTION_ENGINE handles proofs that pass through limiting objects. It converts infinitary closure into finite-use information where required. Its domain includes ultraproducts, weak compactness, Arzelà-Ascoli arguments, concentration compactness, regularity lemmas, compactness contradictions, and model-theoretic transfer.
The engine first determines whether quantitative recovery is necessary. Some theorems are purely qualitative, and compactness debt can be declared harmless within that regime. Other theorems are used in estimates, algorithms, explicit bounds, or finite applications. In those cases, the engine demands growth functions, effective constants, moduli, rates, or a proof-mining extraction.
The module closes when the proof’s output matches the strength required by its use. It forbids the common error of treating nonconstructive existence as explicit control. Compactness closes escape in principle; extraction makes that closure operational.
7.8 ASYMPTOTIC_CONSTANT_LEDGER
The ASYMPTOTIC_CONSTANT_LEDGER records the hidden data behind limiting notation. It tracks constants, thresholds, exceptional sets, uniformity ranges, dependency chains, lower-order terms, smoothing parameters, probability tails, and endpoint losses. Its function is to prevent asymptotic language from being silently upgraded into explicit applicability.
The ledger is especially important in analytic number theory, PDE, additive combinatorics, probability, random matrices, and algorithmic mathematics. These fields often use asymptotic form to expose structure. Downstream use often requires more. A theorem with ineffective constants has different decision value from an explicit bound. A result holding for almost all inputs differs from one holding uniformly. A high-probability estimate differs from a deterministic certificate.
The module closes when the asymptotic statement’s usable regime is declared. It does not force every theorem to become explicit. It forces every use of asymptotics to respect the debt incurred by suppressed quantitative information.
7.9 FORMALIZATION_IDENTITY_AUDITOR
The FORMALIZATION_IDENTITY_AUDITOR checks whether a formal theorem is the intended theorem. It compares informal statement and formal statement under definitions, hypotheses, coercions, universe levels, hidden assumptions, library dependencies, automation, and proof assistant conventions. Its object is semantic identity, not merely syntactic validity.
This module is necessary because formalization can produce absolute confidence in the wrong object. A proof assistant verifies derivability inside a formal environment. It does not know the human purpose of the theorem unless that purpose is represented correctly. Definition choices can strengthen, weaken, or alter claims. Implicit assumptions in informal mathematics can disappear or become explicit. Library lemmas can import principles not recognized by the user. Automation can obscure dependencies.
The auditor closes when the formal result can be read back into ordinary mathematics as the intended claim. The endpoint is not machine trust alone but human-machine theorem identity. A checked proof becomes mathematical certificate only when its statement is semantically anchored.
7.10 COMPUTATION_REPLAY_ENGINE
The COMPUTATION_REPLAY_ENGINE verifies computational support. It inspects the algorithm, input, output, precision, coverage, environment, independent rerun, and proof certificate. It distinguishes exploration, evidence, and proof component. This distinction is essential because computation ranges from informal numerical experiment to formally certified exhaustive proof.
The engine asks whether the computation covers the entire required domain, whether numerical error is bounded, whether symbolic transformations are exact, whether search pruning is justified, whether the environment is reproducible, and whether independent implementations confirm the result. In machine-learning-assisted mathematics, it also separates model-suggested pattern from proof-bearing computation.
The module closes when computational claims are replayable with known error and coverage. Without replay, computation remains valuable but nonterminal. With replay and certification, computation becomes a legitimate proof-bearing carrier.
7.11 EXPOSITION_SIMPLIFICATION_LEDGER
The EXPOSITION_SIMPLIFICATION_LEDGER records what an explanation omits, distorts, compresses, or reorders. It tracks omitted hypotheses, exceptions, analogy boundaries, nonliteral diagrams, dependency shortcuts, informal terminology, and audience-specific simplifications. Its purpose is to prevent explanatory success from becoming theorem confusion.
Mathematical exposition must simplify; otherwise it cannot transmit. The danger arises when simplification becomes memory. Readers carry away a model of the theorem, and that model later guides reasoning. If the model omits a boundary condition, it becomes a source of false inference. The ledger therefore preserves the relation between the accessible explanation and the exact theorem.
The module closes when the explanation has a declared map back to precision. Good exposition creates a reliable gradient from intuition to formal statement. Bad exposition creates a persuasive surface with no controlled descent into exactness.
7.12 COLLABORATION_PROVENANCE_ENGINE
The COLLABORATION_PROVENANCE_ENGINE organizes distributed mathematical work into replayable proof state. It records claims, owners, dependencies, versions, parameters, code, discussions, open gaps, and final proof locations. Its domain includes formal collaborations, Polymath-style projects, seminar-driven proof development, online discussions, multi-author drafts, and institutional research programs.
Collaboration increases the amount of mathematical search that can occur, but it also increases fragmentation. A parameter value can change without all dependent lemmas updating. A comment can resolve a local issue without entering the final proof. A computational check can be accepted socially without becoming replayable. A contributor can know why a step works while the written record does not. Provenance is the antidote to social proof-memory.
The module closes when the collaboration’s residue is converted into an integrated proof artifact. The final theorem must be executable by someone outside the collaboration’s live context. Distributed discovery becomes knowledge only when its dependencies are stable after the social process ends.
7.13 AI_PACKET_AUDITOR
The AI_PACKET_AUDITOR classifies and routes AI-generated mathematical artifacts. It identifies whether an output is a conjecture, lemma candidate, proof sketch, analogy, code fragment, formalization fragment, exposition, counterexample candidate, or literature pointer. It then assigns verification, repair, quarantine, discard, or counterkernel routing.
The module exists because AI changes the cost of generating plausible mathematical material. It can produce many routes, phrasings, and candidate structures quickly. This increases discovery pressure and also increases debt volume. The key risk is fluent noncertificate: output that resembles mathematical closure but lacks independently replayable proof. The auditor prevents speed from becoming authority.
The module closes when every AI packet has been converted into a certified object, a useful bounded heuristic, an active obligation, or a discarded artifact. AI becomes part of mathematical infrastructure only when its outputs are subordinated to debt accounting.
7.14 COUNTERKERNEL_FORGE
The COUNTERKERNEL_FORGE activates when a debt cannot be paid by ordinary repair. It searches for the minimal failure model that explains the unpaid obligation. The counterkernel can be a counterexample, obstruction class, hidden hypothesis, invariant mismatch, irreducible exception, or new boundary object.
This module is central to discovery. Many theoretical advances arise when a failed proof obligation is not patched but understood. The parity barrier in sieve theory, compactness defects in PDE, nonuniformity in combinatorics, formal theorem-identity failures, and analogy breakdowns all become productive when their obstruction is materialized. The counterkernel is the object that makes failure intelligible.
The forge closes when unpaid debt becomes structured. A structured impossibility is knowledge. It prevents repeated failed attempts, redirects search, and can generate new primitives. Debt that cannot be paid is not automatically defeat; it is often the location where the old theory ends.
7.15 CERTIFICATE_CLOSURE_ENGINE
The CERTIFICATE_CLOSURE_ENGINE is the final export gate. It determines whether all required debts have been paid, whether liftback is complete, whether replay is possible, whether counterkernels are excluded, and whether theorem identity is stable. Its judgment governs whether a claim is certified, restricted, quarantined, rejected, or routed to new mathematics.
Certificate closure is stricter than proof possession. A proof can exist in a narrow context while export remains unsafe. A theorem can be correct but not explicit enough for application. A computation can be impressive but unreplayed. A formal proof can be valid but semantically misaligned. The closure engine enforces the difference between local achievement and reusable mathematical knowledge.
The module closes conceptually by refusing untyped export. Every claim leaving the system must carry a status. Certified claims can be reused. Restricted claims can be used only under declared conditions. Quarantined claims remain active but nonexportable. Rejected claims are blocked. Counterkernel claims become new objects of theory.
8. Debt Calculus
Debt calculus describes how obligations behave under composition, compression, displacement, and payment. The basic principle is that mathematical movement conserves obligation. Structure cannot be transported, abstracted, approximated, formalized, or computed for free. If the obligation is not paid at the point of movement, it reappears elsewhere as an exception, hidden hypothesis, nonuniform constant, failed liftback, wrong theorem identity, irreproducible computation, or counterexample.
Debt is generally additive under composition. If a proof moves through several carriers, each movement contributes obligations. A result obtained by analogy, then compactness, then computation, then exposition carries analogy debt, compactness debt, computation debt, and exposition debt. However, debts can compress under shared payment. A single robust transport theorem can close many local transport debts. A verified library can reduce repeated formalization debt. A general extraction theorem can pay compactness debt across a family of results. Debt calculus therefore tracks both accumulation and amortization.
The most important law is displacement. Unpaid debt does not disappear when ignored. It migrates to the user, the application, the reader, the formalizer, the computational reproducer, or the next theorem. Hidden debt produces fragility precisely because downstream agents treat a claim as debt-free while relying on obligations that were never discharged. Debt calculus makes the movement of obligation explicit enough for rational decision.
9. Integration
begins with wrongness, residue, carrier selection, transport, liftback, certificate, counterkernel, or active debt. Debt Theory inserts obligation accounting into every arrow. . Every primitive failure creates a search for a better carrier. Every carrier creates transport. Every transport creates debt. Every debt must be paid, restricted, or transformed.
The integrated runtime starts with primitive failure and residue detection, proceeds to carrier selection, registers the debts created by transport, attempts payment, audits counterkernels, performs liftback, and governs export. This prevents discovery from becoming uncontrolled proliferation of attractive carriers. It also prevents proof from being treated as a single terminal object when its usability depends on unresolved obligations.
The integration changes the meaning of mathematical progress. Progress is not merely the production of theorems, but the conversion of residue into carriers and carriers into certificates through debt discipline. supplies the discovery dynamics; Debt Theory supplies the accounting of obligations created by those dynamics. Together they define a proof-economy architecture.
10. Export Rules
Export rules determine when a mathematical object can safely leave its local context. Export is allowed when theorem identity is stable, transport obligations are paid, carrier losses are audited, constants and ranges are sufficient for intended use, exceptions are declared, computation and formalization are replayed where essential, and expository limits are tagged. Export is restricted when the theorem is usable only under declared regimes or when debts remain active but contained. Export is forbidden when an artifact is being treated as a stronger artifact than it is.
The forbidden cases are precise. Analogy cannot be exported as evidence. Compactness cannot be exported as an explicit bound without extraction. Computation cannot be exported as theorem without replay and error control. Formalization cannot be exported as intended theorem without identity audit. Asymptotic statements cannot be exported into finite regimes without thresholds. Collaboration state cannot be exported as proof without synthesis. AI output cannot be exported as certificate without independent verification.
Export rules close the gap between mathematical validity and decision value. They tell downstream users what kind of object they have. The result is not epistemic caution for its own sake, but clean permission: when export is allowed, the claim can travel.
11. Debt Severity Matrix
The debt severity matrix ranks obligations by their threat to safe use. Low severity debts involve local exposition cleanup, minor constant tracking, or recoverable notation mismatch. Medium severity debts include missing ranges, unstated hypotheses, informal computational support, or unclear analogy boundaries. High severity debts include absent liftback, ineffective compactness where explicit bounds are required, unclear formal theorem identity, or major hidden exceptional sets. Critical debts include wrong carrier, false theorem risk, irreproducible essential computation, embedded AI hallucination, or likely counterkernel.
Severity is context-dependent but not subjective. A missing explicit constant is low severity in pure qualitative theory and high severity in numerical application. A misleading exposition is low severity if clearly marked as intuition and high severity if used as proof. A compactness argument is complete for existence and incomplete for construction. The matrix therefore evaluates debt relative to intended export.
The matrix closes conceptually by connecting epistemology to decision science. Severity determines action: proceed, warn, repair, quarantine, or block. Mathematical judgment becomes operational when each debt class produces a decision consequence.
12. Output Objects
Debt Theory produces concrete artifacts: debt maps, debt ledgers, proof obligation lists, transport audits, carrier loss maps, exception ledgers, constant ledgers, liftback certificates, counterkernel candidates, and export decisions. These objects are not ancillary documentation. They are the infrastructure that allows mathematical knowledge to be reused without relitigating hidden obligations.
A debt map shows where obligations lie across a theorem or theory. A proof obligation list converts vague incompleteness into tasks. A transport audit records movement between carriers. A carrier loss map tells users what the new representation cannot see. An exception ledger prevents exceptional cases from becoming invisible. A constant ledger governs explicit use. A liftback certificate proves return to the original domain. A counterkernel candidate turns failure into structure. An export decision governs reuse.
The output layer closes the architecture by making debt visible outside the proof’s original production context. The goal is not merely to know that debt exists, but to produce artifacts that let others act correctly.
13. Standard Workflow
The standard workflow of New Maths Debt Theory begins from the premise that every mathematical artifact has both content and use-context. A theorem, proof, conjecture, diagram, computation, analogy, formalization, exposition, collaborative note, or AI-generated sketch does not enter the system as a bare object. It enters as something being asked to perform a role. It may be used as proof, heuristic, exposition, search guidance, computational evidence, formal certificate, institutional justification, or downstream dependency. The workflow begins by identifying that role, because debt is always assessed relative to intended export. A loose analogy in a brainstorming setting and the same analogy inside a proof have different epistemic status.
The first substantive stage is claim extraction. The artifact must be decomposed into the mathematical claims it actually makes. In a proof, this includes the theorem, subsidiary lemmas, hidden hypotheses, reductions, transformations, and imported results. In a computation, it includes the input class, algorithmic claim, coverage claim, numerical claim, and interpretation of output. In an exposition, it includes the theorem being explained, the analogies used, the simplifications introduced, and the implicit promise made to the reader. In an AI sketch, it includes every proposed lemma, cited theorem, analogy, proof step, definition, and conclusion. Claim extraction converts a surface artifact into a structured field of obligations.
The second stage is carrier analysis. The system identifies every point where the artifact moves a mathematical object into another representational domain. A combinatorial problem may become an entropy problem. A finite problem may become an ultraproduct or compactness problem. A prime-counting problem may become a zeta-function problem. A geometric configuration may become an incidence graph or algebraic variety. A proof may become a formal term in a proof assistant. A collaborative discussion may become a theorem draft. Carrier analysis locates the exact sites at which transport debt, abstraction debt, compactness debt, and liftback debt can enter.
The third stage is debt registration. Each obligation is recorded as a debt object with a source claim, source carrier, target carrier, transport map, debt type, suppressed data, preserved invariant, suspected loss, and required payment. This stage is decisive because it prevents mathematical unease from remaining vague. The question “does this argument really return to the original problem?” becomes liftback debt. The question “does this asymptotic estimate work in the required range?” becomes quantitative debt. The question “does the formal theorem mean the intended theorem?” becomes formalization identity debt. Registration makes the debt inspectable.
The fourth stage is classification and severity ranking. Debt is assigned to a class: transport, carrier replacement, abstraction, analogy, compactness, asymptotic, formalization, computation, exposition, collaboration, AI-generation, institutional, or theorem-reuse debt. Severity is then determined relative to intended use. A missing explicit constant is minor in a qualitative existence theorem and severe in a numerical application. A misleading simplification is acceptable in an introductory analogy and unacceptable in a proof summary. A computational result without replay may be adequate for conjecture generation and inadmissible as a proof component. Severity is therefore a decision variable, not a moral judgment.
The fifth stage generates payment obligations. Each debt type has a characteristic discharge form. Transport debt requires primitive alignment, invariant preservation, loss accounting, exception transfer, and liftback. Compactness debt requires extraction if quantitative use is intended. Asymptotic debt requires thresholds, constants, uniformity ranges, and error propagation when explicit use is required. Formalization debt requires semantic alignment between informal claim and formal statement. Computation debt requires reproducibility, coverage, and error control. Exposition debt requires boundary markers and recovery paths. Collaboration debt requires provenance and integrated replay. AI debt requires packet typing and independent verification.
The sixth stage attempts payment. This may involve proving a missing lemma, deriving a bound, extracting constants, rerunning a computation, checking formal definitions, reconstructing a collaborative proof, sharpening an analogy boundary, repairing an exposition, or searching for counterexamples. Payment must match the debt type. A persuasive explanation does not pay proof debt. A formal derivation does not pay theorem-identity debt unless the formal statement is aligned. A numerical rerun does not pay coverage debt unless the search space is complete. The system treats payment as a typed closure relation.
The seventh stage audits counterkernels. When a debt resists payment, the failure is analyzed as a possible obstruction rather than as mere incompleteness. The system searches for the minimal structure that explains why payment fails. This obstruction may be a hidden hypothesis, parity barrier, compactness defect, exceptional configuration, wrong carrier, nonuniform constant, failed analogy, irreproducible computation, or semantic mismatch. A counterkernel is not simply a counterexample; it is the structural object that explains why a route cannot close. Counterkernel analysis turns blocked proof work into new mathematical information.
The eighth stage tests liftback. Any conclusion reached in a replacement carrier must return to the original mathematical object. Liftback checks whether the theorem has been proven about the source problem or only about a transformed proxy. It examines constants, hypotheses, exceptional sets, native constraints, and semantic identity. This is the final defense against displaced proof. A theorem about a smoothed model, limiting object, formal encoding, random surrogate, or computational search space does not automatically prove the native claim. Liftback supplies the return map.
The ninth stage assigns export status. The possible outcomes are certified, restricted export, active debt, quarantine, rejection, counterkernel materialization, or new mathematics required. Certified claims can travel in the declared regime. Restricted claims can travel only with explicit conditions. Active debts become research tasks. Quarantined artifacts remain useful as heuristic, local, or exploratory objects but cannot be treated as certificates. Rejected claims are blocked. Materialized counterkernels become obstruction theory. A requirement for new mathematics marks a primitive gap in the existing framework.
The workflow closes by transforming mathematical production into an accountable decision process. It preserves fast exploration while preventing premature certification. It permits conjecture, analogy, computation, exposition, collaboration, and AI generation to operate at high speed, but it assigns each output its correct status. The result is a proof economy in which route, evidence, theorem, certificate, and export are kept distinct.
14. Example Pattern: Entropy Proof
An entropy proof begins by replacing a discrete combinatorial problem with an information-theoretic carrier. A family of sets, configurations, or combinatorial choices becomes a random variable or probability distribution. Counting is replaced by uncertainty. Containment becomes conditional dependence. Spread becomes an entropy constraint. Correlation becomes mutual information. Refinement becomes an inequality in an information algebra. The gain is that a difficult combinatorial structure becomes tractable through the formal calculus of entropy.
This carrier replacement creates debt immediately. The random variable must faithfully encode the combinatorial object. The entropy quantity must measure the relevant structural feature rather than a convenient proxy. Conditional independence must correspond to a genuine combinatorial decoupling. The support of the probabilistic object must recover actual configurations in the original family. Any limiting, empirical, or averaging argument must return to a finite set-theoretic statement. Without these obligations, entropy remains an analogy rather than a proof carrier.
In a valid entropy proof, the information-theoretic stage is not decorative. Entropy inequalities perform real mathematical work. Subadditivity, chain rules, mutual information bounds, relative products, conditional copies, and absorption estimates constrain the possible structure of the random object. These constraints then force a combinatorial conclusion. The crucial movement is not from “entropy suggests disorder” to “therefore the set family behaves randomly.” The movement is from exact probabilistic representation to exact inequality to exact combinatorial recovery.
The debt of an entropy proof is paid when the final conclusion is expressed in the original combinatorial language. If the proof begins with a family of sets, it must end with a statement about actual sets in that family. If it begins with a forbidden configuration problem, it must return a forbidden configuration or a structural decomposition. If it begins with a spread condition, it must show that the entropy hypothesis is equivalent to, or legitimately implied by, the combinatorial spread property being used. The carrier must not merely solve its own internal problem.
The failure modes are equally informative. An entropy proof can fail because the random-variable model omits a dependency that is combinatorially essential. It can fail because an average bound is used where a uniform bound is required. It can fail because a conditional copy is constructed in a probability space that no longer corresponds to admissible combinatorial objects. It can fail because the entropy inequality produces existence in a support that does not lift to the required family. These failures identify the counterkernel of the entropy route.
The entropy pattern closes with a central lesson of Debt Theory. Entropy becomes mathematics only when it pays its representational debts. It is a powerful carrier precisely because, when correctly licensed, it turns hidden combinatorial structure into measurable information flow. It is invalid when its metaphorical force outruns its liftback.
15. Example Pattern: Ultraproduct Proof
An ultraproduct proof begins when a finitary problem generates an uncontrolled sequence of failures. Instead of tracking each finite parameter directly, the proof forms a limiting nonstandard object. This object absorbs the sequence into a single structure. It often possesses compactness, saturation, definability, or regularity properties unavailable in any finite instance. The method converts parameter noise into structural visibility.
The central movement is from quantitative finitary analysis to qualitative infinitary structure. A sequence of finite groups may become an ultra-approximate group. A sequence of finite graphs may become a graph limit or Loeb-measure object. A family of approximate configurations may become an exact configuration in a nonstandard universe. A statement with many small parameters may become a clean contradiction in the limit. The ultraproduct removes the clutter of finite bookkeeping and exposes the invariant obstruction.
This movement creates compactness debt and liftback debt. The proof must show that the relevant properties survive the passage to the ultraproduct. It must ensure that the limiting object has not lost the finite constraint that mattered. It must use a structural theorem strong enough to affect the original sequence. Finally, it must return from the limiting contradiction or classification to a finite conclusion. If the downstream application requires explicit constants, the proof must either extract them or mark the theorem as qualitative.
The ultraproduct proof is therefore a two-way bridge. The first direction moves finite counterexamples into the limit. The second direction moves the limit theorem back into finite mathematics. The first direction is often clean because ultraproducts are designed to preserve specified logical structure. The second direction is where most debt accumulates. It may conceal ultrafilter dependence, ineffective constants, hidden growth functions, or nonconstructive thresholds. A correct ultraproduct proof can prove existence while remaining silent about usable magnitude.
The proper status of such a proof depends on intended export. If the theorem asserts that some finite obstruction cannot persist indefinitely, a qualitative ultraproduct argument may be sufficient. If the theorem is to be used in an explicit estimate, algorithm, numerical bound, or finite classification, extraction debt remains active. Debt Theory does not demote the proof; it prevents its qualitative conclusion from being misused as quantitative control.
The failure modes of ultraproduct reasoning are structurally important. A property may fail to be first-order expressible. A limiting object may satisfy an exact property that finite approximants satisfy only ineffectively. A compactness contradiction may prove nonexistence without an extractable threshold. A definability condition may fail to return to the original finite category. Each failure identifies where the finite world resisted the infinitary carrier.
The ultraproduct pattern closes by distinguishing truth from operational knowledge. The ultraproduct can prove that a finite phenomenon cannot behave badly forever. Debt Theory records what remains unpaid when one asks how soon, how effectively, with what constants, and by what finite procedure the bad behavior must stop.
16. Example Pattern: AI Proof Sketch
An AI proof sketch enters the system as a generated mathematical packet. It may contain a valid route, a false lemma, a useful analogy, a misplaced theorem, a correct definition, a hallucinated citation, an incomplete reduction, or a plausible but invalid proof step. Its initial status is not proof. Its initial status is structured proposal.
The first task is extraction. The sketch must be decomposed into claims, lemmas, definitions, cited results, analogies, reductions, computations, proof transitions, examples, and conclusions. The second task is typing. Each component must be classified as known theorem, conjecture, lemma candidate, heuristic analogy, computational claim, expository statement, formalization fragment, or counterexample candidate. The third task is routing. Each component must be sent to verification, repair, quarantine, discard, or counterkernel analysis.
The distinctive debt of AI output is semantic overproduction. AI systems can generate more plausible mathematical surface than the certificate ecology can immediately absorb. They lower the cost of proposal, not the cost of closure. This creates a high ratio of candidate structure to verified structure. The danger is not merely that some claims are false. The deeper danger is that fluent mathematical language can simulate closure while leaving proof obligations unregistered.
AI debt is paid through independent verification. A proposed lemma must be proved or refuted. A cited theorem must be located and checked for hypothesis match. An analogy must be firewalled. A computational claim must be replayed. A formalization fragment must be audited for theorem identity. A proof step must be reconstructed without relying on fluency. A definition must be checked against the intended primitive. The original confidence of the generated text has no certificate value after extraction; only discharged obligations matter.
AI proof sketches can still be highly productive. They can surface nearby methods, suggest intermediate claims, generate toy cases, propose normal forms, locate analogies, or reveal hidden dependencies. They increase search density. They are valuable precisely as packet generators. Debt Theory allows that value to be used without confusing route production with proof production.
The failure of an AI sketch can also be useful. A false lemma may expose the missing hypothesis. A hallucinated theorem may reveal that the desired bridge does not exist in the literature. A failed analogy may identify the broken invariant. A repeated inability to close a route may materialize a counterkernel. The system therefore treats AI failure not only as noise but as possible obstruction signal.
The AI pattern closes with a strict status rule. AI can accelerate discovery, exposition, formalization, and search. It does not remove the need for theorem identity, proof obligation, liftback, replay, and export status. AI changes the volume and velocity of mathematical packets; Debt Theory governs which packets become knowledge.
17. Final Compression
New Maths Debt Theory compresses to a single governing principle: every mathematical movement creates an obligation. A theorem is not characterized only by its statement. It is characterized by its route: the carriers it entered, the abstractions it used, the analogies that guided it, the limits it passed through, the computations that supported it, the formal systems that encoded it, the expositions that transmitted it, the collaborations that assembled it, and the AI or institutional systems that may have shaped it. Each route element creates debt.
This principle expands the meaning of rigor. Rigor is not only local correctness of inferential steps. It is the disciplined relation between a claim and the transformations that made the claim possible. A compactness argument may be rigorous and still owe explicit bounds. A formal proof may be rigorous and still owe theorem-identity audit. A computation may be rigorous within its environment and still owe replay or coverage. An exposition may be illuminating and still owe boundary conditions. Debt Theory extends rigor from proof syntax to proof ecology.
The theory also clarifies mathematical creativity. New mathematics often begins as productive debt. A powerful analogy suggests a path before transport is licensed. A new carrier exposes a structure before liftback is known. A compactness argument proves qualitative closure before quantitative extraction exists. A computation reveals a pattern before proof follows. These are not failures of discovery. They are the normal way discovery creates obligations. The decisive question is whether those obligations sharpen under pressure.
Productive debt becomes more exact when examined. It yields proof obligations, partial payments, refined hypotheses, counterexamples, stronger carriers, or new primitives. Degenerative debt survives by evading pressure. It retreats into vaguer language, shifts criteria, hides behind complexity, imports institutional authority, or treats difficulty of audit as evidence of depth. Debt Theory separates frontier from laundering by observing whether scrutiny produces structure or merely preserves ambiguity.
The final compression is therefore an operational law. Mathematics advances by transporting structure into better carriers. Transport creates debt. Paid debt becomes certificate. Unpaid registered debt becomes research program. Impossible debt becomes counterkernel. Fertile counterkernel becomes new primitive. Hidden debt becomes fragility. Laundered debt becomes false authority. A healthy mathematical ecosystem is one that converts debt into closure or structure instead of allowing it to accumulate invisibly.
18. Hard Locks
The hard locks are the negative axioms of Debt Theory. They prevent one epistemic object from being substituted for another. Analogy is not proof. Compactness is not a bound. Formalization is not theorem identity. Computation is not certificate. Exposition is not full theorem. Collaboration is not replay. AI output is not proof. Asymptotic notation is not explicit control. Carrier elegance is not liftback. Public consensus is not certificate.
Each lock protects a legitimate mathematical instrument from overextension. Analogy is valuable because it generates routes; it becomes dangerous when treated as evidence. Compactness is valuable because it reveals qualitative impossibility; it becomes dangerous when treated as quantitative control. Formalization is valuable because it verifies derivations; it becomes dangerous when the verified statement is not the intended theorem. Computation is valuable because it searches, tests, and sometimes certifies; it becomes dangerous when unreplayed output is treated as proof. Exposition is valuable because it transmits understanding; it becomes dangerous when simplification becomes theorem memory.
The collaboration and AI locks address modern proof ecology. Collaboration is powerful because it distributes search and correction; it becomes dangerous when social convergence substitutes for integrated proof. AI is powerful because it expands the space of generated mathematical packets; it becomes dangerous when fluency substitutes for certificate. Public consensus may guide attention, but it does not close proof obligations. Prestige, citation, reputation, or institutional validation can never replace debt payment.
The asymptotic and carrier locks protect mathematical transport. Asymptotic statements reveal limiting structure, but they do not provide explicit finite control without thresholds, constants, and uniformity ranges. Carrier elegance reveals hidden invariants, but it does not prove the native problem without liftback. These locks prevent beauty, abstraction, and scale from being mistaken for closure.
The hard locks close the theory by enforcing non-convertibility between epistemic statuses. A route cannot be promoted to proof by rhetoric. Evidence cannot be promoted to certificate by prestige. A proof in one carrier cannot be exported to another by aesthetic resemblance. Every artifact must earn the status it claims.
19. Architecture Summary
New Maths Debt Theory is an obligation calculus for mathematical transport. It studies the debts created when mathematics moves through carriers, abstractions, analogies, limits, computations, formal systems, expositions, collaborations, institutions, and AI-generated packets. Its central claim is that mathematical artifacts acquire export strength only through debt discipline. A claim is not fully described by its statement; it is described by its statement, route, obligations, payments, counterkernels, and permitted uses.
The architecture has three levels. At the epistemological level, it distinguishes knowledge from suggestion, evidence, computation, exposition, social belief, and generated fluency. At the systems level, it models mathematics as a network of carriers, transformations, ledgers, dependencies, and closure states. At the decision-science level, it assigns actions: certify, restrict, repair, quarantine, reject, route to counterkernel, or declare new mathematics required. These levels are inseparable because mathematical knowledge is not only true-or-false; it is also reusable-or-not, explicit-or-not, faithful-or-not, and exportable-or-not.
The architecture resolves a central tension in contemporary mathematics. Modern proof production increasingly relies on powerful carriers: entropy, ultraproducts, random matrices, proof assistants, computer search, collaborative platforms, and AI systems. These carriers increase discovery power while multiplying hidden obligations. Debt Theory allows mathematics to use such carriers aggressively without surrendering rigor. It does not require every artifact to be final. It requires every artifact to carry its correct status.
The practical output is a structured proof economy. Debt maps identify obligations. Ledgers track unresolved payments. Transport audits license carrier movement. Constant ledgers govern explicit use. Formalization audits secure theorem identity. Computation replay engines certify machine support. Exposition ledgers protect transmission. Collaboration provenance engines stabilize distributed proof. AI packet auditors prevent fluent generation from becoming false authority. Counterkernel forges convert failed payment into obstruction theory. Certificate closure engines govern export.
The architecture closes with a single criterion. A mathematical claim is exportable exactly to the extent that its relevant debts have been paid, bounded, declared, or structurally transformed. Anything else remains local, conditional, heuristic, quarantined, or active. Debt Theory therefore does not stand outside mathematics as commentary. It names the internal economy by which mathematical movement becomes reliable knowledge.
New Maths Debt Theory Glossary
Abstraction Debt
Abstraction debt is the obligation created when mathematical detail is deliberately suppressed in order to expose a more general structure. It arises whenever a theorem, proof, or method forgets concrete data such as metric information, finitary bounds, ordering, computability, representation-specific constraints, or exceptional cases. The debt is paid when the omitted data is shown to be irrelevant, recoverable, or explicitly outside the theorem’s intended scope.
Active Debt
Active debt is an unpaid obligation that has been identified, registered, and preserved as a research task. It is not hidden fragility. Active debt is legitimate when its status is visible and downstream use is restricted accordingly. It becomes dangerous only when treated as if it were already paid.
AI Generation Debt
AI generation debt is the obligation created when an AI system produces mathematical content such as conjectures, proof sketches, analogies, definitions, code, formalization fragments, or exposition. The debt arises because generated fluency does not certify theorem identity, proof validity, dependency correctness, or liftback. It is paid by claim extraction, packet typing, independent verification, counterexample search, and proof reconstruction.
AI Packet
An AI packet is a discrete mathematical artifact generated by an AI system. It may be a lemma candidate, analogy, conjecture, proof sketch, computation, example, counterexample, exposition, or formalization fragment. Its initial status is not proof. It becomes useful only after being typed, routed, and audited.
Analogy Debt
Analogy debt is the obligation created when one mathematical structure is used to guide reasoning about another before a certified transport map exists. Analogy is valuable as route generation, but it is not evidence by itself. The debt is paid by identifying shared primitives, preserved invariants, broken invariants, failure boundaries, and either a licensed transport map or a materialized counterkernel.
Analogy Firewall
The analogy firewall is the architectural control that prevents analogy from being laundered into proof. It permits analogy as heuristic guidance but blocks export unless the analogy has been converted into a verified transport object, a bounded heuristic, or an obstruction analysis.
Asymptotic Debt
Asymptotic debt is the obligation created by limiting notation and limiting regimes: big-O, little-o, sufficiently large, almost all, generic, high probability, negligible, and limiting distribution. Such language suppresses constants, thresholds, lower-order terms, exceptional sets, and uniformity ranges. The debt is paid when the usable regime is declared or explicit quantitative control is extracted.
Carrier
A carrier is the representational medium in which a mathematical object is made tractable. Examples include entropy distributions, zeta functions, cohomology groups, ultraproducts, random matrices, nilsystems, formal proof terms, computational search spaces, and geometric models. A carrier reveals certain structures while hiding others.
Carrier Elegance
Carrier elegance is the apparent power, beauty, simplicity, or explanatory force of a replacement carrier. It has no certificate value by itself. A carrier can be elegant and still fail to lift back to the native problem. Debt Theory treats elegance as a discovery signal, not as proof.
Carrier Replacement Debt
Carrier replacement debt is the obligation created when a mathematical object is replaced by a more powerful representation. The new carrier may reveal structure but suppress native constraints. The debt is paid by declaring carrier scope, recording what was revealed and hidden, mapping native constraints, identifying defects, and proving liftback.
Carrier Scope
Carrier scope is the declared range within which a carrier faithfully represents the original mathematical object for the purpose at hand. It specifies what the carrier sees, what it cannot see, and what conclusions can safely be exported from it.
Certificate
A certificate is a mathematical artifact that closes the obligations required for a claim’s intended export. It is stronger than evidence, analogy, computation, exposition, or social agreement. A certificate must secure theorem identity, proof validity, relevant dependencies, liftback, and replayability in the declared regime.
Certificate Closure
Certificate closure is the final state in which all relevant debts have been paid, bounded, declared, quarantined, or transformed. A claim reaches certificate closure when it can safely travel in its intended use-context without hidden obligations.
Collaboration Debt
Collaboration debt is the obligation created when mathematical reasoning is distributed across people, comments, notes, code, drafts, talks, parameter tables, and institutional memory. It is paid when distributed proof fragments are integrated into a replayable proof artifact with provenance, dependency tracking, version control, and final synthesis.
Compactness Debt
Compactness debt is the obligation created when a finite, quantitative, or constructive problem is solved through an infinitary, limiting, or qualitative argument. It often appears in ultraproducts, weak compactness, regularity lemmas, concentration compactness, and contradiction by limiting counterexample. The debt is paid by extraction when quantitative or finite use is required.
Computation Debt
Computation debt is the obligation created when machine output supports a mathematical claim. It includes obligations concerning algorithm specification, input coverage, precision, error bounds, reproducibility, environment control, independent replay, and proof certificates. Computation becomes theorem support only when the relevant replay and error debts are closed.
Counterkernel
A counterkernel is the minimal obstruction that explains why a debt cannot be paid. It may be a counterexample, hidden hypothesis, invariant mismatch, parity barrier, nonuniformity, compactness defect, formalization mismatch, or wrong carrier. A counterkernel turns failure into structure.
Counterkernel Forge
The counterkernel forge is the module that activates when payment fails. It searches for the obstruction responsible for the failure and attempts to materialize it as a mathematical object. Its purpose is to convert blocked proof work into obstruction theory or new primitive formation.
Debt
Debt is an unpaid obligation created by mathematical movement. It is not automatically an error. It is the difference between local mathematical success and globally licensed use. Debt becomes dangerous when hidden, productive when registered, and certified when paid.
Debt Calculus
Debt calculus is the study of how obligations compose, compress, migrate, and reappear. Its central principle is conservation of obligation: mathematical structure cannot be transported for free. If an obligation is not discharged at the point of movement, it reappears as a hidden hypothesis, failed liftback, exceptional case, nonuniform constant, wrong theorem identity, or counterexample.
Debt Class
A debt class is a typed category of obligation, such as transport debt, abstraction debt, analogy debt, compactness debt, asymptotic debt, formalization debt, computation debt, exposition debt, collaboration debt, or AI generation debt. Each class has its own failure modes and closure conditions.
Debt Detector
The debt detector is the module that identifies where mathematical obligations are created. It scans for carrier changes, analogies, compactness arguments, asymptotic notation, computation, formalization, exposition, collaboration, AI generation, institutional authority, and theorem reuse outside native scope.
Debt Lifecycle
The debt lifecycle is the sequence by which an obligation is created, registered, classified, prioritized, paid, quarantined, rejected, transformed into a counterkernel, or resolved by new primitive formation. It ensures that debts do not remain invisible.
Debt Object
A debt object is the atomic record of an obligation. It records the source claim, source carrier, target carrier, transport map, debt type, suppressed data, preserved invariant, suspected loss, required payment, current status, proof obligations, counterkernel risks, liftback status, replay status, and terminal state.
Debt Severity
Debt severity measures how dangerous an unpaid obligation is relative to intended use. Low severity debt permits ordinary cleanup. Medium severity debt requires warning or repair. High severity debt blocks safe reuse until addressed. Critical debt signals possible false theorem, wrong carrier, irreproducible essential computation, embedded hallucination, or likely counterkernel.
Degenerative Debt
Degenerative debt is unpaid obligation that survives by evading pressure rather than becoming sharper. It shifts criteria, hides behind complexity, imports authority, or preserves ambiguity. It is characteristic of theorem laundering and false frontier formation.
Displaced Proof
A displaced proof is a proof that succeeds in a transformed carrier but fails to prove the original claim. It occurs when liftback is missing or defective. The proof may be locally valid and still nonexportable.
Error
Error is an invalid inference, false claim, incorrect computation, or failed proof step. Debt is broader than error. Debt can exist inside correct mathematics whenever obligations remain unpaid for the intended export.
Exception Ledger
An exception ledger records exceptional cases, excluded regimes, boundary conditions, singular configurations, low-dimensional failures, endpoint cases, and nonuniform sets. Its purpose is to prevent exceptions from disappearing during transport or exposition.
Export
Export is the movement of a mathematical artifact outside its local context of production. A theorem may be exported to another field, application, proof, formal library, computation, exposition, or institution. Export is licensed only when relevant debts have been paid, declared, bounded, or quarantined.
Export Forbidden
Export is forbidden when an artifact is being promoted beyond its paid status. Examples include treating analogy as proof, compactness as explicit bound, computation as certificate without replay, formalization as theorem identity without audit, collaboration as replay, AI output as proof, or asymptotics as explicit finite control.
Export Restricted
Restricted export is the state in which a claim may be used only under declared conditions. A result may be qualitative but not quantitative, asymptotic but not explicit, heuristic but not proof-bearing, computational evidence but not certificate, or formal artifact but not yet theorem identity.
Exposition Debt
Exposition debt is the obligation created when mathematics is simplified for communication. It arises from omitted hypotheses, analogy, diagrams, informal terminology, suppressed dependencies, and audience-specific compression. It is paid when the explanation includes a recoverable path to the exact theorem and marks its own limits.
False Theorem-Memory
False theorem-memory is the durable misconception created when an expository simplification is remembered as if it were the exact theorem. It is a failure mode of exposition debt.
Formalization Debt
Formalization debt is the obligation created when an informal mathematical claim is encoded into a formal system. It concerns whether the formal statement is the intended theorem. It is paid by theorem-identity audit, definition alignment, hypothesis checking, dependency review, and human-readable interpretation of the formal result.
Hidden Debt
Hidden debt is an unpaid obligation that has not been registered or declared. It is dangerous because downstream users inherit it unknowingly. Hidden debt often appears later as failed reuse, missing hypotheses, nonuniform constants, irreproducible computation, or counterexamples.
Institutional Debt
Institutional debt is the obligation created when publication, prestige, citation, prizes, consensus, funding, or disciplinary authority substitutes for direct mathematical closure. Institutions can guide attention, but they do not pay proof obligations.
Intended Use
Intended use is the context in which a mathematical artifact will be used. It determines which debts matter. A qualitative theorem, explicit numerical estimate, formal library dependency, cryptographic proof, educational exposition, and conjectural route each require different debt payment.
Liftback
Liftback is the return map from a replacement carrier to the original mathematical problem. It proves that conclusions obtained in the new carrier apply to the native object with declared losses, exceptions, constants, and hypotheses. Liftback is the main safeguard against displaced proof.
Liftback Certificate
A liftback certificate is the proof artifact showing that a result obtained in a target carrier returns to the source carrier in the intended form. It records the return map, losses, exceptions, and validity regime.
Local Success
Local success is a valid result inside a particular carrier, computation, formal system, exposition, or collaboration state. It becomes global usability only after the debts required for export are paid.
New Primitive
A new primitive is a basic concept required when existing mathematical vocabulary cannot express the obstruction or closure condition revealed by unpaid debt. New primitives often arise from fertile counterkernels.
Packet Typing
Packet typing is the classification of generated mathematical artifacts, especially AI outputs, into conjectures, lemma candidates, proof sketches, analogies, computations, formalization fragments, expositions, or counterexamples. Typing determines the correct verification route.
Payment
Payment is the discharge of a debt. It may take the form of proof, bound extraction, constant tracking, computation replay, theorem-identity audit, exposition repair, provenance synthesis, counterexample exclusion, or liftback. Payment must match the debt type.
Primitive Alignment
Primitive alignment is the obligation to show that the basic objects and operations in a source carrier correspond to those in a target carrier. It is a central part of transport debt.
Productive Debt
Productive debt is unpaid obligation that sharpens under scrutiny. It generates proof obligations, refined hypotheses, partial payments, counterexamples, better carriers, or new primitives. Productive debt is a normal part of mathematical discovery.
Proof Economy
Proof economy is the system of claims, carriers, obligations, ledgers, dependencies, certificates, counterkernels, and export decisions through which mathematical knowledge becomes reusable. Debt Theory treats mathematics as a proof economy rather than a list of isolated propositions.
Proof Obligation
A proof obligation is a specific task required to close a debt. It may be a missing lemma, constant extraction, counterexample exclusion, liftback proof, replay check, formal identity audit, or dependency verification.
Quarantine
Quarantine is the status assigned to an artifact that remains useful locally but cannot be exported as a certificate. A quarantined artifact may serve as heuristic, route, evidence, exposition, or conjectural support, provided its limits are visible.
Replay
Replay is the independent reconstruction or verification of a proof, computation, formal result, or collaborative argument. Replay ensures that the artifact does not depend on hidden social memory, unreproducible execution, or inaccessible context.
Replay Debt
Replay debt is the obligation to make an artifact independently executable or checkable. It is common in computation, collaboration, formalization, and complex proof synthesis.
Residue
Residue is the structured remainder left by failure, obstruction, mismatch, or incomplete closure. In terms, residue is not noise; it is the signal that a carrier, primitive, or counterkernel may need to be formed.
Route
A route is the sequence of transformations by which a mathematical claim is produced or supported. It includes carriers, reductions, analogies, computations, formalizations, expositions, collaborations, and liftbacks. Debt Theory treats the route as part of the theorem’s epistemic identity.
Semantic Overproduction
Semantic overproduction is the generation of more plausible mathematical language than can be immediately certified. It is characteristic of AI-assisted mathematics but can also occur in speculative exposition or informal collaboration. It creates AI generation debt when fluency outruns verification.
Theorem Identity
Theorem identity is the alignment between the theorem intended by mathematicians and the statement actually proved, formalized, computed, cited, or communicated. It is especially important in formalization, exposition, and cross-domain transport.
Theorem Laundering
Theorem laundering is the illicit promotion of a weaker artifact into a stronger epistemic status. It occurs when analogy is treated as proof, computation as certificate, compactness as explicit bound, exposition as full theorem, collaboration as replay, AI output as proof, consensus as certificate, or carrier elegance as liftback.
Transport
Transport is the movement of a mathematical claim, object, invariant, or proof obligation from one carrier or domain to another. It is a central mechanism of discovery and proof. Transport creates debt unless preservation, loss, exception, and liftback are accounted for.
Transport Auditor
The transport auditor is the module that checks whether a claim survives movement between carriers. It examines primitive alignment, invariant preservation, loss accounting, exception transfer, and liftback.
Transport Debt
Transport debt is the obligation created by transport. It is paid when the source and target primitives align, invariants are preserved, losses are controlled, exceptions transfer correctly, and the conclusion lifts back to the original domain.
Unpaid Obligation
An unpaid obligation is a requirement for safe mathematical export that has not yet been discharged. It becomes debt when created by a mathematical movement. It becomes dangerous when hidden and productive when registered.
Wrong Carrier
A wrong carrier is a representation that solves, simplifies, or clarifies a transformed problem while suppressing a constraint essential to the original problem. Wrong-carrier failure is one of the most serious forms of carrier replacement debt.
The critique is correct. Version 2 still makes the framework look too governable. The next version has to stop presenting Debt Theory as a complete ledger and reframe it as an adversarial diagnostic system with limited authority, built-in mortality, and explicit failure modes.
The core correction is this:
New Maths Debt Theory cannot be a sovereign governance system for mathematics. It can only be a pressure system: a way to expose where obligations are being hidden, displaced, laundered, ignored, or protected. Its own ledgers are provisional artifacts. Its own classifications are contestable. Its own auditors accumulate debt. Its own diagrams are abstractions with suppression costs.
Version 3 should therefore be built around anti-closure.
New Core Thesis
Mathematical debt cannot be fully centralized, fully classified, or fully governed. Any attempt to do so creates meta-debt. The purpose of Debt Theory is not to eliminate debt, nor to maintain a complete ledger, but to make hidden obligations harder to launder and easier to contest.
The corrected thesis is:
Mathematics advances by carrier movement, selective forgetting, proof compression, and occasional primitive collapse. These movements create obligations. Some obligations can be paid. Some can be bounded. Some can only be exposed. Some become counterkernels. Some invalidate the ledger that named them.
Debt Theory is therefore not a final accounting system. It is a hostile diagnostic discipline for detecting obligation displacement.
Collapse the Taxonomy
The many debt classes should become surface manifestations of fewer root families.
Structural debt concerns the mathematical object itself: wrong carrier, primitive mismatch, invalid invariant, failed liftback, hidden obstruction, abstraction failure, compactness failure, asymptotic overreach, and counterkernel formation. This is the deepest class because it concerns whether the mathematics has preserved the thing it claims to preserve.
Epistemic debt concerns the knowledge status of the object: exposition, formalization, computation, AI generation, proof replay, theorem identity, and evidential misclassification. This class concerns whether the community knows what kind of object it has.
Institutional debt concerns social power: citation laundering, prestige shielding, field fashion, protected counterkernels, ignored counterkernels, journal authority, prize authority, consensus pressure, and disciplinary gatekeeping. This class concerns whether the ledger reflects mathematics or status.
Meta-debt concerns the system itself: who audits the auditors, how ledgers drift, how standards change, how classifications become stale, how enforcement is bypassed, and how Debt Theory itself becomes a laundering device.
The earlier fine-grained classes are still useful, but only as diagnostic symptoms. The architecture should not pretend that “compactness debt,” “analogy debt,” and “AI generation debt” are ontologically equal root kinds. They are routes by which structural, epistemic, institutional, or meta-debt appears.
Replace Governance with Contestability
The governance layer should not imply a trusted council, final ledger, or stable enforcement apparatus. That is the fatal weakness. A debt system that depends on trusted auditors simply moves debt upward.
The replacement principle is contestability.
Every debt classification must be challengeable. Every ledger must have revision history. Every certificate must carry expiry conditions. Every counterkernel must be allowed to compete against protected narratives. Every high-status claim must receive stronger adversarial audit, not weaker audit. Every governance mechanism must declare its own debt.
The system does not ask “who audits the auditors?” as a rhetorical humility note. It answers: no auditor is final. Auditors are themselves ledgered, adversarially reviewable, and replaceable.
Add Ledger Mortality
Version 3 needs a concept of ledger death.
Some mathematical revolutions do not repay old debt. They destroy the accounting system in which the debt was defined. Naive set theory did not merely leave some obligations unpaid; it forced a reconstruction of foundational primitives. A paradigm shift can make an old ledger obsolete, not merely incomplete.
So the theory needs explicit ledger mortality conditions:
A ledger must be retired when its primitive vocabulary cannot express the active counterkernels. It must be reset when its classifications systematically protect status rather than detect obligation. It must be forked when rival carrier systems cannot be adjudicated inside the existing framework. It must be marked historical when its certificates no longer meet current standards.
This prevents Debt Theory from pretending that all progress is monotone repayment.
Counterkernel Privilege Must Become Central
Counterkernel privilege is not a minor risk. It is one of the central failure modes.
A counterkernel proposed from inside a prestigious field is more likely to be treated as deep obstruction. A counterkernel proposed from outside a recognized authority structure is more likely to be dismissed as noise. This means the ledger can become a map of status rather than a map of mathematical obstruction.
Version 3 must introduce adversarial counterkernel handling.
A counterkernel must be evaluated by its obstruction function, not its source. Does it block liftback? Does it expose primitive mismatch? Does it invalidate a transport? Does it force hypothesis revision? Does it reproduce across examples? Does it explain failed proof attempts? Does it survive hostile reformulation?
Prestige should increase scrutiny, not decrease it. Fashionable counterkernels should pay a status tax. Low-status counterkernels should receive minimum viable formalization before dismissal. Otherwise the debt ledger becomes a prestige ledger.
Hard Locks Need Teeth
The hard locks remain correct but weak. “Analogy is not proof” is true, but it is unenforced unless it changes what can be exported.
Version 3 should define hard locks as export blockers, not slogans.
An artifact that violates a hard lock cannot be labeled as certificate. It can be labeled as heuristic, route, conjecture, evidence, computation, exposition, or local result, but not as proof-bearing export. The lock must alter status. If status does not change, the lock has no force.
The enforcement mechanism is not perfect governance. It is status discipline. Every artifact must carry a public epistemic label: proof, conjecture, heuristic, computation, exposition, analogy, formal artifact, partial certificate, restricted export, or active debt. Mislabeling is the violation. The system cannot prevent all violations, but it can make the violation explicit.
AI Debt Must Become a Major Branch
AI generation debt is not one box. It is a debt multiplier.
AI creates semantic overproduction: more plausible mathematical language than the certificate ecology can absorb. It creates false rigor: text shaped like proof without proof obligation closure. It creates replayability collapse: many generated routes with no stable provenance. It accelerates value drift: standards of “looks plausible,” “passes tests,” and “good enough” shift in real time. It creates citation and theorem hallucination. It creates synthetic consensus by repeatedly reproducing dominant surface patterns.
The AI branch should include: packet explosion, hallucinated dependency, theorem-identity drift, proof-sketch laundering, false formalization confidence, synthetic exposition debt, replay overload, benchmark overfitting, and semantic saturation.
The important point is scale. Human mathematical debt accumulates slowly enough that communities can sometimes absorb it. AI debt can accumulate faster than human review capacity. That makes it qualitatively different.
Replace Linear Lifecycle with Debt Ecology
Even the improved lifecycle is still too process-like. Real debt behaves ecologically.
Old debts resurrect when a new carrier reveals that an accepted theorem was weaker than assumed. New debts appear retroactively when standards change. Some debts hibernate inside “well-known” lemmas. Some migrate into textbooks as false theorem-memory. Some become institutionalized through citation chains. Some are killed by paradigm reset. Some return as stronger forms after being dismissed.
The lifecycle should become a debt ecology with loops:
Debt is created, hidden, registered, contested, paid, displaced, laundered, resurrected, forked, quarantined, killed, or transformed. No stage is final except local export under declared standards. Even certificates can become debt under stronger future regimes.
This is not weakness. It is accurate.
Add Value Drift
Value drift is not peripheral. It determines what counts as paid.
A nineteenth-century proof, a Bourbaki-style proof, a computer-assisted proof, a Lean formalization, a probabilistic argument, and an AI-assisted proof sketch exist under different certificate cultures. Standards change. What counted as acceptable compression in one era may become active debt in another. What counted as excessive pedantry may become necessary infrastructure later.
Version 3 must treat certificate standards as historically unstable. A certificate is not absolute; it is indexed to a standard, a community, a use-context, and a time. This does not relativize truth. It relativizes export permission.
Add Debt Externalization
Debt externalization occurs when obligations are pushed onto “future work,” “the community,” “formalization later,” “standard arguments,” “well-known estimates,” “implementation details,” “the literature,” or “someone should check this.” This is one of the most common forms of mathematical fragility.
Externalized debt is not always illegitimate. Research necessarily defers work. But deferral becomes laundering when the deferred obligation is required for the claim’s current status.
Version 3 should distinguish honest deferral from laundering. Honest deferral labels the claim as conditional or active. Laundering preserves the stronger label while moving the obligation elsewhere.
Corrected Purpose
The purpose is not to create a complete, self-governing mathematical ledger. That is impossible and would itself become a brittle authority structure.
The purpose is narrower and stronger: expose hidden obligation, prevent category substitution, force export labels, detect laundering, preserve counterkernels, and identify when the current ledger itself must die.
Version 3 should be less clean, less symmetrical, and less optimistic. It should show that Debt Theory is itself debt-bearing.
Revised Verdict
New Maths Debt Theory is not a governance solution. It is an adversarial diagnostic discipline.
It cannot close mathematical knowledge production. It can make closure claims more expensive to fake.
It cannot eliminate social power. It can force power to declare itself as debt.
It cannot prevent AI overproduction. It can prevent AI output from being mislabeled as certificate.
It cannot guarantee fair counterkernel treatment. It can make counterkernel suppression a named failure mode.
It cannot avoid its own debt. It can require its own ledgers to be mortal, forkable, and revisable.
The corrected final thesis is:
Mathematical debt theory is valid only if it includes its own incompleteness, its own governance debt, its own susceptibility to laundering, and its own death conditions. Otherwise it becomes exactly what it was designed to audit.
Comments
Post a Comment