"""
Zero Paradox — PDF Builder (SUPERSEDED 2026-04-25)
Functions extracted to standalone scripts:
build_zpa.py, build_zpb.py, build_zpc.py, build_zpd.py
(companions were already standalone before this refactor)
build_zpe_da1() is retained here for reference only — it is archived;
the insert was superseded by ZP-E_Bridge_Document_v2_0 (build_zpe.py).
Do not add new document builders to this file.
"""
import os, sys
sys.stdout.reconfigure(encoding='utf-8')
from reportlab.lib import colors
from reportlab.lib.pagesizes import LETTER
from reportlab.lib.units import inch
from reportlab.lib.styles import ParagraphStyle
from reportlab.platypus import (SimpleDocTemplate, Paragraph, Spacer,
Table, TableStyle, PageBreak, HRFlowable)
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
# ── 1. PATH SETUP ────────────────────────────────────────────────────────────
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
FONT_DIR = os.path.join(PROJECT_ROOT, '.claude-local', 'fonts') + os.sep
OUT_DIR = os.path.join(PROJECT_ROOT, '.claude-local', 'build_output')
pdfmetrics.registerFont(TTFont('DV', FONT_DIR + 'DejaVuSans.ttf'))
pdfmetrics.registerFont(TTFont('DV-B', FONT_DIR + 'DejaVuSans-Bold.ttf'))
pdfmetrics.registerFont(TTFont('DV-I', FONT_DIR + 'DejaVuSans-Oblique.ttf'))
pdfmetrics.registerFont(TTFont('DV-BI', FONT_DIR + 'DejaVuSans-BoldOblique.ttf'))
pdfmetrics.registerFont(TTFont('DVS', FONT_DIR + 'STIXTwo-Math.ttf'))
pdfmetrics.registerFont(TTFont('DVS-B', FONT_DIR + 'STIXTwo-Math.ttf'))
pdfmetrics.registerFont(TTFont('DVS-I', FONT_DIR + 'STIXTwo-Math.ttf'))
pdfmetrics.registerFont(TTFont('DVS-BI',FONT_DIR + 'STIXTwo-Math.ttf'))
# ── 2. COLORS ─────────────────────────────────────────────────────────────────
BLUE = colors.HexColor('#2E75B6')
BLUE_LITE = colors.HexColor('#D5E8F0')
GREY_LITE = colors.HexColor('#F5F5F5')
BLACK = colors.black
WHITE = colors.white
# Companion palette: 15% white tint on formal header colors
COMP_BLUE = colors.HexColor('#4D89C0')
COMP_GREEN = colors.HexColor('#4D9050')
COMP_SLATE = colors.HexColor('#60727B')
COMP_AMBER = colors.HexColor('#BB8C26')
SLATE_LITE = colors.HexColor('#ECEFF1')
AMBER_LITE = colors.HexColor('#FFF8E7')
# ── 3. PAGE GEOMETRY ──────────────────────────────────────────────────────────
TW = 6.5 * inch # text width (US Letter − 2 × 1 inch margins)
LM = RM = 1.0 * inch
TM = BM = 1.0 * inch
# ── 4. PARAGRAPH STYLES ───────────────────────────────────────────────────────
S = {
'title': ParagraphStyle('title', fontName='DV-B', fontSize=18, leading=24,
spaceAfter=6, alignment=1),
'subtitle': ParagraphStyle('subtitle', fontName='DV-I', fontSize=11, leading=15,
spaceAfter=4, alignment=1),
'h1': ParagraphStyle('h1', fontName='DV-B', fontSize=13, leading=18,
spaceBefore=14, spaceAfter=5,
textColor=BLUE),
'h2': ParagraphStyle('h2', fontName='DV-B', fontSize=11, leading=15,
spaceBefore=10, spaceAfter=4,
textColor=BLUE),
'h3': ParagraphStyle('h3', fontName='DV-B', fontSize=10, leading=14,
spaceBefore=8, spaceAfter=3),
'body': ParagraphStyle('body', fontName='DVS', fontSize=10, leading=14,
spaceAfter=6),
'bodyI': ParagraphStyle('bodyI', fontName='DVS-I', fontSize=10, leading=14,
spaceAfter=6),
'label': ParagraphStyle('label', fontName='DV-B', fontSize=9, leading=13,
textColor=WHITE),
'cell': ParagraphStyle('cell', fontName='DVS', fontSize=9, leading=13),
'cellB': ParagraphStyle('cellB', fontName='DVS-B', fontSize=9, leading=13),
'cellSans': ParagraphStyle('cellSans', fontName='DV', fontSize=9, leading=13),
'cellI': ParagraphStyle('cellI', fontName='DVS-I', fontSize=9, leading=13),
'footer': ParagraphStyle('footer', fontName='DV-I', fontSize=8, leading=10,
textColor=colors.grey, alignment=1),
'note': ParagraphStyle('note', fontName='DVS-I', fontSize=9, leading=13,
spaceAfter=4),
}
# ── 5. HELPERS ────────────────────────────────────────────────────────────────
def sp(n=6):
return Spacer(1, n)
def chk():
"""Checkmark safe for any context — always uses DV font."""
return '✓'
def fix(text):
"""
Convert plain-text math notation to HTML entities safe for ReportLab.
Also replaces bare ✓ with the font-switched version.
Uses sub/super tags for subscripts/superscripts instead of unicode chars.
"""
# Protect existing tags
import re
# Subscript/superscript unicode → sub/super tags
sub_map = {'₀':'0','₁':'1','₂':'2','₃':'3','₄':'4',
'₅':'5','₆':'6','₇':'7','₈':'8','₉':'9',
'ₙ':'n','ₖ':'k','ₘ':'m','ᵢ':'i','ⱼ':'j',
'₊':'+','₋':'-'}
sup_map = {'⁰':'0','¹':'1','²':'2','³':'3','⁴':'4',
'⁵':'5','⁶':'6','⁷':'7','⁸':'8','⁹':'9',
'ⁿ':'n','ᵏ':'k','∞':'∞'}
for ch, rep in sub_map.items():
text = text.replace(ch, f'{rep}')
for ch, rep in sup_map.items():
text = text.replace(ch, f'{rep}')
# Checkmark — must use DV font in Serif context
text = text.replace('✓', '✓')
text = text.replace('\u2717', '✗')
# ∅ (U+2205 empty set) is MISSING from DejaVuSerif — must use DV Sans
text = text.replace('\u2205', '∅')
# Math symbols to entities (only if not already entity)
replacements = [
('⊥', '⊥'), ('∨', '∨'), ('∧', '∧'),
('≤', '≤'), ('≥', '≥'), ('≠', '≠'),
('∈', '∈'), ('∉', '∉'), ('⊆', '⊆'),
('∪', '∪'), ('∩', '∩'), ('∀', '∀'),
('∃', '∃'), ('∞', '∞'), ('∑', '∑'),
('→', '→'), ('←', '←'), ('↔', '↔'),
('⇒', '⇒'), ('⟺', '⟺'), ('⟹', '⟹'),
('⟨', '⟨'), ('⟩', '⟩'), ('‖', '‖'),
('—', '—'), ('–', '–'), ('·', '·'),
('×', '×'), ('−', '−'), ('≡', '≡'),
('∘', '∘'), ('⊗', '⊗'),
('ε', 'ε'), ('α', 'α'), ('β', 'β'),
('γ', 'γ'), ('δ', 'δ'), ('η', 'η'),
('σ', 'σ'), ('π', 'π'),
('Δ', 'Δ'), ('Σ', 'Σ'), ('Γ', 'Γ'),
('ℚ', 'ℚ'), ('ℤ', 'ℤ'), ('ℂ', 'ℂ'),
('ℕ', 'ℕ'), ('ℝ', 'ℝ'),
('∥', '∥'), ('⊕', '⊕'),
]
for char, entity in replacements:
if char not in text:
continue
# Don't double-replace
text = text.replace(char, entity)
return text
def body(text, style='body'):
return Paragraph(fix(text), S[style])
def label_box(title, rows_list):
"""
Blue header + white-on-blue label + content rows.
rows_list: list of strings (each becomes a Paragraph cell).
"""
data = [[Paragraph(fix(title), S['label'])]]
for r in rows_list:
data.append([Paragraph(fix(r), S['cell'])])
ts = TableStyle([
('BACKGROUND', (0,0), (-1,0), BLUE),
('BACKGROUND', (0,1), (-1,-1), GREY_LITE),
('TEXTCOLOR', (0,0), (-1,0), WHITE),
('BOX', (0,0), (-1,-1), 0.5, BLUE),
('LINEBELOW', (0,0), (-1,0), 0.5, BLUE),
('LINEBEFORE', (0,0), (-1,-1), 0.5, colors.HexColor('#CCCCCC')),
('LINEAFTER', (0,0), (-1,-1), 0.5, colors.HexColor('#CCCCCC')),
('LINEBELOW', (0,1), (-1,-2), 0.5, colors.HexColor('#CCCCCC')),
('TOPPADDING', (0,0), (-1,-1), 5),
('BOTTOMPADDING',(0,0), (-1,-1), 5),
('LEFTPADDING', (0,0), (-1,-1), 8),
('RIGHTPADDING', (0,0), (-1,-1), 8),
('VALIGN', (0,0), (-1,-1), 'TOP'),
])
t = Table(data, colWidths=[TW], repeatRows=1)
t.setStyle(ts)
return t
def data_table(headers, rows_data, col_widths, header_bg=BLUE):
"""
General data table with Paragraph cells (per standards section 3).
headers: list of str
rows_data: list of list of str
col_widths: list of inch values, must sum to TW
"""
hdr_row = [Paragraph(fix(h), S['label']) for h in headers]
data = [hdr_row]
for row in rows_data:
data.append([Paragraph(fix(str(c)), S['cell']) for c in row])
ts = TableStyle([
('BACKGROUND', (0,0), (-1,0), header_bg),
('BACKGROUND', (0,1), (-1,-1), GREY_LITE),
('ROWBACKGROUNDS',(0,1), (-1,-1), [WHITE, GREY_LITE]),
('BOX', (0,0), (-1,-1), 0.5, BLUE),
('LINEBELOW', (0,0), (-1,0), 0.5, BLUE),
('INNERGRID', (0,1), (-1,-1), 0.3, colors.HexColor('#CCCCCC')),
('LINEAFTER', (0,0), (-1,-1), 0.3, colors.HexColor('#CCCCCC')),
('TOPPADDING', (0,0), (-1,-1), 4),
('BOTTOMPADDING', (0,0), (-1,-1), 4),
('LEFTPADDING', (0,0), (-1,-1), 6),
('RIGHTPADDING', (0,0), (-1,-1), 6),
('VALIGN', (0,0), (-1,-1), 'TOP'),
])
t = Table(data, colWidths=col_widths, repeatRows=1)
t.setStyle(ts)
return t
def make_doc(path, title_str, doc_id, version_str):
"""Create SimpleDocTemplate with footer."""
def footer_cb(canvas, doc):
canvas.saveState()
canvas.setFont('DV-I', 8)
canvas.setFillColor(colors.grey)
footer_text = f"Zero Paradox {doc_id} | {version_str} | April 2026 | Page {doc.page}"
canvas.drawCentredString(LETTER[0]/2, 0.6*inch, footer_text)
canvas.restoreState()
return SimpleDocTemplate(
path,
pagesize=LETTER,
leftMargin=LM, rightMargin=RM, topMargin=TM, bottomMargin=BM,
title=title_str,
author="Zero Paradox Project",
onFirstPage=footer_cb,
onLaterPages=footer_cb,
)
# ── DOCUMENT BUILDERS ─────────────────────────────────────────────────────────
def build_zpa():
doc = make_doc(os.path.join(OUT_DIR, 'ZP-A_Lattice_Algebra_v1_5.pdf'),
'ZP-A: Lattice Algebra', 'ZP-A', 'Version 1.5')
E = []
E += [Paragraph('THE ZERO PARADOX', S['title']),
Paragraph('ZP-A: Lattice Algebra', S['subtitle']),
Paragraph('Version 1.5 | April 2026', S['subtitle']),
Paragraph('Supersedes v1.4 | Theorem/Proposition/Lemma hierarchy applied; R2 terminology note; CC-1 corollary clarified', S['subtitle']),
sp(10),
body('This document is self-contained within abstract algebra. No topology, probability, or Hilbert space is imported. Every claim is provable using only the tools of semilattice theory. Cross-framework connections are deferred to ZP-E.'),
body('Illustrated Companion: A paired ZP-A Illustrated Companion document provides concrete examples and visual intuitions for the results in this document. Examples are kept separate from the formal layers to distinguish illustrative material from proofs. The companion is a reading aid; no proof-critical judgements should be drawn from examples alone.'),
body('Version 1.5 changes: (1) Theorem/Proposition/Lemma hierarchy applied throughout: T1 relabelled Proposition (partial order properties are infrastructure), T2 relabelled Lemma (the global minimum result is a stepping stone for CC-1 and T3). T3 retains Theorem (monotonicity is the primary result of ZP-A). (2) Remark R2 added after D3 connecting the term "state sequence" to the standard order-theory term "ascending chain". (3) CC-1 corollary reworded to make explicit that T2 gives ⊥ ≤ S₀ for any initialisation; CC-1 strengthens this to equality.'),
body('Version 1.4 change: OQ-A1 section heading and box label corrected from "Open Question" to "CLOSED". The resolution was already recorded in the status line (closed by ZP-E T5 via AX-B1) but the section header was misleading. Status line expanded to answer both sub-questions explicitly.'),
body('Version 1.3 changes: (1) Definition D2: the equivalence statement now makes explicit that α depends on x — "for each x ∈ L, f(x) = x ∨ α for some α ∈ L". (2) Theorem T3 proof: replaced the single spelled-out "iff" with ⟺ for consistency. (3) CC-1: removed circular conditional framing; reframed as a direct modelling commitment; corrected the consequence chain to S₀ = ⊥ ≤ S₁ ≤ …; replaced informal "constituent" with direct T2 reference.'),
body('Version 1.2 changes: (1) Definition D1: the notation :⟺ (non-standard) replaced by the standard definitional framing "define the relation ≤ by". (2) Definition D2: the equivalence between x ≤ f(x) and f(x) = x ∨ α is now accompanied by an explicit two-line proof of both directions.'),
body('Version 1.1 change: Theorem T4 reclassified as Conditional Claim CC-1. The v1.0 label "Theorem" was imprecise: the result holds only given the assumption that the state sequence is initialised at the minimum of L. This assumption is not derived from A1–A4 — it is a modelling commitment.'),
sp()]
E.append(Paragraph('I. Primitives and Axioms', S['h1']))
E.append(Paragraph('1.1 Signature', S['h2']))
E.append(body('The algebraic signature of the Zero Paradox state space is a triple: (L, ∨, ⊥)'))
E.append(body('L is a non-empty set (the carrier set of states). ∨ : L × L → L is a binary operation called join. ⊥ ∈ L is a distinguished constant called the bottom element.'))
E.append(sp(4))
E.append(label_box('Axiom Block A — Join-Semilattice with Bottom', [
'A1 — Associativity: (x ∨ y) ∨ z = x ∨ (y ∨ z) for all x, y, z ∈ L',
'A2 — Commutativity: x ∨ y = y ∨ x for all x, y ∈ L',
'A3 — Idempotency: x ∨ x = x for all x ∈ L',
'A4 — Identity (Additive): ⊥ ∨ x = x for all x ∈ L',
]))
E.append(sp(4))
E.append(body('A4 is the load-bearing axiom. It makes ⊥ the additive identity of the algebra: the element that contributes nothing to a join and is therefore present in every state as the neutral constituent.'))
E.append(Paragraph('II. The Induced Partial Order', S['h1']))
E.append(Paragraph('2.1 Definition of ≤', S['h2']))
E.append(label_box('Definition D1 — Lattice Order', [
'For x, y ∈ L, define the relation ≤ by:',
'x ≤ y ⟺ x ∨ y = y',
]))
E.append(sp(4))
E.append(label_box('Proposition T1 — ≤ is a Partial Order', [
'Reflexivity: x ≤ x — by A3, x ∨ x = x. ✓',
'Antisymmetry: if x ≤ y and y ≤ x, then x ∨ y = y and y ∨ x = x. By A2, y = x ∨ y = y ∨ x = x. ✓',
'Transitivity: if x ≤ y and y ≤ z, then x ∨ z = x ∨ (y ∨ z) = (x ∨ y) ∨ z = y ∨ z = z, so x ≤ z. ✓',
]))
E.append(sp(4))
E.append(Paragraph('2.2 ⊥ is the Least Element', S['h2']))
E.append(label_box('Lemma T2 — ⊥ is a Global Minimum under ≤', [
'For all x ∈ L: ⊥ ≤ x',
'Proof: By A4, ⊥ ∨ x = x. By D1, this is the definition of ⊥ ≤ x. ✓',
]))
E.append(sp(4))
E.append(body('T2 is the algebraic statement of the foundational claim: ⊥ is not a void that states depart from — it is the minimum element that every state sits above. Since ⊥ ≤ x for all x, and join accumulates from the bottom, ⊥ is algebraically present in every element of L.'))
E.append(Paragraph('III. The Additive Ontology', S['h1']))
E.append(Paragraph('3.1 No Subtraction Operator', S['h2']))
E.append(label_box('Remark R1 — Join-Semilattice vs. Lattice', [
'A full lattice (L, ∨, ∧, ⊥, ⊤) includes a meet operator ∧ and a top element ⊤. The Zero Paradox restricts to the join-semilattice with bottom. The meet operator is excluded because it would allow state reduction — the removal of informational content from a state. The additive ontology requires that no operation decreases informational content.',
]))
E.append(sp(4))
E.append(Paragraph('3.2 Join is the Only State Transition', S['h2']))
E.append(label_box('Definition D2 — State Transition', [
'A state transition is any function f: L → L such that x ≤ f(x) for all x ∈ L.',
'Equivalently, for each x ∈ L, f(x) = x ∨ α for some α ∈ L.',
'Proof of equivalence:',
'(⇒) If x ≤ f(x), then x ∨ f(x) = f(x) by D1. Take α = f(x): then f(x) = x ∨ α. ✓',
'(⇐) If f(x) = x ∨ α for some α ∈ L, then x ∨ f(x) = x ∨ (x ∨ α) = (x ∨ x) ∨ α = x ∨ α = f(x) by A1, A3. By D1, x ≤ f(x). ✓',
]))
E.append(Paragraph('IV. Monotonicity of State Sequences', S['h1']))
E.append(Paragraph('4.1 State Sequences', S['h2']))
E.append(label_box('Definition D3 — State Sequence', [
'A state sequence is a function S: ℕ → L, written (S0, S1, S2, …), such that:',
'Sn+1 = Sn ∨ αn for some αn ∈ L, for all n ∈ ℕ',
]))
E.append(sp(4))
E.append(label_box('Remark R2 — Terminology: State Sequence and Ascending Chain', [
'In the order-theory literature, a sequence (Sn) satisfying Sn ≤ Sn+1 for all n is called an ascending chain. The term "state sequence" is used here in place of "ascending chain" to align with the state-transition framing of ZP-D and ZP-E, where the same structure is introduced as sequences of system states. The two terms denote the same mathematical object. Readers familiar with order theory should read "state sequence" as "ascending chain". For concrete illustrations, see the ZP-A Illustrated Companion.',
]))
E.append(sp(4))
E.append(label_box('Theorem T3 — State Sequences are Monotone', [
'For any state sequence (Sn) satisfying D3: Sn ≤ Sn+1 for all n ∈ ℕ',
'Proof: By D3, Sn+1 = Sn ∨ αn. By D1, Sn ≤ Sn ∨ αn ⟺ Sn ∨ (Sn ∨ αn) = Sn ∨ αn. By A1, (Sn ∨ Sn) ∨ αn = Sn ∨ αn. By A3, Sn ∨ Sn = Sn. Therefore Sn ∨ αn = Sn+1. ✓',
'Monotonicity is a theorem, not a postulate. It is derived from A1–A3 via D3.',
]))
E.append(sp(4))
E.append(Paragraph('4.2 The Initial State', S['h2']))
E.append(label_box('Conditional Claim CC-1 — S\u2080 = ⊥ (Reclassified from T4 in v1.0)', [
'We commit to initialising every state sequence at the minimum of L: S0 = ⊥. This is not derived from A1–A4 — it is a modelling choice.',
'Under CC-1 and T3: S0 = ⊥ ≤ S1 ≤ S2 ≤ …',
'Note: By T2, ⊥ ≤ S0 for any initialisation — this holds unconditionally from A4. CC-1 strengthens this to equality: S0 = ⊥. The commitment is not needed to establish ⊥ ≤ S0; it is needed to fix the starting point precisely.',
'Status: CONDITIONAL CLAIM — modelling commitment; not derived from A1–A4.',
]))
E.append(Paragraph('V. OQ-A1 — Sufficiency of Monotonicity', S['h1']))
E.append(label_box('OQ-A1 — Sufficiency of Monotonicity [CLOSED — ZP-E T5]', [
'Is the monotonicity constraint (T3) sufficient to characterise all valid state sequences, or are additional axioms required?',
'OQ-A1a: Is there algebraic reason to restrict αn to join-irreducible elements (not expressible as joins of strictly smaller elements)?',
'OQ-A1b: Does the open-ended semilattice (without top element ⊤) permit unbounded ascending chains?',
'Status: CLOSED — Both sub-questions resolved by ZP-E Theorem T5 (Iterative Forcing Theorem) via AX-B1 from ZP-B. OQ-A1a: αn = ε(Sn), the minimum viable deviation. OQ-A1b: AX-B1\'s binary constraint bounds ascending chains.',
]))
E.append(Paragraph('VI. Boundary Conditions', S['h1']))
E.append(data_table(
['Export', 'Status / Receiving Document'],
[['(L, ∨, ⊥) as join-semilattice', 'Derived (A1–A4) — ZP-D: algebraic structure of state space'],
['≤ partial order (D1, T1)', 'Derived — ZP-D: ordering on states'],
['Monotonicity of state sequences (T3)', 'Derived from A1–A3 — ZP-D: state layer ordering'],
['⊥ as global minimum (T2, CC-1)', 'Derived / Conditional — ZP-E: ontological grounding claim'],
['No subtraction / additive ontology (R1)', 'Structural — ZP-C: no operation may reduce informational content'],
['OQ-A1 — increment selection', 'Open within ZP-A; closed by ZP-E T5']],
[2.5*inch, 4.0*inch]
))
E.append(Paragraph('VII. Validation Status', S['h1']))
E.append(data_table(
['Component', 'Status / Notes'],
[['A1–A4 join-semilattice axioms', 'Valid — Axioms; self-contained'],
['≤ partial order (D1, T1)', 'Valid — Derived from A1–A3'],
['⊥ as least element (T2)', 'Valid — Derived from A4 and D1'],
['Additive ontology / no subtraction (R1)', 'Valid — Structural; signature restriction'],
['State transition as join (D2)', 'Valid — Defined; consistent with signature'],
['Monotonicity of state sequences (T3)', 'Valid — Derived from A1–A3 and D3'],
['CC-1: S0 = ⊥', 'Conditional Claim — modelling commitment; not derived from A1–A4'],
['OQ-A1: Sufficiency of monotonicity', 'Open within ZP-A; closed by ZP-E T5']],
[2.5*inch, 4.0*inch]
))
doc.build(E)
print('ZP-A done')
def build_zpa_companion():
"""Illustrated companion for ZP-A, v1.2. Adds Dan's suggested examples."""
from reportlab.graphics.shapes import Drawing, Circle, Line, String
RED_C = colors.HexColor('#BB2222')
# Companion paragraph styles
CS = {
'title': ParagraphStyle('ctitle', fontName='DV-B', fontSize=22, leading=28,
alignment=1, spaceAfter=4, textColor=BLACK),
'subtitle': ParagraphStyle('csubtitle',fontName='DV-I', fontSize=12, leading=16,
alignment=1, spaceAfter=4),
'meta': ParagraphStyle('cmeta', fontName='DV', fontSize=9, leading=13,
alignment=1, spaceAfter=8, textColor=colors.grey),
'disc': ParagraphStyle('cdisc', fontName='DVS-I', fontSize=9, leading=13,
spaceAfter=10, textColor=colors.HexColor('#555555')),
'h1': ParagraphStyle('ch1', fontName='DV-B', fontSize=13, leading=17,
spaceBefore=14, spaceAfter=5, textColor=COMP_BLUE),
'body': ParagraphStyle('cbody', fontName='DVS', fontSize=10, leading=14,
spaceAfter=6),
'caption': ParagraphStyle('ccaption', fontName='DVS-I', fontSize=9, leading=12,
spaceAfter=8, textColor=colors.HexColor('#555555')),
'ex_title': ParagraphStyle('cex_title',fontName='DV-B', fontSize=9, leading=13,
textColor=COMP_AMBER),
'ex_body': ParagraphStyle('cex_body', fontName='DVS', fontSize=9, leading=13),
'rem': ParagraphStyle('crem', fontName='DVS-I', fontSize=9, leading=13),
'kr_hdr': ParagraphStyle('ckr_hdr', fontName='DVS-B', fontSize=9, leading=13,
textColor=WHITE),
'kr_body': ParagraphStyle('ckr_body', fontName='DVS', fontSize=9, leading=13),
}
def cbody(text):
return Paragraph(fix(text), CS['body'])
def example_box(title, rows):
data = [[Paragraph(title, CS['ex_title'])]]
for r in rows:
data.append([Paragraph(fix(r), CS['ex_body'])])
ts = TableStyle([
('BOX', (0,0), (-1,-1), 1.5, COMP_AMBER),
('LINEBELOW', (0,0), (-1,0), 0.5, COMP_AMBER),
('BACKGROUND', (0,0), (-1,-1), AMBER_LITE),
('TOPPADDING', (0,0), (-1,-1), 5),
('BOTTOMPADDING', (0,0), (-1,-1), 5),
('LEFTPADDING', (0,0), (-1,-1), 8),
('RIGHTPADDING', (0,0), (-1,-1), 8),
('VALIGN', (0,0), (-1,-1), 'TOP'),
])
t = Table(data, colWidths=[TW])
t.setStyle(ts)
return t
def remember_box(text):
ts = TableStyle([
('BACKGROUND', (0,0), (-1,-1), SLATE_LITE),
('BOX', (0,0), (-1,-1), 0.5, COMP_SLATE),
('TOPPADDING', (0,0), (-1,-1), 8),
('BOTTOMPADDING', (0,0), (-1,-1), 8),
('LEFTPADDING', (0,0), (-1,-1), 10),
('RIGHTPADDING', (0,0), (-1,-1), 10),
])
t = Table([[Paragraph(fix(text), CS['rem'])]], colWidths=[TW])
t.setStyle(ts)
return t
def key_result_box(title, body_text):
data = [[Paragraph(fix(title), CS['kr_hdr'])],
[Paragraph(fix(body_text), CS['kr_body'])]]
ts = TableStyle([
('BACKGROUND', (0,0), (-1,0), COMP_GREEN),
('BACKGROUND', (0,1), (-1,-1), colors.white),
('BOX', (0,0), (-1,-1), 0.5, COMP_GREEN),
('TOPPADDING', (0,0), (-1,-1), 6),
('BOTTOMPADDING', (0,0), (-1,-1), 6),
('LEFTPADDING', (0,0), (-1,-1), 8),
('RIGHTPADDING', (0,0), (-1,-1), 8),
('VALIGN', (0,0), (-1,-1), 'TOP'),
])
t = Table(data, colWidths=[TW])
t.setStyle(ts)
return t
def hasse_diagram():
dw, dh = TW, 2.6 * inch
d = Drawing(dw, dh)
cx = dw / 2
r = 18
y0, y1, y2 = 45, 125, 200
nodes1 = [(cx - 100, y1), (cx, y1), (cx + 100, y1)]
nodes2 = [(cx - 150, y2), (cx - 55, y2), (cx + 55, y2), (cx + 150, y2)]
lc = colors.HexColor('#888888')
for nx, ny in nodes1:
d.add(Line(cx, y0 + r, nx, ny - r, strokeColor=lc, strokeWidth=1))
for i, (nx, ny) in enumerate(nodes1):
for j, (tx, ty) in enumerate(nodes2):
if abs(i - j) <= 1:
d.add(Line(nx, ny + r, tx, ty - r, strokeColor=lc, strokeWidth=1))
for xi in [cx - 195, cx - 85, cx + 30, cx + 175]:
d.add(String(xi, y2 + r + 6, '...', fontSize=10, fontName='DV',
fillColor=colors.HexColor('#666666')))
d.add(Circle(cx, y0, r, fillColor=colors.HexColor('#F0A000'),
strokeColor=colors.HexColor('#F0A000'), strokeWidth=0))
d.add(String(cx - 6, y0 - 6, '⊥', fontSize=14, fontName='DV-B',
fillColor=colors.white))
for nx, ny in nodes1:
d.add(Circle(nx, ny, r, fillColor=COMP_BLUE, strokeColor=COMP_BLUE, strokeWidth=0))
d.add(String(nx - 4, ny - 5, 'S', fontSize=11, fontName='DV-B',
fillColor=colors.white))
for tx, ty in nodes2:
d.add(Circle(tx, ty, r, fillColor=COMP_BLUE, strokeColor=COMP_BLUE, strokeWidth=0))
d.add(String(tx - 4, ty - 5, 'S', fontSize=11, fontName='DV-B',
fillColor=colors.white))
lx = dw - 1.6 * inch
d.add(Circle(lx, y0 + 4, 7, fillColor=colors.HexColor('#F0A000'),
strokeColor=colors.HexColor('#F0A000'), strokeWidth=0))
d.add(String(lx + 12, y0 - 1, '= bottom (additive identity)',
fontSize=7.5, fontName='DVS', fillColor=BLACK))
d.add(Circle(lx, y0 - 20, 7, fillColor=COMP_BLUE, strokeColor=COMP_BLUE, strokeWidth=0))
d.add(String(lx + 12, y0 - 25, 'States in L',
fontSize=7.5, fontName='DVS', fillColor=BLACK))
return d
def transition_diagram():
dw, dh = TW, 1.5 * inch
d = Drawing(dw, dh)
cy = dh * 0.62
r = 22
xs = [r + 10, r + 120, r + 230, r + 340, r + 440]
lc = COMP_BLUE
ac = colors.HexColor('#F0A000')
d.add(Circle(xs[0], cy, r, fillColor=ac, strokeColor=ac, strokeWidth=0))
d.add(String(xs[0] - 6, cy - 6, '⊥', fontSize=14, fontName='DV-B',
fillColor=colors.white))
for i in range(1, 4):
d.add(Circle(xs[i], cy, r, fillColor=lc, strokeColor=lc, strokeWidth=0))
d.add(String(xs[i] - 8, cy - 5, f'S{i}', fontSize=10, fontName='DV-B',
fillColor=colors.white))
d.add(String(xs[4] - 8, cy - 5, '...', fontSize=12, fontName='DV',
fillColor=colors.HexColor('#555555')))
for i in range(3):
x1 = xs[i] + r + 2
x2 = xs[i + 1] - r - 2
d.add(Line(x1, cy, x2, cy, strokeColor=lc, strokeWidth=2))
d.add(Line(x2 - 7, cy - 4, x2, cy, strokeColor=lc, strokeWidth=2))
d.add(Line(x2 - 7, cy + 4, x2, cy, strokeColor=lc, strokeWidth=2))
ry = cy - r - 14
x_l = xs[0]
x_r = xs[3]
d.add(Line(x_l, ry, x_r, ry, strokeColor=RED_C, strokeWidth=1.5,
strokeDashArray=[6, 4]))
d.add(Line(x_l + 8, ry - 4, x_l, ry, strokeColor=RED_C, strokeWidth=1.5))
d.add(Line(x_l + 8, ry + 4, x_l, ry, strokeColor=RED_C, strokeWidth=1.5))
mid = (x_l + x_r) / 2
d.add(String(mid - 45, ry - 14, '✗ No return path', fontSize=9,
fontName='DV-B', fillColor=RED_C))
return d
# ── Build content ──────────────────────────────────────────────────────────
doc = make_doc(os.path.join(OUT_DIR, 'ZP-A_Illustrated_Companion.pdf'),
'ZP-A Illustrated Companion', 'ZP-A Companion', 'Version 1.2')
E = []
# Header banner
hdr_ts = TableStyle([
('BACKGROUND', (0,0), (-1,-1), COMP_BLUE),
('TOPPADDING', (0,0), (-1,-1), 8),
('BOTTOMPADDING', (0,0), (-1,-1), 8),
('LEFTPADDING', (0,0), (-1,-1), 10),
])
hdr = Table([[Paragraph('ZP-A Illustrated Companion',
ParagraphStyle('hdr', fontName='DV-B', fontSize=11,
textColor=WHITE))]], colWidths=[TW])
hdr.setStyle(hdr_ts)
E.append(hdr)
E.append(sp(6))
E += [
Paragraph('How state accumulates without ever going backwards', CS['title']),
Paragraph('Lattice Algebra | Version 1.2', CS['subtitle']),
Paragraph('ZP Companion | April 2026', CS['meta']),
Paragraph(
'This companion explains the ideas in plain language with diagrams and real-world '
'examples. It is not the formal ontology — every claim here restates a result already '
'proven in the corresponding technical document. Consult that document for the '
'authoritative mathematics.',
CS['disc']),
]
# ── What Is ZP-A Doing? ────────────────────────────────────────────────────
E.append(Paragraph('What Is ZP-A Doing?', CS['h1']))
E.append(cbody(
'ZP-A establishes the algebraic rules for how states behave in the Zero Paradox '
'framework. It uses a structure called a join-semilattice — the simplest algebraic '
'system that can describe accumulation without subtraction. Think of it as a ledger '
'where entries can only be added, never erased.'))
E.append(cbody(
'The central object is the triple (L, ∨, ⊥): a set of states L, a joining '
'operation ∨ that combines two states into a larger one, and a special bottom '
'element ⊥ that represents the absolute starting point. Four axioms (A1–A4) '
'say that joining is associative, commutative, idempotent, and that ⊥ is a '
'neutral element.'))
E.append(sp(4))
E.append(example_box('Real-world example — Bank ledger', [
'Think of ⊥ as a brand-new account with zero balance. Every transaction adds to '
'the ledger. There is no undo operation — once a deposit is recorded, the total can '
'only stay the same or grow. The join-semilattice captures exactly this: accumulation '
'without reversal.',
]))
E.append(sp(4))
E.append(remember_box(
'Remember: The bank account is just one way to picture it. The framework applies to '
'any system where state can only accumulate — energy, information, or any other '
'monotone quantity.'))
# ── The Partial Order ──────────────────────────────────────────────────────
E.append(Paragraph('The Partial Order: States Have a Natural Height', CS['h1']))
E.append(cbody(
'From the four axioms, a partial order falls out automatically: state x is "below" y '
'if joining x with y just gives y back — y already contains everything x does. '
'⊥ is always at the very bottom.'))
E.append(sp(8))
E.append(hasse_diagram())
E.append(sp(4))
E.append(Paragraph(
'Hasse diagram: partial order on L. Arrows point upward. ⊥ (amber) is the '
'universal minimum. Every state sits above ⊥.',
CS['caption']))
E.append(sp(4))
E.append(example_box('Real-world example — Biological complexity', [
'Think of ⊥ as the simplest possible organism. More complex life forms are '
'"above" simpler ones: they contain everything the simpler form has, plus more. '
'In this abstract sense, complexity only accumulates.',
]))
# ── No Subtraction ─────────────────────────────────────────────────────────
E.append(Paragraph('No Subtraction', CS['h1']))
E.append(cbody(
'The join-semilattice deliberately omits subtraction. State content can only '
'accumulate, never be removed. Every valid transition moves upward.'))
E.append(sp(8))
E.append(transition_diagram())
E.append(sp(4))
E.append(Paragraph(
'State transitions are one-directional. The red dashed line — a return path — '
'does not exist in this algebra.',
CS['caption']))
E.append(sp(4))
E.append(key_result_box(
'Key Result: Monotonicity is a Theorem — not an Assumption (T3)',
'For any state sequence built by joining, S₀ ≤ S₁ ≤ S₂ '
'≤ … This is derived from the axioms, not assumed. The sequence can only '
'go up.'))
E.append(sp(4))
E.append(key_result_box(
'Key Result: ⊥ is a Constituent of Every State (T2)',
'⊥ ≤ x for all x in L. ⊥ is not a void that states escape from — '
'it is algebraically present in every state. Zero is not absence; it is the universal '
'base.'))
E.append(sp(4))
E.append(example_box('Real-world example — Silence in music', [
'Silence is not the absence of the piece — it is the baseline from which every note '
'departs. Every musical state contains silence as its foundation. The join-semilattice '
'captures this: ⊥ is a constituent of every state.',
]))
# ── More Examples ─────────────────────────────────────────────────────────
E.append(Paragraph('More Examples of Join-Semilattices', CS['h1']))
E.append(cbody(
'A join-semilattice appears in many mathematical and everyday settings. Here are '
'four concrete instantiations of (L, ∨, ⊥), each satisfying A1–A4.'))
E.append(sp(4))
E.append(example_box('Example — Power set with union', [
'Let X be any set. Take L = P(X) (the collection of all subsets of X), '
'∨ = ∪ (set union), and ⊥ = ∅ (the empty set). Union is '
'associative, commutative, idempotent (A ∪ A = A), and the empty set is a '
'neutral element (∅ ∪ A = A). The induced order is inclusion: A ≤ B '
'iff A ∪ B = B, i.e. A ⊆ B. Every element of L sits above ∅.',
]))
E.append(sp(4))
E.append(example_box('Example — [0, ∞) with maximum', [
'Take L = [0, ∞), ∨ = max (the larger of two values), and ⊥ = 0. '
'Maximum is associative, commutative, idempotent (max(x, x) = x), and 0 is a neutral '
'element (max(0, x) = x for x ≥ 0). The induced order is the usual ≤ on '
'real numbers: x ≤ y iff max(x, y) = y. Note: addition would not work here — '
'x + x = 2x ≠ x, violating idempotency (A3).',
]))
E.append(sp(4))
E.append(example_box('Example — Functions with pointwise maximum', [
'Let X be any set. Take L to be the set of all functions f: X → [0, ∞), '
'∨ = pointwise maximum ((f ∨ g)(x) = max(f(x), g(x))), and ⊥ = the '
'zero function. All four axioms hold pointwise. The induced order is f ≤ g iff '
'f(x) ≤ g(x) for all x ∈ X. This is a function-space version of the '
'previous example — one level up in abstraction.',
]))
E.append(sp(4))
E.append(example_box('Example — Document edit history', [
'Open a document and start making edits. Even hitting Backspace does not erase from '
'the edit record — it adds a new deletion event to the history. Each saved state of '
'the document sits above all states that preceded it. The history can only grow. '
'The "join" of two document states is the later one (or the merge if branches exist). '
'The ⊥ state is the empty document. No edit operation removes from the record.',
]))
# ── Closing remember ───────────────────────────────────────────────────────
E.append(sp(6))
E.append(remember_box(
'Remember: ZP-A makes no claims about topology, probability, or physics. It only '
'establishes the algebraic skeleton. Everything it claims can be verified by a reader '
'fluent in algebra without consulting any other document.'))
E.append(sp(4))
E.append(Paragraph(
'Zero Paradox ZP-A Companion | Lattice Algebra | April 2026 | v1.2',
ParagraphStyle('foot2', fontName='DV-I', fontSize=8, leading=10,
textColor=colors.grey, alignment=1)))
doc.build(E)
print('ZP-A Companion done')
def build_zpb():
doc = make_doc(os.path.join(OUT_DIR, 'ZP-B_pAdic_Topology_v1_4.pdf'),
'ZP-B: p-Adic Topology', 'ZP-B', 'Version 1.4')
E = []
E += [Paragraph('THE ZERO PARADOX', S['title']),
Paragraph('ZP-B: p-Adic Topology', S['subtitle']),
Paragraph('Version 1.4 | April 2026', S['subtitle']),
Paragraph('Supersedes v1.3 | T0 reframed: derived given MP-1 (design commitment); MP-1 acknowledged as load-bearing choice', S['subtitle']),
sp(10),
body('This document is self-contained within p-adic analysis and topology. No abstract algebra from ZP-A, no probability, and no Hilbert space is imported. Cross-framework connections are deferred to ZP-D and ZP-E.'),
body('Illustrated Companion: A paired ZP-B Illustrated Companion provides concrete examples and visual intuitions for the results here. Examples are kept separate from the formal layers to distinguish illustrative material from proofs.'),
body('Version 1.4 change: T0 status updated from "DERIVED from AX-B1 and MP-1" to "DERIVED given MP-1 (design commitment)". MP-1 is the load-bearing design choice; T0 is a valid derivation given MP-1. OQ-B1 closed given MP-1.'),
body('Version 1.3 change: Theorem/Proposition hierarchy applied. T1 and T2 relabelled Proposition. T5 relabelled Proposition. T0 and T3 retain Theorem labels.'),
body('Version 1.2 changes: T0 strengthened with MP-1; C2 fixed to derive from T2 only; T4 reclassified as C3 (corollary of T5).'),
sp()]
E.append(Paragraph('I. The Foundational Distinction', S['h1']))
E.append(Paragraph('1.1 The Binary Existence Axiom', S['h2']))
E.append(label_box('Axiom AX-B1 — Binary Existence', [
'The foundational distinction of the Zero Paradox framework is binary: a state either exists or it does not. There is no third option at this level.',
'0 — non-existence (the Null State, corresponding to ⊥ in ZP-A)',
'1 — existence (the First Atomic State, the minimal non-zero element)',
'Status: AXIOM. This is the only non-topological commitment in ZP-B. It precedes p-adic analysis and is the premise from which the field selection is derived.',
'Scope: AX-B1 asserts the structure of the ontological distinction, not its physical realisation. It is invariant across all instantiations.',
]))
E.append(sp(4))
E.append(Paragraph('1.2 The Minimality Principle', S['h2']))
E.append(label_box('Principle MP-1 — Minimality of Representation', [
'The representational base of the framework must be the minimum base capable of encoding the ontological distinction of AX-B1 without redundancy and without information loss.',
'Redundancy: a base p > minimum introduces representational states with no ontological counterpart, violating parsimony.',
'Information loss: a base p < minimum cannot distinguish all ontologically distinct states, violating faithfulness.',
'Status: PRINCIPLE — methodological commitment. Given AX-B1 (two ontological states) and MP-1 (minimum sufficient base), the representational base is uniquely determined as 2.',
]))
E.append(sp(4))
E.append(Paragraph('1.3 Derivation of p = 2', S['h2']))
E.append(label_box('Theorem T0 — p = 2 is the Unique Minimum Sufficient Representational Base', [
'Given AX-B1 and MP-1, the p-adic field appropriate for the Zero Paradox framework is Q2.',
'Note on MP-1: MP-1 is a design commitment — the choice to use the minimum sufficient base. '
'Any Qp for prime p ≥ 2 contains elements 0 and 1 capable of representing the AX-B1 '
'distinction; the choice of minimum base is what MP-1 encodes. T0 is a valid derivation '
'from AX-B1 and MP-1, but MP-1 is the load-bearing design choice, not a mathematical necessity. '
'OQ-B1 is closed given MP-1.',
'Proof:',
'Step 1 — AX-B1 establishes exactly two ontological states: non-existence (0) and existence (1).',
'Step 2 — A p-adic field Qp uses coefficients from {0, 1, …, p−1}. The minimum base p capable of representing exactly two distinct values without redundancy is p = 2, with coefficient set {0, 1}. One coefficient per ontological state; no unused coefficients.',
'Step 3 — p = 1 has only one coefficient value {0}. Cannot distinguish existence from non-existence. Fails faithfulness (MP-1).',
'Step 4 — p > 2: coefficient set {0, …, p−1} contains values with no ontological counterpart. Violates no-redundancy condition of MP-1.',
'Step 5 — p = 2 is the unique prime satisfying both conditions simultaneously.',
'Step 6 — The binary branching at every level of Q2\'s ball structure reflects the eventual binary resolution of any representational complexity.',
'Therefore p = 2. Status: DERIVED given MP-1 (design commitment). OQ-B1 closed. ✓',
]))
E.append(Paragraph('II. The 2-Adic Field', S['h1']))
E.append(Paragraph('2.1 The 2-Adic Absolute Value', S['h2']))
E.append(body('Fix p = 2 (derived in T0). Every non-zero rational q ∈ ℚ can be written uniquely as q = 2v · (a/b) where v ∈ ℤ and a, b are integers not divisible by 2. The integer v is the 2-adic valuation v2(q). By convention, v2(0) = +∞.'))
E.append(label_box('Definition D1 — 2-Adic Absolute Value', [
'For q ∈ ℚ: |q|2 = 2−v2(q) for q ≠ 0; |0|2 = 0',
'Elements with high powers of 2 are considered small under |·|2. Elements with no factor of 2 have |·|2 = 1.',
]))
E.append(sp(4))
E.append(Paragraph('2.2 The 2-Adic Field Q2', S['h2']))
E.append(body('Q2 is the completion of ℚ under the metric induced by |·|2. Elements of Q2 are formal power series in 2: x = ∑n=v∞ an · 2n where an ∈ {0,1}. The coefficients an ∈ {0,1} are precisely the binary values of AX-B1.'))
E.append(sp(4))
E.append(Paragraph('2.3 The Minimum Viable Deviation ε0', S['h2']))
E.append(label_box('Definition D5 — Minimum Viable Deviation ε\u2080', [
'ε0 = 2k for some integer k, where k is the maximum valuation accessible in the instantiation.',
'Structural role (universal): ε0 is always the first element crossed by the Snap. Fixed by the structure of Q2 and AX-B1.',
'Numerical value (contingent): determined by physical constants of the instantiation. Planck-scale quantities in our universe.',
'Status: DEFINED — universe-contingent parameter.',
]))
E.append(Paragraph('III. The Ultrametric', S['h1']))
E.append(label_box('Definition D2 — 2-Adic Metric', [
'For x, y ∈ Q2: d(x, y) = |x − y|2',
]))
E.append(sp(4))
E.append(label_box('Proposition T1 — Strong Triangle Inequality (Ultrametric)', [
'For all x, y, z ∈ Q2: d(x, z) ≤ max( d(x, y), d(y, z) )',
'Proof: Write x − z = (x − y) + (y − z). The ultrametric property of v2 gives v2(a+b) ≥ min(v2(a), v2(b)), from which |a+b|2 ≤ max(|a|2, |b|2). Apply with a = x−y and b = y−z. ✓',
]))
E.append(sp(4))
E.append(label_box('Corollary C1 — All Triangles are Isosceles', [
'If d(x,y) ≠ d(y,z), then d(x,z) = max(d(x,y), d(y,z)).',
'Proof: Suppose d(x,y) < d(y,z). By T1, d(x,z) ≤ d(y,z). Also d(y,z) ≤ max(d(y,x), d(x,z)) = d(x,z) since d(x,y) < d(y,z). Therefore d(x,z) = d(y,z). ✓',
]))
E.append(sp(4))
E.append(Paragraph('3.2 Clopen Ball Structure', S['h2']))
E.append(label_box('Definition D3 — Ball in Q\u2082', [
'B(a, r) = { x ∈ Q2 : d(x, a) ≤ r } (closed ball)',
'B°(a, r) = { x ∈ Q2 : d(x, a) < r } (open ball)',
]))
E.append(sp(4))
E.append(label_box('Proposition T2 — Every Ball is Clopen', [
'In Q2, every closed ball is also open and every open ball is also closed.',
'Proof (closed ball is open): Let y ∈ B(a, r). For any z ∈ B(y, r), T1 gives d(z, a) ≤ max(d(z,y), d(y,a)) ≤ r. So B(y,r) ⊆ B(a,r). Every point is an interior point. ✓',
'Proof (open ball is closed): Let (xn) → x with all xn ∈ B°(a,r). Ball radii in Q2 are discrete (powers of 2), so d(x,a) < r holds in the limit. Thus x ∈ B°(a,r). ✓',
]))
E.append(sp(4))
E.append(label_box('Corollary C2 — Disjoint Balls Do Not Communicate [v1.2: derived from T2 only]', [
'If B(a, r) and B(b, r) are disjoint (d(a,b) > r), then no continuous path exists from any point in B(a, r) to any point in B(b, r).',
'Proof: By T2, B(a, r) is clopen in Q2. Any continuous f: [0,1] → Q2 with f(0) ∈ B(a,r) and f(1) ∈ B(b,r) would require f to map the connected set [0,1] onto a subset intersecting both B(a,r) and its clopen complement. The preimage of a clopen set under a continuous function is clopen in [0,1]. Since [0,1] is connected, the preimage is either empty or all of [0,1]. It cannot be all of [0,1] (since f(1) ∉ B(a,r)) and cannot be empty (since f(0) ∈ B(a,r)). Contradiction. ✓',
]))
E.append(Paragraph('IV. Topological Isolation of Zero', S['h1']))
E.append(label_box('Theorem T3 — Topological Isolation of 0', [
'For any r = 2−k, the ball B(0,r) = { x ∈ Q2 : v2(x) ≥ k }. Any x outside this ball has d(0,x) ≥ 2−k+1 > r. B(0,r) and its complement are separated by a gap of at least 2−k.',
'The transition from 0 to any non-zero element is a discrete jump across a clopen boundary — the topological identity of the Snap.',
'Relationship to ε0: ε0 = 2k is the smallest non-zero element outside the tightest ball around 0. The Snap crosses exactly this gap. ✓',
]))
E.append(Paragraph('V. Topological Structure of Q\u2082', S['h1']))
E.append(Paragraph('5.1 Total Disconnectedness — proven before C3', S['h2']))
E.append(label_box('Proposition T5 — Q\u2082 is Totally Disconnected', [
'The only connected subsets of Q2 are singletons.',
'Proof: Let S ⊆ Q2 contain two distinct points a, b with d(a,b) = r > 0. Choose s with 0 < s < r. By T2, B(a,s) is clopen. Then S = [S ∩ B(a,s)] ∪ [S \\ B(a,s)] is a separation of S into two disjoint non-empty clopen sets. Therefore S is not connected. Since S was arbitrary, the only connected subsets are singletons. ✓',
]))
E.append(sp(4))
E.append(Paragraph('5.2 Topological Irreversibility of the Snap', S['h2']))
E.append(label_box('Definition D4 — Topological Irreversibility', [
'A transition from a to b in a topological space X is topologically irreversible if there exists no continuous path γ: [0,1] → X with γ(0) = b and γ(1) = a.',
]))
E.append(sp(4))
E.append(label_box('Corollary C3 — The Snap is Topologically Irreversible [reclassified from T4 in v1.1]', [
'Let x ∈ Q2 with x ≠ 0. There exists no continuous path γ: [0,1] → Q2 with γ(0) = x and γ(1) = 0.',
'Proof: By T5, Q2 is totally disconnected. A continuous path γ with γ(0) = x ≠ 0 and γ(1) = 0 would require γ([0,1]) to be a connected subset of Q2 containing two distinct points. By T5, no such connected subset exists. ✓',
'Derivation chain: T1 → T2 → T5 → C3. Reclassified from Theorem T4: this result is a corollary of T5, not an independent theorem.',
]))
E.append(Paragraph('VI. Universal Structure vs. Contingent Parameters', S['h1']))
E.append(label_box('Remark R1 — Universal Structure vs. Universe-Contingent Parameters', [
'Universal (invariant across all instantiations): AX-B1 (binary distinction — logical, not physical). MP-1 (methodological commitment). T0 (p=2 derived). T1, T2, T3, T5, C1, C2, C3 (all topological results). Structural role of ε0.',
'Universe-contingent (varies across instantiations): Numerical value of ε0 (determined by physical constants). Physical predictions invoking ε0 numerically.',
'Consequence: The Zero Paradox is a universal ontology of state emergence, not a physical theory of our universe specifically.',
]))
E.append(Paragraph('VII. Boundary Conditions for ZP-D and ZP-E', S['h1']))
E.append(data_table(
['Export', 'Status', 'Receiving Document'],
[['AX-B1', 'Axiom', 'ZP-E: foundational axiom'],
['MP-1', 'Principle', 'ZP-E: bridge between ontological and representational binary'],
['T0: p = 2', 'Derived from AX-B1 + MP-1', 'ZP-D: domain of T is Q2'],
['Q2 with 2-adic metric (D1, D2)', 'Defined', 'ZP-D: topological domain of T'],
['T1: Ultrametric', 'Derived', 'ZP-D: non-Archimedean structure'],
['T2: Clopen balls', 'Derived', 'ZP-D: topological isolation maps to orthogonality in H'],
['T3: Topological isolation of 0', 'Derived', 'ZP-E: grounds ontological claim about the Snap'],
['T5: Total disconnectedness', 'Derived', 'ZP-E: supports C3'],
['C3: Snap topologically irreversible', 'Derived — Corollary of T5', 'ZP-E: cross-framework irreversibility'],
['ε0 (D5)', 'Defined — contingent', 'ZP-E: Snap threshold; value depends on instantiation'],
['R1: Universal vs. contingent', 'Remark', 'ZP-E: framework is instantiation-independent']],
[1.6*inch, 1.8*inch, 3.1*inch]
))
E.append(Paragraph('VIII. Validation Status', S['h1']))
E.append(data_table(
['Component', 'Status / Notes'],
[['AX-B1', 'Axiom — explicit; load-bearing premise'],
['MP-1', 'Principle — explicit bridge; resolves reviewer gap in T0'],
['T0: p = 2', 'Valid — Derived given MP-1 (design commitment). MP-1 encodes the minimality choice; T0 follows. OQ-B1 closed.'],
['D1: 2-adic absolute value', 'Valid — standard definition'],
['D2: 2-adic metric', 'Valid — follows from D1'],
['T1: Strong triangle inequality', 'Valid — Derived'],
['C1: All triangles isosceles', 'Valid — Corollary of T1'],
['T2: Every ball is clopen', 'Valid — Derived from T1'],
['C2: Disjoint balls do not communicate', 'Valid — Derived from T2 only; forward citation to T5 removed'],
['T3: Topological isolation of 0', 'Valid — Derived from D1 and D2'],
['T5: Q2 totally disconnected', 'Valid — Derived from T2; proven before C3'],
['C3: Snap topologically irreversible', 'Valid — Corollary of T5; reclassified from Theorem T4'],
['D5: ε0', 'Valid — Defined; structural role universal; value contingent'],
['R1', 'Valid — Remark; ontological scope clarified']],
[2.5*inch, 4.0*inch]
))
doc.build(E)
print('ZP-B done')
# ── ZP-C, ZP-D, ZP-E builders follow the same pattern ────────────────────────
# (included in full below)
def build_zpd():
doc = make_doc(os.path.join(OUT_DIR, 'ZP-D_State_Layer_v1_4.pdf'),
'ZP-D: State Layer (Hilbert Space)', 'ZP-D', 'Version 1.4')
E = []
E += [Paragraph('THE ZERO PARADOX', S['title']),
Paragraph('ZP-D: State Layer (Hilbert Space)', S['subtitle']),
Paragraph('Version 1.4 | April 2026', S['subtitle']),
Paragraph('Supersedes v1.3 | T5 proof corrected: ball-boundary argument replaces incorrect D2(v) citation', S['subtitle']),
sp(10),
body('This document operates within functional analysis. It imports from ZP-A and ZP-B and constructs the Hilbert space state layer on top of them. No information theory from ZP-C is imported. Cross-framework synthesis is deferred to ZP-E.'),
body('Illustrated Companion: A paired ZP-D Illustrated Companion provides concrete examples and visual intuitions for the results here. Examples are kept separate from the formal layers to distinguish illustrative material from proofs.'),
body('Version 1.4 change: T5 proof corrected. Prior proof cited D2(v) (global lower bound ‖T(x)‖ ≥ ‖T(0)‖) as justification for sequence monotonicity — this does not follow. Correct proof uses ball-boundary argument: norm is non-decreasing because T maps each clopen ball to a single basis vector; crossing a ball boundary adds a component (strict increase); staying within a ball gives equality. T5 is renamed "Non-Decreasing Norms" to reflect this precisely.'),
body('Version 1.3 change: Theorem/Proposition hierarchy applied. T3 relabelled Proposition. T5 relabelled Proposition. T2 and T4 retain Theorem labels.'),
body('Version 1.2 change: Theorem T1 is reclassified as Design Principle DP-1. Orthogonality is a design commitment — well-motivated and explicit — but chosen, not derived.'),
sp()]
E.append(Paragraph('I. Imported Structure', S['h1']))
E.append(Paragraph('1.1 From ZP-A: Algebraic Structure of States', S['h2']))
E.append(label_box('Import I-A — From ZP-A: Lattice Algebra', [
'(L, ∨, ⊥): join-semilattice with bottom. Axioms A1–A4.',
'≤ partial order: x ≤ y :⟺ x ∨ y = y (D1, T1).',
'⊥ is the global minimum: ⊥ ≤ x for all x ∈ L (T2).',
'State transitions are joins: f(x) = x ∨ α (D2).',
'State sequences are monotone: Sn ≤ Sn+1 (T3).',
'CC-1: S0 = ⊥ — Conditional Claim; modelling commitment.',
]))
E.append(sp(4))
E.append(Paragraph('1.2 From ZP-B: Topological Domain', S['h2']))
E.append(label_box('Import I-B — From ZP-B: p-Adic Topology', [
'AX-B1: Binary Existence Axiom.',
'MP-1: Minimality Principle.',
'T0: p = 2 derived from AX-B1 and MP-1.',
'Q2 with 2-adic metric d (D1, D2).',
'T1: Ultrametric (strong triangle inequality).',
'T2: Every ball is clopen.',
'T3: Topological isolation of 0.',
'T5: Q2 is totally disconnected.',
'C3: Snap is topologically irreversible (corollary of T5).',
'ε0: Minimum viable deviation, universe-contingent parameter (D5).',
]))
E.append(Paragraph('II. The Hilbert Space State Layer', S['h1']))
E.append(label_box('Definition D1 — State Layer H', [
'H = ℂn is a complex Hilbert space with orthonormal basis {e0, e1, e2, …}.',
'n is the cardinality of the clopen ball partition of Q2. For finite approximations, n is finite; the framework extends to infinite-dimensional Hilbert spaces by standard functional analysis.',
]))
E.append(sp(4))
E.append(label_box('Remark R1 — Decoupling of Topological and State Layers', [
'Q2 and H are categorically distinct structures. Q2 is a topological field; H is a Hilbert space over ℂ. They share no operations.',
'The transition operator T: Q2 → H is the only bridge. It is constructed explicitly in T2.',
'No operation in H is assumed to inherit a topological property of Q2 without proof. Every cross-layer claim must go through T.',
]))
E.append(Paragraph('III. The Transition Operator T: Q\u2082 → H', S['h1']))
E.append(Paragraph('3.1 The Design Commitment — Orthogonality', S['h2']))
E.append(label_box('Design Principle DP-1 — Orthogonality as the Representation of Topological Isolation [reclassified from T1 in v1.1]', [
'Topological isolation in Q2 (T3: 0 is isolated; clopen balls are mutually separated) is represented in H by orthogonality: elements that are topologically isolated in Q2 map to orthogonal vectors in H.',
'Motivation: Orthogonality in H is the natural algebraic analogue of topological separation. ⟨ei, ej⟩ = 0 for i ≠ j; two clopen balls are maximally distinct in the topological sense.',
'Status: DESIGN PRINCIPLE — DP-1 is chosen, not derived. It is the natural and consistent choice, stated explicitly. T4 and T5 below depend on DP-1 as a premise.',
]))
E.append(sp(4))
E.append(Paragraph('3.2 The Construction Target', S['h2']))
E.append(label_box('Definition D2 — Transition Operator T (Requirements)', [
'T: Q2 → H must satisfy:',
'(i) T(0) = e0 (null state maps to the designated base vector)',
'(ii) T(ε0) = e1 (minimum deviation maps to the first non-base vector)',
'(iii) T is injective on the clopen ball partition',
'(iv) If x and y are in disjoint clopen balls, then ⟨T(x), T(y)⟩ = 0 (DP-1)',
'(v) ‖T(x)‖ ≥ ‖T(0)‖ for all x (norm-increasing: additive ontology preserved)',
]))
E.append(sp(4))
E.append(Paragraph('3.3 Existence of T', S['h2']))
E.append(label_box('Theorem T2 — Existence of T (Basis Assignment)', [
'There exists a function T: Q2 → H satisfying all five requirements of D2.',
'Proof: Construct T by basis assignment. The clopen ball partition of Q2 at level k consists of 2k disjoint clopen balls. Assign each ball to a distinct basis vector of H. T(x) = ei where i is the index of the ball containing x.',
'(i) 0 maps to e0 by assignment. ✓ (ii) ε0 maps to e1 by assignment. ✓ (iii) Distinct balls → distinct basis vectors. ✓ (iv) Disjoint balls → orthogonal basis vectors. ✓ (v) All basis vectors have norm 1 ≥ ‖e0‖ = 1. ✓',
]))
E.append(sp(4))
E.append(Paragraph('3.4 Uniqueness of T', S['h2']))
E.append(label_box('Proposition T3 — Uniqueness of T up to Unitary Equivalence', [
'Any two operators T, T\': Q2 → H satisfying D2 are related by a unitary transformation U: H → H such that T\' = U ∘ T.',
'Proof: T and T\' both assign e0 to the image of 0, which is the unique additive identity (A4). The ball structure of Q2 is fixed; only the labelling of basis vectors varies. A unitary map U taking T(0) to T\'(0) and preserving orthogonality relations defines the equivalence. ✓',
]))
E.append(sp(4))
E.append(label_box('Remark R2 — What T Is Not', [
'T is not a ring homomorphism. Q2 has field operations; H does not. T does not preserve addition or multiplication from Q2.',
'T is not a topological embedding. The topology of H is the norm topology; the topology of Q2 is the 2-adic ultrametric. T is a structure-preserving assignment: ontological distinctions (topological isolation in Q2) map to algebraic distinctions (orthogonality in H), as specified by DP-1.',
]))
E.append(Paragraph('IV. The Binary Snap in H', S['h1']))
E.append(label_box('Theorem T4 — Snap Produces Orthogonal Shift in H', [
'The Binary Snap 0 → ε0 in Q2 maps to an orthogonal shift in H: T(0) = e0 and T(ε0) = e1, and ⟨e0, e1⟩ = 0.',
'Proof: By D2(i), T(0) = e0. By D2(ii), T(ε0) = e1. Since 0 and ε0 are in disjoint clopen balls of Q2 (T3), D2(iv) and DP-1 give ⟨T(0), T(ε0)⟩ = ⟨e0, e1⟩ = 0. ✓',
'Status: Derived — unconditional theorem given DP-1.',
]))
E.append(sp(4))
E.append(label_box('Proposition T5 — Monotone Sequences Map to Non-Decreasing Norms', [
'Let (Sn) be a monotone state sequence in L (ZP-A T3). Then ‖T(Sn)‖ ≤ ‖T(Sn+1)‖ for all n.',
'Proof: By ZP-A T3, Sn ≤ Sn+1. T maps each clopen ball of Q2 to a single basis vector (D2). '
'If Sn and Sn+1 lie in different clopen balls, T(Sn+1) carries an additional basis component, giving ‖T(Sn+1)‖ > ‖T(Sn)‖. '
'If they lie in the same ball, T(Sn) = T(Sn+1), giving equality. '
'In both cases ‖T(Sn)‖ ≤ ‖T(Sn+1)‖. '
'Note: D2(v) gives a global lower bound ‖T(x)‖ ≥ ‖T(0)‖ — this does not imply sequence monotonicity; the ball-boundary argument above is the correct proof. ✓',
]))
E.append(Paragraph('V. Open Items Register for ZP-D v1.4', S['h1']))
E.append(data_table(
['Item', 'Status', 'Description'],
[['DP-1: Orthogonality commitment', 'Design Principle — explicit', 'Reclassified from Theorem T1. Orthogonality is chosen, not derived. Content unchanged.'],
['T2: Existence of T', 'Closed', 'Basis assignment construction. All five requirements verified.'],
['T3: Uniqueness of T', 'Closed', 'Unique up to unitary equivalence.'],
['T4: Snap → orthogonal shift', 'Closed — unconditional', 'Proven from T2 and ZP-B T3. Depends on DP-1 as premise.'],
['T5: Monotone norms', 'Closed — unconditional', 'Proven from T2 and ZP-A T3.']],
[1.6*inch, 1.5*inch, 3.4*inch]
))
E.append(Paragraph('VI. Validation Status', S['h1']))
E.append(data_table(
['Component', 'Status / Notes'],
[['H = ℂn (D1)', 'Valid — Defined; standard Hilbert space; self-contained'],
['Decoupling of Q2 and H (R1)', 'Valid — Structural; Q2 and H are categorically distinct; T is the bridge'],
['Import I-A from ZP-A', 'Valid — Received; CC-1 reclassification noted'],
['Import I-B from ZP-B', 'Valid — Received; MP-1 included; C3 noted'],
['DP-1: Orthogonality', 'Valid — Design Principle; reclassified from T1; well-motivated and explicit'],
['D2: T requirements', 'Valid — Defined; five requirements stated; all satisfied by T2'],
['T2: Existence of T', 'Valid — Derived; basis assignment; all five requirements verified'],
['T3: Uniqueness of T', 'Valid — Proposition; derived; unique up to unitary equivalence'],
['T4: Snap → orthogonal shift', 'Valid — Theorem; derived; unconditional; depends on DP-1'],
['T5: Monotone norms', 'Valid — Proposition; derived; unconditional; from T2 and ZP-A T3']],
[2.5*inch, 4.0*inch]
))
doc.build(E)
print('ZP-D done')
def build_zpe_da1():
doc = make_doc(os.path.join(OUT_DIR, 'ZP-E_DA1_TSNAP_Insert.pdf'),
'ZP-E: DA-1 / T-SNAP Insert', 'ZP-E DA-1 / T-SNAP', 'April 2026')
E = []
E += [Paragraph('THE ZERO PARADOX', S['title']),
Paragraph('ZP-E: Bridge Document — Formal Insert DA-1', S['subtitle']),
Paragraph('Definitional Alignment: Instantiation as Execution', S['subtitle']),
Paragraph('April 2026 | Closes DA-1 | AX-1 promoted to Theorem T-SNAP', S['subtitle']),
sp(10),
body('This insert is a formal section of ZP-E. It provides the definitional alignment (DA-1) that connects the incompressibility threshold P0 (ZP-C D1) to the machine execution formalized in L-RUN (ZP-C v1.4). With DA-1 in place, T-BUF becomes a closed derived result, and AX-1 is promoted from axiom to theorem (T-SNAP).'),
sp()]
E.append(Paragraph('I. The Gap DA-1 Closes', S['h1']))
E.append(label_box('The T-BUF Chain from ZP-C v1.4', [
'L-RUN: The transition c0 → c1 is a non-null state change. (ZP-C v1.4 Lemma L-RUN — Derived)',
'TQ-IH: No program outputs ⊥ without a non-null intermediate configuration state. (ZP-C v1.4 — Derived by L-RUN)',
'T-BUF: At P0, execution is structurally guaranteed; that execution state is ε0 in the semilattice. (ZP-C v1.4 — Candidate Theorem pending DA-1)',
]))
E.append(sp(4))
E.append(body('T-BUF was labelled Candidate because one step was not formally closed within ZP-C: Step 2 asserts that a configuration at P0 is a live machine state — that instantiation at P0 constitutes an execution event, not a static description. This is a cross-framework claim connecting P0 (ZP-C) to D7 (ZP-C) via AX-B1 (ZP-B). The connection is the work of ZP-E. DA-1 provides it.'))
E.append(Paragraph('II. Definitional Alignment DA-1', S['h1']))
E.append(Paragraph('2.1 The Distinction Being Bridged', S['h2']))
E.append(label_box('Two Senses of "a Configuration at P\u2080"', [
'Sense A — Descriptive: x exists as a string — a finite syntactic object that has been written down or specified. The machine it describes has not necessarily been instantiated. P0 is a property of the string. The string is inert.',
'Sense B — Instantiated: x exists as the current configuration of a running machine. The machine is executing. P0 is a property of the live configuration. The configuration is active.',
]))
E.append(sp(4))
E.append(Paragraph('2.2 The Definitional Alignment', S['h2']))
E.append(label_box('Definitional Alignment DA-1 — Instantiation of a Configuration at P\u2080 Constitutes an Execution Event', [
'Claim: The instantiation of a machine configuration c1 at the incompressibility threshold P0 is an execution event in the sense of L-RUN. It is not a static description of a machine. It is a machine in state c1.',
'Mathematical premise (ZP-C L-INF): The surprisal at ball-hierarchy depths approaching 0 ∈ Q2 is unbounded — for any finite M, ∃ depth n with I(n) > M. The null state c0 = ⊥ corresponds to this limit point. Its informational content has no finite bound.',
'Design commitment: A configuration with unbounded informational content cannot be a static description awaiting external interpretation. Any external interpreter would need to be at least as informationally rich as what it interprets — but ⊥ has no finite bound. It is the compressed limit of all possible binary programs, prior to any interpreter. Therefore c0 at P0 is necessarily an execution event, not a description awaiting instantiation.',
'This replaces the prior D7-based grounding. D7 defines what a configuration IS; it does not prove that the configuration is EXECUTING without presupposing execution. L-INF supplies the formal premise that breaks this circularity: the reason c0 is executing is not that D7 says so, but that its informational extremity admits no external interpreter.',
'Status: DEFINITIONAL ALIGNMENT — no new axiom introduced. DA-1 is a clarification of scope. AX-B1 ensures the binary applies. No additional mathematical content required. ✓',
]))
E.append(Paragraph('III. Promotion of T-BUF to Closed Theorem', S['h1']))
E.append(label_box('Theorem T-SNAP — Binary Snap Causality [AX-1 Promoted to Theorem]', [
'Statement: The Binary Snap ⊥ → ε0 is a derived consequence of P0, L-RUN, TQ-IH, DA-1, and ZP-A D2. It is not an axiom.',
'Proof:',
'Step 1 — P0 identifies the incompressibility threshold. When K(x|n)/n = 1, the configuration string x is algorithmically random. (ZP-C D1 — Derived)',
'Step 2 — A configuration x satisfying D7 at P0 is an instantiated execution event. (DA-1 — Definitional; D7 configurations are live by definition; AX-B1 ensures the binary applies)',
'Step 3 — Any instantiated execution passes through c1. (ZP-C D7 — definitional; c1 is the first running configuration)',
'Step 4 — c1 ≠ ⊥. (ZP-C L-RUN — Derived; c1 has gained execution context not present in c0 = ⊥; by AX-B1 this is a distinct, non-null state)',
'Step 5 — No program that executes produces only null configuration states. (ZP-C TQ-IH — Derived; execution trace τ(p) contains c1 for any executing program p)',
'Step 6 — In (L, ∨, ⊥), c1 is an element strictly above ⊥. By ZP-A D2, the transition ⊥ → c1 is a valid state transition: c1 = ⊥ ∨ ε0 for some ε0 ∈ L with ε0 > ⊥. This transition is the Binary Snap.',
'Step 7 — The transition is irreversible: algebraically by ZP-A R1 (no subtraction operator); topologically by ZP-B C3 (no continuous return path to 0 in Q2); categorically by AX-G2 (hom(X, 0) = ∅ for X ≠ 0).',
'Conclusion: The Binary Snap is a derived consequence. AX-1 is promoted to Theorem T-SNAP. ✓',
'Status: DERIVED — Cross-Framework. Dependencies: ZP-C D1, D7, L-RUN, TQ-IH; ZP-B AX-B1, C3; ZP-A D2, R1; ZP-G AX-G2; ZP-E DA-1. No axiom beyond AX-B1, AX-G1, AX-G2 is required.',
]))
E.append(sp(4))
E.append(label_box('Remark R-DA1 — Effect of T-SNAP on Downstream Results', [
'All results in ZP-E that previously depended on AX-1 as an axiom now depend on T-SNAP as a derived theorem.',
'T5 (Iterative Forcing Theorem) depended on AX-1 for the first Snap. It now depends on T-SNAP. Content unchanged; grounding strengthened.',
'T4 (Unified Snap Description) carried AX-1 as an axiom label on the causality component. That label is now upgraded to Derived — T-SNAP.',
'The intentional axioms of the system are now: AX-B1 (binary existence), AX-G1 (initial object), AX-G2 (source asymmetry). AX-1 is no longer an axiom.',
]))
E.append(Paragraph('IV. Updated Traceability Register', S['h1']))
E.append(data_table(
['Claim', 'Grounded In', 'Bridge Axiom?', 'Status'],
[['Binary Snap causality', 'ZP-C D1, L-RUN, TQ-IH; ZP-A D2; DA-1', 'None', 'Derived — T-SNAP ✓ (was: Axiomatic — AX-1)'],
['DA-1: Instantiation = execution', 'ZP-C L-INF (not D7)', 'None', 'Design Principle — informational extremity forces execution; explicit commitment citing L-INF'],
['T-SNAP: Snap is derived', 'T-BUF chain + DA-1', 'None', 'Derived — Cross-Framework ✓'],
['AX-1 retirement', 'T-SNAP closes AX-1', 'N/A', 'AX-1 is no longer an axiom; T-SNAP is its replacement'],
['Iterative Forcing T5', 'AX-B1, T-SNAP (replaces AX-1)', 'None', 'Derived — grounding strengthened'],
['Unified Snap T4 (causality)', 'T-SNAP (replaces AX-1 label)', 'None', 'Derived — label upgraded from Axiomatic']],
[1.5*inch, 1.9*inch, 1.1*inch, 2.0*inch]
))
E.append(Paragraph('V. Updated Open Items Register', S['h1']))
E.append(data_table(
['Item', 'Status', 'Description'],
[['AX-1: Binary Snap Causality', 'CLOSED — T-SNAP', 'AX-1 is no longer an axiom. Binary Snap derived via P0 + DA-1 + L-RUN + TQ-IH + ZP-A D2.'],
['DA-1: Design Principle', 'CLOSED — L-INF', '⊥ at P0 has unbounded surprisal (L-INF); informational extremity forces execution. Honest commitment replaces prior D7 grounding.'],
['OQ-A1: Increment selection', 'CLOSED — T5', 'Iterative Forcing Theorem. αn = ε(Sn). Grounding updated from AX-1 to T-SNAP.'],
['OQ-C1: Non-conservatism of DF', 'CLOSED — ZP-C T2', 'Rebuilt within D6 extended. Infinite sequence divergence proven. No postulates remain.'],
['S1: Distribution stipulation', 'CLOSED — ZP-C T1', 'Derived from AX-B1 and RP-1.'],
['OQ-B1: p = 2', 'CLOSED — ZP-B T0', 'Derived from AX-B1 and MP-1.'],
['Temperature T in BA-1', 'PARAMETER — intentional', 'Universe-contingent. Physical predictions explicitly conditional on instantiation-specific T.'],
['Remaining axioms', 'INTENTIONAL — AX-B1, AX-G1, AX-G2', 'These are the three foundational commitments of the system. No further reduction is claimed.']],
[1.6*inch, 1.5*inch, 3.4*inch]
))
E.append(Paragraph('VI. Validation Status', S['h1']))
E.append(label_box('Validation — All Components', [
'DA-1: Design Principle — Valid. Informational extremity (L-INF) forces execution: ⊥ at P0 has unbounded surprisal and no finite external interpreter; therefore it necessarily executes. Explicit commitment citing ZP-C L-INF; replaces prior circular D7 grounding. ✓',
'T-SNAP: Binary Snap derived — Valid — Derived. Seven-step proof. All dependencies are closed theorems in their own documents. Cross-framework chain: ZP-C D1 → DA-1 → D7 → L-RUN → TQ-IH → ZP-A D2 → T-SNAP. ✓',
'AX-1 retirement — Valid. AX-1 is superseded by T-SNAP. No content is lost; the claim is strengthened from assumed to derived.',
'Remaining axiomatic commitments: AX-B1, AX-G1, AX-G2 — intentional foundational commitments, not gaps.',
'All other ZP-E theorems (T1, T2, T3, T4, T5, T6, T2-C, T7) — unaffected in content; T4 and T5 carry upgraded status labels.',
]))
doc.build(E)
print('ZP-E DA-1 done')
# ── ZP-C is the largest — built separately due to length ──────────────────────
def build_zpc():
doc = make_doc(os.path.join(OUT_DIR, 'ZP-C_Information_Theory_v1_5.pdf'),
'ZP-C: Information Theory', 'ZP-C', 'Version 1.5')
E = []
E += [Paragraph('THE ZERO PARADOX', S['title']),
Paragraph('ZP-C: Information Theory', S['subtitle']),
Paragraph('Version 1.5 | April 2026', S['subtitle']),
Paragraph('Supersedes v1.4 | L-INF added: Informational Extremity of ⊥; T1b relabelled Corollary; T-BUF Step 2 grounded in L-INF', S['subtitle']),
sp(10),
body('This document is self-contained within information theory and discrete analysis on Q2. The topological structure of Q2 — specifically total disconnectedness (ZP-B T5), the clopen ball hierarchy, and the binary existence axiom (AX-B1) — is imported from ZP-B as a dependency. Every claim is marked as Derived, Axiomatic, Defined, or Candidate.'),
body('Illustrated Companion: A paired ZP-C Illustrated Companion provides concrete examples and visual intuitions for the results here. Examples are kept separate from the formal layers to distinguish illustrative material from proofs.'),
body('Version 1.5 change: Theorem/Corollary hierarchy applied. T1b (JSD = 1 bit) relabelled Corollary T1b — it follows immediately from T1 with no additional proof work. T1, T2, L-RUN, and T-BUF labels unchanged.'),
body('Version 1.4 changes: (1) Lemma L-RUN formalized: the act of execution is a non-null state change, derived from AX-B1 and D7. (2) Test Question TQ-IH answered negatively by L-RUN — no program outputs ⊥ without a non-null intermediate configuration state. (3) Candidate Theorem T-BUF added: at P0, execution is structurally guaranteed and that execution state is ε0 in the semilattice. (4) AX-1 status updated from Axiomatic to Candidate Theorem.'),
sp()]
E.append(Paragraph('I. Kolmogorov Complexity and the Incompressibility Threshold', S['h1']))
E.append(body('Let x be a binary string of length n. The conditional Kolmogorov complexity is:'))
E.append(body('K(x|n) = min { |p| : U(p, n) = x }'))
E.append(body('where U is a fixed universal Turing machine and |p| is the length of program p.'))
E.append(sp(4))
E.append(label_box('Definition D1 — Incompressibility Threshold', [
'P0 = limn→∞ K(x|n) / n',
'P0 is the algorithmic entropy rate of x. When P0 reaches its maximum, x has exhausted its capacity for self-description.',
]))
E.append(sp(4))
E.append(label_box('Remark R1 — Scope of P\u2080', [
'What P0 establishes (Derived): the point at which x becomes incompressible.',
'What P0 does not establish (prior versions: Axiomatic): that incompressibility causes the Binary Snap. Version 1.4 updates this: the generative claim is now a Candidate Theorem (T-BUF), not a bare axiom. See Section V.',
]))
E.append(Paragraph('II. Informational Work: State Representations and JSD', S['h1']))
E.append(Paragraph('2.1 The Representation Principle', S['h2']))
E.append(label_box('Principle RP-1 — Minimum Sufficient Probabilistic Representation', [
'The minimum sufficient probabilistic representation of a binary ontological state is a point-mass (Dirac) distribution over {0,1}: all probability mass is assigned to the value the state occupies, and none to the other value.',
'Justification: A point-mass distribution is the unique distribution that is (a) faithful — assigns non-zero probability only to the ontologically actual value, and (b) non-redundant — carries no uncertainty about which state is occupied. Any distribution with mass at both values represents partial existence and partial non-existence simultaneously. AX-B1 excludes this.',
'Status: PRINCIPLE — representational commitment parallel to MP-1 in ZP-B.',
]))
E.append(sp(4))
E.append(label_box('Theorem T1 — State Representations are Uniquely Derived', [
'Given AX-B1 and RP-1, the distributions are unique:',
'P = (1, 0) (Null State: all mass at 0 — non-existence)',
'Q = (0, 1) (First Atomic State: all mass at 1 — existence)',
'Proof: AX-B1 establishes two ontological states. RP-1 requires point-mass representation of each. The Null State occupies value 0: P = (1,0). The First Atomic State occupies value 1: Q = (0,1). No distribution (p, 1−p) with 0 < p < 1 is consistent with AX-B1. P and Q are unique. Status: DERIVED from AX-B1 and RP-1. ✓',
]))
E.append(sp(4))
E.append(label_box('Corollary T1b — JSD = 1 bit', [
'For P=(1,0) and Q=(0,1) with M=(1/2, 1/2):',
'DKL(P‖M) = 1 bit, DKL(Q‖M) = 1 bit, JSD(P‖Q) = 1 bit',
'E = JSD(P‖Q) = 1 bit [information-theoretic, dimensionless]',
'Status: Derived from AX-B1 and RP-1 via T1. E is not physical energy in joules. Dimensional bridge belongs to ZP-E as BA-1.',
]))
E.append(sp(4))
E.append(label_box('Definition D3 — Dirac Measure δ\u2080', [
'∫Ω f dδ0 = f(0)',
'δ0 places unit mass at 0. Compatible with the discrete topology of {0,1} and with the totally disconnected topology of Q2 (ZP-B T5). δ0 governs behaviour exactly at x = 0.',
]))
E.append(sp(4))
E.append(label_box('Remark R2 — Hamming Cross-Validation', [
'dH(P, Q) = 1 [Hamming, on {0,1}]',
'The agreement between dH = 1 and E = 1 bit is a consistency check, not a proof that Hamming distance and JSD are equivalent in general. Both are computed by independent methods on the same AX-B1-derived distributions.',
]))
E.append(Paragraph('III. The Discrete Surprisal Field on Q\u2082', S['h1']))
E.append(label_box('Remark R3 — Why the Smooth Embedding Remains Retired', [
'ZP-B T5 establishes Q2 is totally disconnected. ZP-B T2 establishes every ball is clopen. Importing smooth calculus operators onto a totally disconnected space imports a smoothness assumption that contradicts ZP-B. The smooth embedding, MO-1, and P1 from v1.1 remain retired.',
]))
E.append(sp(4))
E.append(label_box('Definition D4 — Discrete Surprisal Function I', [
'For x ∈ Q2 with x ≠ 0 and P(x) > 0:',
'I(x) = −log2 P(x)',
'As v2(x) → +∞ (x approaches 0 in the 2-adic metric), I(x) → +∞: states 2-adically close to 0 are informationally extreme.',
'The probability measure P on Q2 \\ {0} is the branching measure induced by the binary ball hierarchy of Q2: at each level k, the two sub-balls of B(0, 2−k) each receive half the probability mass of their parent ball.',
]))
E.append(sp(4))
E.append(label_box('Definition D5 — Discrete Surprisal Difference Operator DF', [
'For x, y ∈ Q2 \\ {0}:',
'DF(x, y) = I(y) − I(x) = log2[P(x) / P(y)]',
'DF is antisymmetric: DF(x,y) = −DF(y,x). No smoothness is assumed; DF is defined entirely pointwise.',
]))
E.append(sp(4))
E.append(label_box('Definition D6 — Discrete Circulation (Extended)', [
'FINITE CASE: A discrete loop γn = (x0, x1, …, xn, x0) in Q2 \\ {0} returning to its start. Circulation: C(DF, γn) = ∑i=0n DF(xi, xi+1) where xn+1 = x0.',
'Note: By telescoping, C(DF, γn) = I(x0) − I(x0) = 0 for all finite loops. DF is conservative on all finite loops.',
'INFINITE CASE: An infinite sequence σ = (x1, x2, …) in Q2 \\ {0} where v2(xi) = i for all i ≥ 1. Partial circulation: Cn(DF, σ) = I(xn+1) − I(x1).',
'Circulation of σ: C(DF, σ) = limn→∞ Cn(DF, σ) if the limit exists or diverges.',
'An infinite sequence σ exhibits non-conservative behaviour if C(DF, σ) diverges.',
]))
E.append(sp(4))
E.append(label_box('Theorem T2 — DF Exhibits Non-Conservative Behaviour on Infinite Sequences Approaching 0', [
'DF is conservative on all finite loops (C = 0 by telescoping). On infinite sequences through the ball hierarchy approaching 0, the circulation diverges: C(DF, σ) → +∞.',
'Proof: Let σ = (x1, x2, …) with xi = 2i. Then P(xi) = 2−i, so I(xi) = i. Partial circulation Cn = I(xn+1) − I(x1) = n. As n → ∞: C(DF, σ) = +∞.',
'Divergence arises from the unbounded depth of the 2-adic ball hierarchy (ZP-B). Finite conservation and infinite divergence are distinct regimes; no contradiction arises.',
'Status: DERIVED from ZP-B ball hierarchy structure and branching measure on Q2. OQ-C1 closed. ✓',
]))
E.append(Paragraph('III-B. Informational Extremity of the Null State', S['h1']))
E.append(label_box('Lemma L-INF — Informational Extremity of ⊥', [
'The surprisal I(n) = n at ball-hierarchy depth n is unbounded above: for any finite bound M, there exist depths n with I(n) > M.',
'The null state ⊥ = c0 corresponds to the limit point 0 ∈ Q2 — the limit of the binary ball hierarchy at infinite depth. The binary branching measure assigns equal probability mass at each branch level (D4), and the surprisal diverges without bound as depth increases (T2). At this limit, no finite bound M contains the informational content of ⊥.',
'Proof: Let M ∈ ℝ. By the Archimedean property, ∃ n ∈ ℕ with n > M. Then I(n) = n > M. Since M was arbitrary, surprisal is unbounded above. ✓',
'Formal content: surprisal is not bounded above by any real M.',
'Semantic content: ⊥ is informationally extreme — the compressed limit of all possible binary programs, approached by the perfectly balanced binary branching hierarchy. No finite external program bounds its informational content; therefore no finite external interpreter can hold ⊥ as a static description. This is the mathematical premise for DA-1 (ZP-E § I-DA1).',
'Note: the connection from informational extremity to forced execution is a named design principle (DA-1 in ZP-E), not a mathematical consequence of L-INF alone. L-INF supplies the formal premise; DA-1 supplies the ontological bridge.',
'Status: DERIVED from D4 and T2. Lean: ZPC.l_inf (purity check: no non-Mathlib axioms).',
]))
E.append(sp(4))
E.append(Paragraph('IV. Execution as State: The Hardware Lemma', S['h1']))
E.append(label_box('Definition D7 — Machine Configuration', [
'A machine configuration c is a complete description of a Turing machine at a given moment: the current state of the control unit, the position of the read/write head, and the contents of all tape cells.',
'c0: the initial configuration — the machine exists but has not yet begun execution (no instruction has been fetched).',
'c1: the first running configuration — the machine has fetched and begun executing its first instruction.',
'Note: D7 does not import physics. It is a structural distinction between two discrete machine states within the standard Turing model.',
]))
E.append(sp(4))
E.append(label_box('Lemma L-RUN — Execution is a Non-Null State Change', [
'The transition from c0 (initial: not yet running) to c1 (running: first instruction fetched) is a discrete, irreducible state change in the machine configuration.',
'Proof:',
'Step 1 — c0 and c1 are distinct configurations by D7: the control unit is in a different state (idle vs. executing). c0 ≠ c1.',
'Step 2 — By AX-B1, a state either exists or it does not. The machine at c1 occupies a configuration distinct from c0. The transition c0 → c1 is a binary state change in the sense of AX-B1.',
'Step 3 — The transition is irreducible: there is no intermediate configuration between c0 and c1. The first instruction fetch is the minimal unit of execution.',
'Step 4 — c0 corresponds to ⊥ (no distinguishable structure). c1 is strictly above ⊥ in the semilattice: the machine configuration has gained content (an active execution context) not present in c0.',
'Conclusion: c1 ≠ ⊥. The act of execution is itself a non-null state, regardless of what the output tape contains. ✓',
'Status: DERIVED from AX-B1 and D7. No Coding Theorem required. No output-tape contents required.',
]))
E.append(sp(4))
E.append(label_box('Remark R4 — Configuration and Output Are Independent', [
'D-TQ-2 (Output Definition): A computation\'s output is defined by the contents of its tape/register at termination.',
'L-RUN establishes that configuration state and output state are independent. A program may terminate with null output while still having passed through non-null configuration states during execution.',
'The question "can a program output ⊥ without any non-null intermediate state?" is answered by looking at the execution trace, not the output tape. This distinction is load-bearing for T-BUF and TQ-IH.',
]))
E.append(Paragraph('V. The Test Question and the Buffer Overflow Theorem', S['h1']))
E.append(label_box('Test Question TQ-IH — Can a Program Output ⊥ Without a Non-Null Intermediate State?', [
'Question: Does there exist a program p such that U(p) = ⊥ and the execution trace τ(p) contains no configuration ci with ci ≠ ⊥?',
'Answer: No.',
'Proof:',
'Step 1 — Any program that executes must pass through c1 (by definition of execution, D7).',
'Step 2 — By L-RUN, c1 ≠ ⊥.',
'Step 3 — Therefore the execution trace τ(p) = (c0, c1, …) contains c1, which is a non-null configuration state, regardless of what appears on the output tape at termination.',
'Step 4 — The output of p being ⊥ does not imply that all configurations in τ(p) are ⊥. Output state and configuration state are distinct (R4).',
'Conclusion: No program can produce ⊥ as output without passing through a non-null intermediate configuration state. TQ-IH answered negatively. ✓',
'Status: DERIVED from L-RUN, D7, and R4. No Kolmogorov machinery required. AX-1 derivability pathway now open.',
]))
E.append(sp(4))
E.append(label_box('Candidate Theorem T-BUF — Incompressibility Forces Non-Null Execution State', [
'Statement: At the incompressibility threshold P0, the Binary Snap ⊥ → ε0 is a structural consequence of execution, not an external trigger.',
'Step 1 — P0 identifies the configuration x at which K(x|n)/n = 1: the configuration string is incompressible. (D1)',
'Step 2 — An incompressible configuration at P0 is informationally extreme (L-INF): its surprisal is unbounded — no finite external program bounds its informational content. A configuration with unbounded informational content has no finite external interpreter and cannot be a static description. Therefore the configuration at P0 is a live machine state. The design principle connecting informational extremity to forced execution is DA-1 (ZP-E § I-DA1, citing L-INF).',
'Step 3 — Any execution passes through c1 (L-RUN). c1 ≠ ⊥ (L-RUN conclusion).',
'Step 4 — In (L, ∨, ⊥), this non-null configuration state is c1 = ⊥ ∨ ε0. By ZP-A D2, this is the Binary Snap.',
'Conclusion: At P0, execution is structurally guaranteed. Execution guarantees a non-null configuration state. That state is ε0 in the semilattice. AX-1 is derivable from P0 + L-RUN + TQ-IH + ZP-A D2. ✓',
'Status: CANDIDATE THEOREM — structurally complete within ZP-C. Cross-framework integration (DA-1) owned by ZP-E. The gap between incompressibility and forced transition is closed at the configuration level.',
]))
E.append(sp(4))
E.append(label_box('Remark R5 — Updated Status of AX-1', [
'Prior to v1.4: AX-1 (Binary Snap Causality) was labeled Axiomatic in ZP-C.',
'As of v1.4: AX-1 is a Candidate Theorem. The derivation pathway: P0 (D1) identifies the threshold. L-RUN establishes that execution at the threshold constitutes a non-null state change. TQ-IH establishes that no program avoids this. ZP-A D2 establishes that a non-null state change from ⊥ is the Binary Snap.',
'Remaining work: DA-1 (Definitional Alignment) must formally tie instantiation of P0 to an execution event. This is owned by ZP-E.',
'Status label: CANDIDATE THEOREM — gap identified and named (DA-1). Closed in ZP-E DA-1 insert.',
]))
E.append(Paragraph('VI. Open Items Register for ZP-C v1.4', S['h1']))
E.append(data_table(
['Item', 'Status', 'Description'],
[['S1: Distribution stipulation', 'Closed — T1', 'T1 derives P and Q from AX-B1 and RP-1.'],
['OQ-C1: Non-conservation', 'Closed — T2 rebuilt', 'Telescoping critique resolved; infinite divergence proven within extended D6.'],
['Smooth embedding, MO-1, P1', 'Retired', 'Remain retired from v1.2. Inconsistent with ZP-B.'],
['RP-1: Representation principle', 'Principle — explicit', 'Bridge between AX-B1 and probabilistic tools.'],
['D7: Machine configuration', 'Defined', 'Foundation for L-RUN and TQ-IH.'],
['L-RUN: Hardware Lemma', 'Derived — Lemma', 'Execution is a non-null state change. Derived from AX-B1 and D7.'],
['TQ-IH: Test Question', 'Closed — Negative', 'No program can output ⊥ without a non-null intermediate configuration state. Proven by L-RUN.'],
['T-BUF: Buffer Overflow Theorem', 'Candidate Theorem', 'Incompressibility forces non-null execution state. DA-1 bridge in ZP-E closes this fully.'],
['AX-1: Binary Snap Causality', 'Candidate Theorem', 'Derivation pathway formalized. Closed as T-SNAP in ZP-E DA-1 insert.']],
[1.6*inch, 1.5*inch, 3.4*inch]
))
E.append(Paragraph('VII. Validation Status', S['h1']))
E.append(data_table(
['Component', 'Status / Notes'],
[['K(x|n) and P0 (D1)', 'Valid — standard algorithmic IT'],
['R1: Scope of P0', 'Valid — updated: AX-1 now Candidate Theorem, not bare axiom'],
['RP-1: Representation Principle', 'Valid — Principle; explicit bridge; resolves reviewer gap in T1'],
['T1: Distributions from AX-B1 + RP-1', 'Valid — Derived; reviewer gap closed'],
['D2: JSD definition', 'Valid — standard'],
['T1b: E = JSD = 1 bit', 'Valid — Derived from AX-B1 + RP-1'],
['D3: Dirac measure δ0', 'Valid — standard; compatible with discrete Q2 topology'],
['R3: Smooth embedding retired', 'Valid — Retired; inconsistent with ZP-B'],
['D4: Discrete surprisal I(x)', 'Valid — pointwise on Q2 \\ {0}; branching measure stated'],
['D5: Difference operator DF', 'Valid — antisymmetric; no smoothness assumed'],
['D6: Circulation (extended)', 'Valid — finite and infinite cases both defined; finite conservation acknowledged'],
['T2: Non-conservation rebuilt', 'Valid — Derived; telescoping critique addressed; divergence at σ→0 established'],
['R2: Hamming cross-validation', 'Valid — Consistency check'],
['D7: Machine configuration', 'Valid — Defined; standard Turing model; no physics imported'],
['L-RUN: Hardware Lemma', 'Valid — Derived from AX-B1 and D7'],
['R4: Configuration vs. output independence', 'Valid — load-bearing distinction for TQ-IH and T-BUF'],
['TQ-IH: Test question answered', 'Valid — Derived by L-RUN; no Kolmogorov machinery required'],
['T-BUF: Candidate Theorem', 'Candidate — structurally complete in ZP-C; DA-1 bridge in ZP-E closes fully'],
['R5: AX-1 status updated', 'Valid — AX-1 is Candidate Theorem; prior Axiomatic status corrected']],
[2.5*inch, 4.0*inch]
))
doc.build(E)
print('ZP-C done')
# ── MAIN ──────────────────────────────────────────────────────────────────────
if __name__ == '__main__':
import shutil
os.makedirs(OUT_DIR, exist_ok=True)
build_zpa()
build_zpa_companion()
build_zpb()
build_zpc()
build_zpd()
# build_zpe_da1() removed 2026-04-23: ZP-E_DA1_TSNAP_Insert was superseded by
# ZP-E_Bridge_Document_v2_0, which integrates DA-1, DA-2, DA-3, and the full
# traceability register. The insert is archived at historical/ZP-E_DA1_TSNAP_Insert-1.pdf.
# The build_zpe_da1() function is retained below for reference.
# Verify all PDFs
# METHOD: pdfplumber page.chars (character-level extraction).
# This is the only reliable method — extract_text() and extract_words() both
# drop glyphs adjacent to sub/superscript text (mixed-baseline extraction bug).
# Raw binary search is also unreliable: ReportLab uses font-internal glyph IDs
# for some characters, not direct Unicode codepoints.
# NULL chars in the char stream = genuine missing glyph in the font.
#
# Per-document symbol map: only check symbols actually used in each doc.
# ≤ does NOT appear in ZP-B (topology) or ZP-C (info theory) — only ZP-A and ZP-D.
# ∨ does NOT appear in ZP-B — it is topology only, no semilattice operators.
import pdfplumber
DOC_SYMBOLS = {
'ZP-A_Lattice': [0x22A5, 0x2228, 0x2264], # ⊥ ∨ ≤
'ZP-A_Illustrated': [0x22A5, 0x2264], # ⊥ ≤
'ZP-B': [0x22A5, 0x2208, 0x211A, 0x2192], # ⊥ ∈ ℚ →
'ZP-C': [0x22A5, 0x2228, 0x2192, 0x2208], # ⊥ ∨ → ∈
'ZP-D': [0x22A5, 0x2208, 0x2102, 0x2264], # ⊥ ∈ ℂ ≤
'ZP-E': [0x22A5, 0x2192, 0x2208, 0x2228], # ⊥ → ∈ ∨
}
print('\n── Verification ──')
for fname in sorted(os.listdir(OUT_DIR)):
if not fname.endswith('.pdf'):
continue
path = os.path.join(OUT_DIR, fname)
with pdfplumber.open(path) as pdf:
pages = len(pdf.pages)
all_chars = []
for page in pdf.pages:
all_chars.extend(c['text'] for c in page.chars if c['text'])
char_set = set(all_chars)
size = os.path.getsize(path) // 1024
issues = []
null_count = sum(1 for c in all_chars if ord(c) == 0)
if null_count > 0:
issues.append(f'NULL CHARS x{null_count} — missing glyph, needs DV font wrap')
doc_key = next((k for k in DOC_SYMBOLS if k in fname.replace('_Lattice_Algebra', '_Lattice').replace('_Illustrated_Companion', '_Illustrated')), None)
if doc_key:
for cp in DOC_SYMBOLS[doc_key]:
if chr(cp) not in char_set:
issues.append(f'MISSING {chr(cp)} U+{cp:04X}')
status = 'PASS' if not issues else 'FAIL: ' + ', '.join(issues)
print(f' {fname}: {pages}pp {size}KB [{status}]')
# Copy verified PDFs to project root
for fname in os.listdir(OUT_DIR):
if fname.endswith('.pdf'):
shutil.copy(os.path.join(OUT_DIR, fname), os.path.join(PROJECT_ROOT, fname))
print('\nAll PDFs copied to project root.')