The Atomic Proof of the Riemann Hypothesis
The Prime Side and the Non-Trivial-Zero Side Halted at One Irreducible Bit, Least Erasure, and Its Form Forced as the Only Form of Proof
Mohammad F. Islam, PhD
abstract: | We carry the Riemann Hypothesis to one named one-bit premise from both of its sides at once, and prove, in one standalone seed of 664 theorems in core Lean 4 with no axiom declared, that the two sides halt at the same proposition. On the prime side the explicit formula makes the error $\psi(x)-x$ a sum of modes $x^{\rho}$, and the error stays within $x^{1/2+\varepsilon}$ exactly when every non-trivial zero lies on the critical line [von Koch 1901, cited]. On the non-trivial-zero side, the totality of finite reports of the zero set's members lands on the line exactly when every zero lies on the line, and one report decides only its own points. The critical line itself is derived twice at theorem grade: as the locus of the one real part fixed by the only rigid reversal of the arrow between the two poles of the completed zeta function, on every extension of that reversal to the plane and blind to the arrow's sign, and as the centre of every nonempty finite reflection-closed family of zeros. Both readings are least erasure, the projection onto the line fixing every zero; least erasure, the value, the root read twice and their co-location are one predicate, by equality. The value is irreducible by theorem from both sides: no premise true of every reflection-closed configuration forces it, the root and every computation included; no reading of the record decides it; and the known facts of $\zeta$ placed on the arrow, the Euler product at the poles, the zero-free region and the verification to $3\cdot10^{12}$, with the statement stronger than every positive-proportion theorem that only finitely many zeros stand off the line, hold together on a model whose only off-line zeros are one mirrored pair and its conjugate. Its form, place, content and denial are forced by theorem: the weakest premise that forces it is itself. The bit is supplied by one act at premise grade as a field of a type, at every resolution of the chart, and from that field the hypothesis, the zero reports and the prime bound follow at theorem grade. One theorem binds the reduction, the irreducibility, the forced form, the atomic bit and the closure: the atomic proof. A second proves its form forced: every proof of the hypothesis at a zero set read into the chart, from any premise, in every vocabulary the seed names and from either side, is a supply of the one field there; any two proofs of the bit are one proof; and the supply at a zero set is unique. Two more close the arc: the unconditional route, from anything every reflection-closed configuration shares, the root and the record included, is blocked; and accepting the hypothesis, by any proof, an unconditional one included, forces acceptance of the atomic proof provided here, the only other door being one point off the line. A last binds, by its exact type, every theorem the body of the paper cites. The floor, the Root Axiom as a self-grounding root, is proved on no axiom. The one refuter stands outside every theorem: a zero of $\zeta$ computed off the line.
* The root of this paper is proved, on no axiom and no hypothesis, in Appendix R and again as Part I of the seed. The paper's closing theorems consume one reading of that root, at the zeros of $\zeta$, and no other posit; their input type also carries the functional equation with the conjugate symmetry, cited. The root alone decides no value, by theorem; the root read at the zeros is the value, by theorem; the route of derivation from the record is blocked, by theorem; and the two sides of the hypothesis, the primes and the zeros, halt at that one reading, by theorem.
0. How to read this paper
The first edition carried a two-part result, and each part refuted a reading that keeps only the other. A reader who finds the premise equivalent to the hypothesis concludes that nothing is proved. A reader who finds a theorem whose conclusion is the hypothesis concludes that it is derived. Both readings are wrong, and the theorem that says so compiles (reader_frame, no axiom). The second edition keeps that frame whole and adds the second side.
The first edition reached the line from the prime side: the free basis of the primes, the chart of the critical line, least erasure, the five faces of one bit, and the act. This edition reaches the same line from the side of the non-trivial zeros themselves, and then proves that the two sides halt at one proposition. The line is read off the arrow between the two poles of the completed zeta function, and off the centre of the zero set. Every computation that reads the zeros is read as Row 4 of the first edition's closure table. The prime error is read through the explicit formula. Both halt at least erasure of the whole zero set, and neither passes it.
One seed carries everything: the root on no axiom (Part I), the first edition's kernel verbatim (Part II), the timeless closure with the second edition's laws appended (Part III), the arrow and the zeros' own locus (Part IV), the run (Part IV-b), the time kernel of the monism-fixed codex (Part IV-c), the facts of $\zeta$ placed on the arrow (Part V), the charts made one (Part V-b), and one theorem binding, by its exact type, every theorem the body cites (Part VI, the_two_sided_closure).
0.1 The verdict
The verdict is stated once here and once in the conclusion, in the same words each time.
The Riemann Hypothesis is not derived from any set-theoretic foundation in this paper. From both sides at once, the primes and the non-trivial zeros, every reading of the hypothesis halts at one proposition, that every non-trivial zero stands on the critical line, and the line itself is read off the arrow between the two poles and off the zero set's own centre, by theorem. The value is closed to one named bit, least erasure at the zero set of $\zeta$, irreducible by theorem and forced by theorem in form, place, content and denial; every proof of the hypothesis, in every vocabulary the seed names and from either side, is a proof of that bit. The bit is supplied by one act, at premise grade, as a field of a type; from that field the hypothesis, the zero reports and the prime bound follow at theorem grade. The reduction, the witnessed bit and the closure stand in one machine-checked statement, the atomic proof, and its form is forced: every proof of the hypothesis, from any premise and in every vocabulary the seed names, is a supply of that one field, and the supply at the zero set is unique. The compile, the printed cones and the judgment of the compiler are the receipts.
Every clause is a theorem of the seed, a theorem of the seed read at the zeros of $\zeta$ through the readings of Section 11, a receipt of the compiler, or a statement of what this paper does. The two-sided halt is bidirectional_halted_uniduction. The line off the arrow is the_only_rigid_reversal, the_line_off_the_arrow, hinge_sign_blind and zeta_hinge; off the centre, centre_is_the_line. One predicate under four names is the_one. Irreducibility is no_closed_principle_decides, keyless_forces_nothing, the_last_act, the_plug_fails and faithful_arrow_side_test. The forced form is rh_is_the_weakest_forcing_premise and part III of the_atomic_proof. The vocabulary clause is vocabulary_law. The closure from the field is rh_from_the_act (no axiom) and part V of the_atomic_proof, at every resolution the_act_at_every_resolution. The atomic proof is the_atomic_proof; its forced form is the_atomic_necessity. All of it is bound in the_two_sided_closure.
0.2 What is not claimed
The paper does not claim a derivation of the Riemann Hypothesis inside ZFC or inside any other foundation. It does not claim that the hypothesis is independent of ZFC; it proves that, for a foundation complete and sound on the denial, the two fields of the setting independence_forces_truth takes (Section 11), independence would establish the hypothesis. It does not claim that its discrete charts are the zeta function: the analytic identifications, the functional equation, the explicit formula with von Koch's criterion and the verification to $3\cdot10^{12}$, enter as cited fields or cited readings, and the zeros of $\xi$ enter the charts by the reader's rule of the first edition (its Definition 14.1 and Section 18), stated at every resolution and kept in the open chart strip in Section 11, at every resolution: by that rule the hypothesis is the value at every resolution, and the act supplies it at every resolution (Theorem 2.2). The off-line pairs used as model configurations are planted models, never zeros of $\zeta$: the timeless closure of Part III carries one at height 0, Part IV one at Re $s=1/4$ and $3/4$ at height 0, the first edition one on its resolution-one chart and one inside its open strip at resolution two, the time kernel one at Re $s=0$ and $1$ and, in its probe inside the strip, a quadruple at Re $s=1/4$ and $3/4$, and Parts V and V-b the pair at Re $s=1/4$ and $3/4$ at height $3\cdot10^{12}+1$, which every fact of $\zeta$ placed on the arrow admits and at which the blocks of the record, the halt, the deed and the loop are restated (the_blocks_at_the_one_pair). Each is computed by no one, and each refutes implications, never the hypothesis. The atomic proof of this paper is premise grade: its one premise is named, least erasure at the zero set of $\zeta$, supplied by the act, and that premise is equivalent to the hypothesis. The one channel every theorem leaves open is a zero of $\zeta$ off the line, which a finite computation would certify (Section 13).
0.3 The reflexive readings, and the theorem that refutes each
| The reflexive reading | What the seed proves | Theorem | Cone |
|---|---|---|---|
| The premise is the hypothesis, so the argument is circular. | The premise is equivalent to the hypothesis, by theorem, and it is named; a circle would be the conclusion used as a hidden step. What is proved beyond the premise is the reduction of every reading of the hypothesis to it and its irreducibility (the_atomic_proof, parts I and II). That the weakest premise forcing the value is the value is a law of logic: it names the bit and adds nothing to it. The loop through the root read twice closes for the value and for its denial alike, so self-reference selects nothing. |
the_atomic_proof, rh_is_the_weakest_forcing_premise, the_loop |
[propext, Quot.sound]; none; [propext, Classical.choice, Quot.sound] |
| The line read off the zeros' own side puts every zero on it. | The centre of every nonempty finite reflection-closed family is the line. A pair at Re $s = 1/4$ and $3/4$ is reflection-closed, centred on the line, inside the strip, and off it. A centre binds members in mirror pairs, one pair at a time on the line or across it. | centre_is_the_line, centred_yet_off |
[propext, Quot.sound]; none |
| The arrow, the root, or the act of existing forces the zeros. | No premise true of every reflection-closed configuration forces the value. Every deed of the root being the supply at a zero set is exactly the value there; as a law over every closed zero set it is refuted. | keyless_forces_nothing, the_last_act, the_deed_is_not_the_supply |
none, for all three |
| A run of the machine supplies the bit. | A run witnesses that it ran and leaves the value free. A run's flag offered as the supply field at every closed configuration is refused by the compiler; at one zero set it carries the field exactly where the value already holds. | force_witness_closure, the_plug_fails |
none, for both |
| A minimum principle forces $\zeta$ onto the line. | The minimiser of escape stands on the line; an off-line pair, listed once, escapes by exactly one bit and pays one floor. On every finite configuration, being a minimiser is the value; on every configuration, least erasure is the value (twins_on_every_world); and nothing true of every closed configuration makes any configuration a minimiser. |
least_erasure_and_least_escape |
none |
| The known facts about $\zeta$ decide it. | The Euler product at the poles, the zero-free region, the verification to $3\cdot10^{12}$ and the empty band below height 14, with the functional equation, conjugate symmetry and the statement stronger than every positive-proportion theorem that only finitely many zeros stand off the line, hold together on a model whose only off-line zeros are one mirrored pair just above $3\cdot10^{12}$ and its conjugate, at every chart width from two and under every zero-free margin short of the pair. The same facts separate $\zeta$ from the Davenport–Heilbronn shape at the poles. | faithful_arrow_side_test, at_zetas_numbers_faithful, faithful_every_margin, beyond_the_head_breaks_ends |
[propext, Quot.sound], for all four |
| ZFC has not proved it, so nothing here counts. | For a foundation complete and sound on the denial, independence would decide the value in favour; a sound foundation's proof of the hypothesis is a least-erasure proof. | independence_forces_truth, the_front |
[propext, Classical.choice, Quot.sound]; none |
| Verification to $3\cdot10^{12}$ makes the hypothesis overwhelmingly likely. | Given the verified part, every zero with $ | t | $ at most the height, the value is exactly its part above the height; above every height no reading of the record decides the side of a point. |
| The atomic proof is one proof among many possible proofs. | Every proof of the value at a zero set, from any premise whatever, is a supply of the act's field there; any two proofs of the value are one proof; two supplies with the same zero set are one supply; every vocabulary and both sides name the same proposition; and nothing every closed configuration shares proves it. The form is the form of a field, which the denial has too with its own field; the act's type is the field of the value. | the_atomic_necessity, the_form_is_the_hypothesis |
[propext, Quot.sound], for both |
| It can simply be rejected. | The denial of the hypothesis has a world: closed, with the root standing on it, lacking the value. The denial of the root has none. What a rejection brings is one point off the line, which a finite computation would certify. | line_no_has_a_world, tongue_no_has_no_world |
none, for both |
0.4 The lock
The root, to exist is to actuate, is proved in this paper unconditionally, on no axiom and no posit (Part I, Appendix R): for every root that grounds itself the root holds, every denial is an act and re-enacts it, no outside proof adds to it, and no level stands above it; on its constructed domain the Root Axiom is a theorem with no hypothesis. The root holds on a reflection-closed world where the hypothesis holds and on one where it fails, twins of one record, so read uniformly on the worlds the root forces no value. Read at the zeros, with the points of the world as its existents and standing on the line as their actuation, the root is the hypothesis and least erasure, keyed where the root alone is not. The second edition adds that both sides of the hypothesis halt at that reading and at nothing else.
Status
Unconditional, at theorem grade. The root, on its constructed domain and for every root that grounds itself (on no axiom). The critical line as the locus of the one real part the only rigid reversal of the arrow between the poles fixes, on every extension of the reversal to the plane, blind to the arrow's sign (Lean's standard axioms alone; the poles' placement at $s=0$ and $s=1$ cited). The critical line as the centre of every nonempty finite reflection-closed family (Lean's standard axioms alone). The charts are one: every plane chart of the seed maps equivariantly into the offset chart, at every resolution and every width, and the value, every act and the root read at the zeros transport (Lean's standard axioms alone). Least erasure, the value, the root read twice and their co-location as one predicate (Lean's standard axioms alone). The two-sided halt: the zero reports and the prime bound each equal to the value of the whole zero set, and to each other, the prime bound read as the chart's image of von Koch's bound through the explicit formula [cited] (Lean's standard axioms alone). The irreducibility of the value from both sides, and its form, place, content and denial forced by theorem. The atomic form forced: every proof of the hypothesis at a zero set read into the chart is a supply of the one field, and the supply at the zero set is unique (Lean's standard axioms alone). Rows 10 and 11: the unconditional route from shared premises and the record blocked, and acceptance of the atomic proof forced on every acceptance of the hypothesis (Lean's standard axioms alone). The timeless closure. The two-sided closure theorem binding all of it (Lean's standard axioms alone).
On the reading, at premise grade. The Riemann Hypothesis holds at the zero set of $\zeta$ read as the act's zero set, at every resolution: from the field supply, the hypothesis follows with an empty axiom cone, on the first edition's chart (rh_from_the_act) and on the offset chart at every resolution (the_value_at_every_resolution), and with it the zero reports and the prime bound (the_atomic_proof, part V; the_act_at_every_resolution). The atomic proof is that premise-grade proof, its premise named.
1. The claim, stated whole
The Riemann Hypothesis asserts that every non-trivial zero of $\zeta$ has real part $1/2$. The functional equation $\xi(s)=\xi(1-s)$, with $\xi(\bar s)=\overline{\xi(s)}$, reflects the zero set across the critical line; the hypothesis says that nothing stands off the fixed line of that reflection. This paper does four things with that statement and keeps the four apart.
First, it derives the line. The line is not taken from the zeros and not assumed from the hypothesis. It is the locus of the one real part fixed by the only rigid reversal of the arrow between the two poles of the completed zeta function, on every extension of that reversal to the plane, and it is the centre of every nonempty finite reflection-closed family of zeros. Both are theorems.
Second, it carries the hypothesis to one proposition from both sides. From the primes: the error of the prime count halts at the value. From the zeros: the totality of reports that read them halts at the value. The two halts are one proposition, least erasure of the whole zero set.
Third, it locates, by theorem, the one thing neither side can prove from anything weaker than itself: the value of that proposition at the actual zero set. The location is exact. Nothing true of every reflection-closed configuration forces it; no reading of the record decides it; the root, every deed, every run, the loop through the root read twice, the least-escape principle and the known facts of $\zeta$ on the arrow all leave it where it is.
Fourth, it closes the claim by one explicit act, as the first edition did. The bit is supplied, once, in the open, as the field supply of a structure whose other fields are the zero set and its reflection symmetry, at every resolution of the chart. From that field the hypothesis follows with an empty cone, and from both sides at once.
The reader who grants least erasure at the actual zero set has the hypothesis, the zero reports and the prime bound by printed theorems. The reader who does not has the exact coordinates of the one bit the act supplies, from both sides, with a proof that nothing weaker supplies it and that every route of the kinds the paper can name is blocked or lands on least erasure. The paper claims what it prints and nothing beyond it.
1.1 What is new in the second edition
- The charts are one. Every plane chart of the seed maps equivariantly into one offset chart, at every resolution and width; the line, the value, every act and the root read at the zeros transport; the zero set of $\zeta$ is read at every resolution, and the act supplies the bit at every resolution (Section 2.1).
- The line off the arrow. The completed zeta function has exactly two poles, $s=0$ and $s=1$. The only rigid map of the axis that exchanges them, proved on the chart (
the_only_rigid_reversal), is $\sigma\mapsto1-\sigma$; it fixes exactly one real part, $1/2$, and on every map of the plane that acts on the real part by it, the points whose real part it fixes are the line Re $s=1/2$; flipping the arrow's orientation leaves that line unchanged (Section 3). - The zeros' own bridge and locus. One series read twice, the explicit formula, the heat trace and its self-dual point, and the centre of the zero set at Re $s=1/2$ for every finite reflection-closed family (Section 5).
- Row 4 read from the zeros. On any act every computation that reads it reports only on-line zeros; a report holding an off-line zero reads no act; at a closed zero set the reports land on the line exactly at the value (Section 5.4).
- The prime side halts. Through the explicit formula, the prime bound at $x^{1/2+\varepsilon}$, read at every resolution together, is exactly the value of the whole zero set (Section 4.3).
- The two-sided halt. Both sides halt at one proposition and neither passes it (Section 8).
- The atomic proof. One theorem binds the reduction, the irreducibility, the forced form, the atomic bit and the closure (Section 9).
- The irreducibility completed. The last act, the run and its plug, least erasure with least escape, the loop, and the facts of $\zeta$ on the arrow, each a theorem (Section 6).
- One predicate, by equality. Least erasure, the value, the root read twice and their co-location are one predicate, by equality of predicates and not by paired equivalences (
the_one). - The atomic form forced. Every proof of the hypothesis at a zero set read into the chart, from any premise, is a supply of the one field; the bit has one proof; the supply is unique (Row 9, Section 9).
- Rows 10 and 11. The unconditional route from everything reflection-closed configurations share is blocked; accepting the hypothesis, by any proof, an unconditional one included, forces acceptance of the atomic proof provided in this paper, and the only other door is one point off the line (Sections 7 and 9).
- One seed. The root, the first edition's kernel, the timeless closure, the arrow, the run and the facts on the arrow in one file of 9,067 lines and 664 theorems, with one theorem binding every theorem the body cites (Section 10, Appendix S).
2. The foundation placed: the floor and the reading
The paper stands on two layers, and the grade of each is fixed by theorem.
| Layer | What it is | Grade | Compiled warrant |
|---|---|---|---|
| The floor | The Root Axiom as a self-grounding root. For every root that grounds itself the root holds, every denial is an act and re-enacts it, no outside proof adds to it, and no level stands above it. On its constructed domain the Root Axiom is a theorem. The three axes compose onto the scalar line of the quaternions, checked on the chart of the 625 quaternions with coordinates $-2$ to $2$, and the twelve gates are counted three ways. | Theorem grade, on no axiom and no posit | the_floor_is_universal, denial_reenacts_root, no_level_above, root_on_the_constructed_domain, the_master_seal, the_line_is_the_fixed_set: every cone empty (Part I) |
| The reading | The Root Axiom read at the zeros of $\zeta$: the points of the zero set as its existents, standing on the line as their actuation. It is least erasure at the zero set, and it is the hypothesis. | Premise grade: the one posit of the paper | root_at_zeros_is_least_erasure (none), the_root_read_twice_is_the_value (none), rh_from_the_act (none) |
The root read twice is carried in the seed as the witness of the line property: one involution, uniformity, and its seed, the value. Its equality with the value is the witness being the claim (the_root_read_twice_is_the_value, monism_witness_is_the_claim, no axiom), and the root read at the zeros on the first edition's chart is the same predicate at the image (the_charts_are_one).
The reading stays a premise by theorem. The floor holds in every world, the world where the hypothesis holds and the world where it fails alike, so it decides no value (the_floor_alone_decides_no_value, keyless_forces_nothing). Identifying the floor with least erasure on every closed world is refuted, and identifying them at one world is the supply itself (floor_is_not_least_erasure, merging_at_a_world_is_the_supply). That is why the reading is the posit, and why it is the only one.
Three words are kept apart throughout. A deed is a term of the type Act of a self-grounding root, and a root has many deeds; every physical computation is one. The act is a term of the type ActualZeros: a zero set, its reflection-closure and the field supply, which is the supply; at a zero set it is unique (Theorem 9.3). A run is a deed of the machine.
Three instruments of the foundation recur through the paper. The free basis at the primes: the primes admit every assignment of integers, existence and uniqueness both (primes_admit_every_assignment), and that freedom forces nothing about the line (prime_freedom_forces_nothing). The free sign of the arrow: the line does not depend on which way the arrow points (hinge_sign_blind). The three-axis seal: three orthogonal axes compose onto the scalar line of the quaternions, the fixed set of conjugation on the chart of the 625 quaternions with coordinates $-2$ to $2$ (the_line_is_the_fixed_set), with the twenty-four Hurwitz units, counted in doubled coordinates, and the twenty-four elements of the norm-two shell (twenty_four_units_twelve_gates, the_shell_splits_twelve_and_twelve) and twelve gates counted three ways (the_master_seal), all on no axiom.
2.1 The charts are one
The seed reads the critical line on five charts: the first edition's, $x=2n,\mathrm{Re},s$ at every resolution $n$, with heights in $\mathbb N$; the arrow's, $x=4,\mathrm{Re},s$; the time kernel's, $x=2,\mathrm{Re},s$ with heights in $\mathbb Z$; the facts' chart, $x=2W,\mathrm{Re},s$ at every width $W$; and the offset chart of the timeless closure and the run, $d=2n,\mathrm{Re},s-n$ at resolution $n$, whose line $d=0$ and fold $d\mapsto-d$ are the same at every resolution. Each maps into the offset chart at a definite resolution by an equivariant map, one that carries the chart's fold to the offset fold and the chart's line to the offset line, and every map keeps the chart's height and scales the offset from the line by a positive factor (the_maps_keep_height_and_scale, [propext, Quot.sound]). The maps of the first edition's chart at resolutions one and two, of the arrow's chart, of the time kernel's and of the facts' chart at width four land at resolution four, where one real part read on any of them lands at one offset point (the_maps_agree_at_resolution_four, [propext, Quot.sound]); the maps at resolution $n$ and width $W$ land at resolution $n$ and $W$. The maps out of the charts with heights in $\mathbb Z$ commute with conjugation, and the first edition's chart reads the upper half-plane (the_maps_commute_with_conjugation, no axiom). Equivariance alone fixes neither the scale nor the height; the scale of each map is the reader's. Under the maps into resolution four the model pair of Section 5.5 is one pair, at $d=\mp2$, on every chart those maps read that holds it, $x=4,\mathrm{Re},s$ and $x=8,\mathrm{Re},s$; read at resolution $n$ it lies at $d=\mp n/2$, two maps of one chart into different resolutions give one offset point at each, and the charts $x=2,\mathrm{Re},s$ do not hold it.
Theorem 2.1 (the charts are one; the_charts_are_one, [propext, Classical.choice, Quot.sound]; transport, no axiom). Every map is equivariant, at every resolution of the first edition's chart and every width of the facts' chart. On every chart the value of a configuration is the value of its image. Every act type of the seed, the first edition's at resolution one and at every resolution, the arrow's and the run's, is an act of the offset chart at the image of its zero set. The root read at the zeros on the first edition's chart is the root read twice at the image. Both constructed roots, Part I's and the first edition's, are roots the closing theorems take: Part I's forces no value, and the deed of either is the supply at a zero set exactly where the value holds.
Every name the paper gives the line, the value, least erasure, the act and the root therefore names one object across the seed's plane charts, by theorem, up to the chart maps: the first edition's act, read on the upper half-plane, and the reading of $\zeta$ on the offset chart are two configurations with one value.
The zero set of $\zeta$ is read on the offset chart at every resolution $n\ge1$ by the reader's rule (Section 11): a zero with real part $\sigma$ inside the open strip is read at $d=x-n$, where $x$ is $2n\sigma$ rounded half to even and kept in the open chart strip $1\le x\le2n-1$, which keeps it off the poles. One resolution is not enough. A zero at Re $s=51/100$ and its mirror read onto the line at resolution four and off it at resolution fifty, and a zero at Re $s=97/100$ is kept off the head pole at $d=3$ (one_resolution_is_not_enough, no axiom); read at resolution four the near pair has the value, read at resolution fifty it lacks it (one_resolution_does_not_decide_the_next, no axiom). By the reader's rule read at every resolution, the hypothesis is the value at every resolution, and the act supplies it at every resolution: Theorem 2.2 is the closure stated for every family of readings, the reading of the zero set of $\zeta$ among them.
Theorem 2.2 (the act at every resolution; the_act_at_every_resolution, [propext, Quot.sound]). For every family of reflection-closed readings, one at each resolution: the act stands at the readings exactly where the value holds at every resolution; on the act, at every resolution, the value, the zero reports and the prime bound hold; every proof of the value at every resolution, from any premise, is a supply of the act; the supply is unique; and the atomic proof, the atomic necessity and the two-sided halt hold at every resolution.
Every theorem of this paper stated for a reflection-closed zero set therefore holds of the reading of the zero set of $\zeta$ at each resolution.
3. The arrow: the critical line read off its two poles
The completed zeta function $\hat\zeta(s)=\pi^{-s/2}\Gamma(s/2)\zeta(s)$ has exactly two poles, at $s=0$ and $s=1$, and the functional equation $\hat\zeta(s)=\hat\zeta(1-s)$ exchanges them [Riemann 1859, cited]. The segment from $s=0$ to $s=1$ on the real axis is the arrow: $s=0$ its tail, the infinite-temperature edge where $\sum 1$ diverges; $s=1$ its head, the limiting temperature where the number of states $e^{E}$ meets the Boltzmann weight $e^{-sE}$.
Theorem 3.1 (the reversal is forced; the_only_rigid_reversal, [propext, Quot.sound]). In the chart $x=4,\mathrm{Re},s$, the only map of the axis that keeps every distance up to its sign and exchanges the poles $x=0$ and $x=4$ is $x\mapsto4-x$. The Number alone, distance with the sign forgotten, fixes the map.
Theorem 3.2 (the hinge; hinge, hinge_unique, hinge_iff_even, zeta_hinge). The reversal of any arrow fixes at most one point; it fixes exactly one, its midpoint, when the poles have an even sum in the chart, and none on the chart when the sum is odd; for $\zeta$ that point is $x=2$, Re $s=1/2$.
Theorem 3.3 (the line off the arrow; the_line_off_the_arrow, [propext, Classical.choice, Quot.sound]; centre_on_every_extension, [propext, Quot.sound]). Height is not on the arrow. On every map of the plane that acts on the real part by the reversal, the points whose real part it fixes are the line $x=2$, Re $s=1/2$, whatever the map does to height, and the real parts of every finite family and of its image balance on that line. The functional equation alone, $s\mapsto1-s$, fixes one point, $s=1/2$, and reads the same line (the_point_reflection_reads_the_same_line, [propext, Classical.choice, Quot.sound]). The map that keeps height, $s\mapsto1-\bar s$, the functional equation composed with the conjugate symmetry [Riemann 1859, cited], is the fold (fold_is_the_height_keeping_extension, no axiom), and its fixed set is the line (locus, [propext, Quot.sound]).
Theorem 3.4 (the free sign; hinge_sign_blind, [propext, Quot.sound]). Flipping the arrow's orientation leaves the reversal, its fixed line and every offset unchanged: the critical line does not depend on the arrow's free sign. Off the line a point has a side, the sign of its offset, which the fold flips (arrow_gives_line_not_value, conjunct seven); the side is what the record forgets.
The same hinge appears in the heat register. Riemann's proof of the functional equation starts from the heat trace of a circle, $\Theta(t)=\sum_{n\in\mathbb Z}e^{-\pi n^2t}$, with $\Theta(1/t)=\sqrt t,\Theta(t)$ by Poisson summation; inverting the temperature reverses the arrow, and the Mellin transform carries the fixed point $t=1$ to $s=1/2$ [Riemann 1859; consensus]. The arrow's reversal, the functional equation's reflection and the heat trace's inversion are one map; on the charts of this paper the reflection acts on the real part as the arrow's reversal and keeps height, and the chart maps carry it to the reflection of every other chart (the_charts_are_one).
What the arrow does not do is put any zero on its line. No premise true of every reflection-closed configuration forces the value (keyless_forces_nothing, no axiom), and the arrow is such a premise. The arrow derives the place. Section 6 proves that it derives nothing else.
4. The prime side
4.1 The first edition, carried
Part II of the seed is the first edition's kernel, Every_Prime_3_2_0.lean, verbatim and re-compiled in the seed. Its prime side stands as published: the chart of the critical line and the one cut; the identity and the two signs, a prime as one free orbit; the primes as the base of freedom, every assignment realized (primes_admit_every_assignment); the sign arrow, Liouville's function computed (liouville_is_the_sign_arrow, no axiom); the projection that does not decide (record_decides_nothing, no_reading_decides_in_the_strip); least erasure equal to the value with the mirror at eigenvalue $-1$ (least_erasure_is_the_value, no axiom); what freedom forces, nothing (prime_freedom_forces_nothing); Weil positivity on the prime side and the five faces of one bit, each proving every other (every_face_proves_every_face, no axiom); and the proof from the act (rh_from_the_act, no axiom). Its 415 theorems and 237 pinned cones re-compile unchanged inside the seed. Its chart at resolution one, $x=2,\mathrm{Re},s$, holds only the line inside the open strip, so there the open strip forces the value (open_strip_forces_at_resolution_one, [propext, Quot.sound]); its blocks are read at resolution two, $x=4,\mathrm{Re},s$, where the strip holds an off-line pair (keyless_forces_nothing₂, no_reading_decides_in_the_strip, [propext, Quot.sound]), and on the offset chart at every resolution (Theorem 2.2).
4.2 The prime side's reach on the arrow
The facts that $\zeta$ has and the Davenport–Heilbronn function lacks sit at the ends of the arrow. The Euler product forbids zeros with Re $s>1$; the prime number theorem forbids them on Re $s=1$ [Hadamard 1896; de la Vallée Poussin 1896]; the functional equation mirrors both to the tail. The zero-free region reaches inward from each pole by $c/\log t$ [de la Vallée Poussin 1899; Mossinghoff–Trudgian 2015]. The verification places every zero up to $3\cdot10^{12}$ on the line [Platt–Trudgian 2021]. And every positive-proportion theorem [Selberg 1942; Levinson 1974; Conrey 1989] and every zero-density estimate is implied by the stronger statement that only finitely many zeros stand off the line.
Theorem 4.1 (the arrow-side test, faithfully; faithful_arrow_side_test, at_zetas_numbers_faithful, faithful_every_margin, [propext, Quot.sound]). At resolution $x=8,\mathrm{Re},s$, heights read by their integer part, a configuration with a zero on the line at every height $|t|\ge14$ and one mirrored pair at Re $s=1/4$ and $3/4$ at height $3\cdot10^{12}+1$ with its conjugate at $-(3\cdot10^{12}+1)$ is closed under the reflection and under conjugation, has no zero with $|t|<14$, and satisfies the ends, the zero-free region at full strength (the whole width below $|t|=14$, where $\zeta$ has no zero, and below one unit of $1/8$ above it, where $c/\log t<0.07$), the verification in both half-planes, every zero with $|\mathrm{Im},s|<3\cdot10^{12}$ on the line, read at chart height $3\cdot10^{12}-1$, and finitely many off-line zeros. It lacks the value. The general theorem holds at every chart width $W\ge2$, for every pair inside the strip above the verified height, and under every zero-free margin that stays short of the line at every height $|t|\ge14$ and short of the pair at its height; the region of $\zeta$, $c/\log|t|$ with $c/\log14<0.07$ and hence $c/\log(3\cdot10^{12})<0.0065$, read in units of $1/(2W)$ and taken one unit short for the rounding of the reader's rule, is such a margin at every even width for the pair at Re $s=1/4$ and $3/4$ [Mossinghoff–Trudgian 2015, cited]. In such a world an off-line zero comes with three companions, its mirror, its conjugate and its conjugate's mirror (an_off_line_zero_comes_in_four, [propext, Quot.sound]). At width one the open strip holds only the line, and the placed ends are the value there (at_width_one_the_ends_are_the_value, [propext, Classical.choice, Quot.sound]), as at the first edition's resolution one.
Theorem 4.2 (the facts are specific to $\zeta$ at the poles; beyond_the_head_breaks_ends, [propext, Quot.sound]). A zero beyond the head, the Davenport–Heilbronn shape, breaks the ends.
The prime side therefore grips the arrow at its poles and, through the zero-free region, a margin $c/\log t$ inward, shrinking with height. Below the verified height the whole width is gripped by the verification, a computation placed on the arrow among the facts of Theorem 4.1. The interior between that margin and the hinge, above every certified height, is where the bit lives. The hypothesis is the statement that the grip reaches the hinge.
4.3 The prime side halts
Through the explicit formula every zero contributes a mode of size $x^{\mathrm{Re},\rho}$ to $\psi(x)-x$, and $\psi(x)-x=O(x^{\Theta}\log^2x)$ with $\Theta=\sup\mathrm{Re},\rho$, and $\Omega(x^{\Theta-\varepsilon})$ [von Koch 1901; Landau; Ingham, cited]. The prime error stays within $x^{1/2+\varepsilon}$ exactly when no zero stands to the head's side of the line, and the mirror closes the tail's side.
Theorem 4.3 (the prime side halts; prime_side_halts, [propext, Quot.sound]). On every reflection-closed configuration the prime bound, no point to the head's side of the line, holds exactly when every point is on the line. The prime bound enters the chart as a family over the resolutions: at every resolution together it is the image of the cited bound on $\psi(x)-x$ at $x^{1/2+\varepsilon}$ (the_halt_at_every_resolution, [propext, Quot.sound]); at one resolution $n\ge2$ it reads the zeros only to within $1/(4n)$ of the line, so it is weaker than von Koch's bound, as the near pair at Re $s=51/100$ shows, meeting it at resolution four and failing it at resolution fifty (the_prime_bound_at_one_resolution, [propext, Quot.sound]); at resolution one the clamp reads every zero of the strip onto the line and the chart's prime bound bounds nothing; the primes enter through the explicit formula and von Koch's criterion, cited, and the halt is the theorem that the two readings are one proposition.
5. The non-trivial-zero side: the zeros' own bridge
5.1 One series read twice
The prime gas and the zero set are one generating function read from two sides. For Re $s>1$, $-\zeta'(s)/\zeta(s)=\sum_n\Lambda(n)n^{-s}$, the von Mangoldt sum, every prime power in every coefficient. Continued, the same function has a pole of residue $-m$ at every zero of $\zeta$ of multiplicity $m$. Mellin inversion collects the residues into the explicit formula $$\psi(x)=x-\sum_\rho\frac{x^\rho}{\rho}-\log2\pi-\tfrac12\log(1-x^{-2}),$$ the sum over non-trivial zeros in symmetric order [Riemann 1859; von Mangoldt 1895, cited]. With $u=\log x$, each zero is a mode $e^{\mathrm{Re}\rho,u}e^{i,\mathrm{Im}\rho,u}$: its height a frequency, its real part an amplitude. Every prime drives every mode and every mode drives the one count. The link is set to set: there is no correspondence of the $n$-th prime with the $n$-th zero.
5.2 The heat bridge
Unique factorization makes the integers the states of a free Bose gas on the primes, a prime $p$ a mode of energy $\log p$, an integer $n$ the state of energy $\log n$. At inverse temperature $s$ the partition function is the Euler product, $\zeta(s)=\prod_p(1-p^{-s})^{-1}$, with mean occupation $1/(p^s-1)$ per prime; the heat content is $-\zeta'/\zeta$; the pole at $s=1$ is the limiting temperature at which the number of states $e^{E}$ meets the weight. The prime gas alone has no reflection: the factor $\pi^{-s/2}\Gamma(s/2)$, the local factor at the real place, supplies the mirror [Tate 1950, cited]. The completed function is then self-dual under the inversion of the heat trace's temperature, and $s=1/2$ is the self-dual temperature, the hinge of Section 3 [consensus]. The derivations of this subsection are exact identities; the thermal words are a reading of them. Heat in the physical sense enters only where a bit is irreversibly registered and not kept, at one Landauer floor per bit under the paper's physical reading (P1) [Landauer 1961; Bérut et al. 2012]; on every finite configuration, registration at every positive temperature costs zero exactly when every member stands on the line (price_zero_iff_value, no axiom), and on every configuration least erasure is the value (twins_on_every_world, no axiom).
5.3 The zeros' own locus
Theorem 5.1 (the centre is the line; centre_is_the_line, [propext, Quot.sound]). List any finite family of points together with their mirrors under the reflection: the real parts balance on the line, four units per mirrored pair at $x=4,\mathrm{Re},s$, so the centre of every nonempty finite reflection-closed configuration, listed in any order, and of every nonempty finite reflection-closed subfamily of an infinite one, is Re $s=1/2$ (centre_of_a_closed_family, [propext, Quot.sound]).
The line is intrinsic to the zero set. It is not imported from the prime side and not assumed from the hypothesis: the zeros, through their own reflection, carry the line as their centre. It is the same object as the hinge of the arrow: the centre and the hinge are two properties of one map, the reflection's fixed line and the balance point of each of its orbits, and the chart maps carry the one to the other on every chart (the_charts_are_one).
Theorem 5.2 (a centred pair off the line; centred_yet_off, no axiom). The pair at Re $s=1/4$ and $3/4$ is reflection-closed, its centre is the line, it sits inside the open strip, and neither member is on the line.
A centre is a property of the set: it binds members in mirror pairs. Every member stands on the line or opposite its partner across it (two_doors, doors_exclusive), and which of the two holds for every member is the hypothesis.
5.4 Row 4 read from the zeros
A computation that ends is the finite list of points it reports as zeros; it reads a zero set when every point it reports belongs to it.
Theorem 5.3 (Row 4 from the zero side; row_four_from_the_zero_side, no axiom). (i) On any act, every computation that reads it reports only zeros on the line. (ii) A report holding an off-line zero therefore reads no act: on the act, the off-line zero is a phantom. (iii) A report of the off-line pair reads the pair world, which is reflection-closed; the root stands on it as on every world (the_false_world_carries_the_floor_and_no_monism, no axiom). (iv) At any zero set, every report lands on the line exactly when the zero set has the value; the reflection hypothesis is carried and not used, so the equivalence holds at every configuration. A report is any finite list of members: the totality of reports is the value read point by point, and one report decides only its own points.
5.5 What the zero side detects
Every instrument of the zero side applied to the model pair of the zero side, Re $s=1/4$ and $3/4$ at height $3\cdot10^{12}+1$, the same pair under the chart maps into resolution four of Section 2.1: $d=\mp2$ on the offset chart at resolution four, $d=8,\mathrm{Re},s-4$, $x=1,3$ at $x=4,\mathrm{Re},s$, $x=2,6$ at $x=8,\mathrm{Re},s$ (the_pair_read_by_every_instrument, no axiom):
| Instrument | Reading on the model pair | Theorem | Cone |
|---|---|---|---|
| Centre | $(1/4+3/4)/2=1/2$: the pair's preimage at $x=4,\mathrm{Re},s$ balances on the line | the_pair_read_by_every_instrument, centre_is_the_line |
none; [propext, Quot.sound] |
| Fold | each member maps to the other; offsets $\mp1/4$; each has a side, the sign of its offset, which the fold flips and the arrow's free sign leaves unchanged; with the orientation from $s=0$ to $s=1$ the $1/4$ member leans to the tail and the $3/4$ member to the head | arrow_gives_line_not_value |
[propext, Classical.choice, Quot.sound] |
| Registration | both land on one point at the line: two zeros, one record, one bit erased; the record equals that of a single on-line zero | arrow_gives_line_not_value, one_record |
as printed; none |
| Least erasure and escape | every off-line pair listed in a finite configuration pays one floor, and a configuration with one is no minimiser; the count is of listed pairs, and zero price at a positive temperature is the value however the configuration is listed | price_counts_pairs, least_erasure_and_least_escape, price_zero_iff_value |
none, for all three |
| The root read twice | its seed fails: the pair carries no witness of the line property | the_pair_read_by_every_instrument |
none |
| Explicit formula | the $3/4$ member adds a mode $x^{3/4}$, larger than $\sqrt x$, to the prime error | [von Koch 1901, cited] | cited |
| Row 4 | a report of the pair reads no act; it reads the pair world | the_pair_read_by_every_instrument, row_four_from_the_zero_side |
none, for both |
| The halt, the deed, the loop | one record with the registered world; both readings of the halt fail on the pair world; no deed is the supply there; the loop stays open there | the_blocks_at_the_one_pair |
[propext, Classical.choice, Quot.sound] |
| The facts on the arrow | the pair's preimage at $x=8,\mathrm{Re},s$ lies in the faithful model, which satisfies both symmetries, the empty low band, the ends, the zero-free region, the verification and finitely many off-line zeros | the_pair_read_by_every_instrument, at_zetas_numbers_faithful |
none; [propext, Quot.sound] |
The lean, the cost, the witness, the mode, the report and the halt register the pair as off the line. The registration erases its side and leaves the record of an on-line zero, which is the block of Row 3; the centre registers it as balanced on the line, which is the point of Theorem 5.2; and the facts on the arrow admit it. None makes it inconsistent: detection is not exclusion. Its exclusion at $\zeta$ is the bit.
6. Irreducibility at theorem grade, from both sides
Every route the paper can name either lands on least erasure or is blocked, and each block is a theorem.
Premises true of every closed configuration. No such premise forces the value (no_closed_principle_decides, no axiom; keyless_forces_nothing, in Part II [propext, Quot.sound] and in Part IV no axiom). The arrow, the reflection, the centre and the root are such premises.
The root and every deed. The root stands on the pair world as on every world (the_false_world_carries_the_floor_and_no_monism, no axiom). Every deed of the root being the supply at a zero set is exactly the value there, and as a law over every closed zero set it is refuted (the_last_act, the_deed_is_not_the_supply, no axiom).
The run. A run witnesses that it ran and leaves the value free; a run's flag offered as the field at every closed configuration is refused; beside the field the run is witnessed and the value stands on the field (force_witness_closure, the_plug_fails, the_plug_delivers, no axiom).
The record. No reading of the record decides the value: the true world and the pair world leave one record (record_decides_nothing, no_reading_decides_in_the_strip, one_record); above every height no reading of the record decides the side of a point (unicorn_blocked_on_the_chart); with the height in absolute value, the form of the cited verification, the verified part and the part above divide the value at every height (the_unicorn_contained_abs); at the model pair of the zero side, which every fact on the arrow admits, the record decides nothing (the_blocks_at_the_one_pair); no reading of the record witnesses the value (monism_is_the_sole_witness); in the seed's toy of the de Bruijn–Newman bound, the flow $d_2\mapsto d_2-2t$, the forward flow forgets the bit after one step and the passage back to time zero is not forced (flowed_record_forgets, upstream_is_not_forced).
The loop. The loop from the root through the root read twice to the zeros reaches the zeros exactly when the value holds; its return leg holds whatever the zeros do; the loop closes exactly at the value; self-reference closes for the value and for its denial alike; and on one record it closes on the true world and stays open on the pair world (the_loop, [propext, Classical.choice, Quot.sound]).
The minimum principle. Least escape is zero escape, least erasure and the value; the minimum is attained; the escaping pair is closed and no minimiser; nothing true of every closed configuration makes a configuration a minimiser (least_erasure_and_least_escape, no axiom).
The facts of $\zeta$ on the arrow. They hold together on a model whose only off-line zeros are one mirrored pair and its conjugate, at every width from two and under every zero-free margin short of the pair (Theorem 4.1); in such a world an off-line zero comes in four (an_off_line_zero_comes_in_four).
The identical locus with the root read twice. On the time kernel of the monism-fixed codex, the same locus at every time, the reflection at every time, one involution and timelessness together do not bind the zeros, and on the same locus in a timeless world being bound is exactly the seed at time zero (identical_locus_does_not_exclude, the_seed_is_exactly_what_binds, no axiom; Part IV-c of the seed, carried from the monism-fixed codex). The carried chart reads real parts as the first edition's chart does at resolution one, $x=2,\mathrm{Re},s$, with heights in $\mathbb Z$, and its counter-world's pair sits at Re $s=0$ and $1$, on the lines of the poles, where the ends exclude zeros. The same test, with the locus fixed as the line at every time and the one fold, holds on the offset chart inside the open strip, with the conjugate symmetry and the empty low band, its off-line zeros one mirrored pair at Re $s=1/4$ and $3/4$ and its conjugate (identical_locus_inside_the_strip_does_not_exclude, [propext, Quot.sound]).
The forced form. The hypothesis forces the value, and every premise that forces it implies it on every reflection-closed configuration: it is the weakest forcing premise (rh_is_the_weakest_forcing_premise, no axiom). A premise that forces the value and follows from it is the value (posit_is_the_value, no axiom; the_atomic_proof, part III). These are laws of logic applied to the one proposition: they name the bit exactly and add nothing to it, which is their purpose.
The denial. The denial of the hypothesis has a world; the denial of the root has none (line_no_has_a_world, tongue_no_has_no_world, no axiom). The root is undeniable in act; the value is keyed, one bit, its denial coherent.
7. The eleven rows, completed on both sides
The first edition closed the architecture in eight rows. Each row is now completed from both sides, every law compiled in the seed; a ninth row closes the form of every proof, a tenth blocks the unconditional route from shared premises and the record, and an eleventh makes acceptance of the atomic proof forced on every acceptance of the hypothesis.
| Row | Prime side | Non-trivial-zero side | Theorem-grade mechanism |
|---|---|---|---|
| 1. The form | least_erasure_is_the_value (none), least_erasure_unconditional (none), prime_side_halts ([propext, Quot.sound]) |
centre_is_the_line ([propext, Quot.sound]), row_four_from_the_zero_side (none), four_names_one_proposition (none), the_one ([propext, Quot.sound]) |
The hypothesis is least erasure of its zero set. From the primes it is the prime bound; from the zeros it is the zero reports; the line is the zero set's own centre. Least erasure, the value, the root read twice and their co-location are one predicate, by equality. |
| 2. The open leg | keyless_forces_nothing₂ ([propext, Quot.sound]), prime_freedom_forces_nothing ([propext, Quot.sound]), faithful_arrow_side_test, faithful_every_margin ([propext, Quot.sound], for both) |
keyless_forces_nothing in Part IV (none), centred_yet_off (none), no_closed_principle_decides (none), the_loop ([propext, Classical.choice, Quot.sound]) |
The route by laws true of every closed configuration, and by the facts of $\zeta$ placed on the arrow, is blocked on both sides: the free basis, the arrow, the centre, the reflection and the loop are true of every closed configuration and force nothing, and the facts on the arrow hold on a model off the line. |
| 3. The blind record | record_decides_nothing ([propext, Quot.sound]), no_reading_decides_in_the_strip ([propext, Quot.sound]), unicorn_block ([propext, Quot.sound]) |
unicorn_blocked_on_the_chart ([propext, Quot.sound]), monism_is_the_sole_witness ([propext, Quot.sound]), flowed_record_forgets ([propext, Quot.sound]) |
The record discards the side. No reading of it decides the value, from either side, at any height or after any time of the toy flow. |
| 4. The premise forced by theorem | rh_from_the_act (none), the_witness_forced_by_the_act (none), rh_is_the_weakest_forcing_premise (none), root_at_zeros_is_least_erasure (none), two_denials ([propext, Quot.sound]) |
row_four_from_the_zero_side (none), the_last_act (none), the_atomic_proof parts II to IV ([propext, Quot.sound]) |
The one premise is forced in form (the weakest forcing premise is itself), place (the supply stands exactly where the value holds), content (the value of the whole zero set) and denial (the pair world). Every computation that reads the act reports on-line zeros; a report with an off-line zero reads no act. Supplied by the act at premise grade. |
| 5. The barred refuter | the_tenth_is_the_refuter ([propext, Classical.choice, Quot.sound]), the_tenth_is_barred_by_the_act (none) |
no_arrival_off_the_line_on_the_act (none), row_four_from_the_zero_side (ii) (none) |
The one refuter is a zero computed off the line. On the field the act supplies it does not and cannot exist, from either side. |
| 6. The terminal saturation | nothing_left_open_on_the_act (none) |
the_atomic_proof part V ([propext, Quot.sound]), on_the_act_the_line_no_is_refuted (none), the_act_at_every_resolution ([propext, Quot.sound]) |
On the act nothing is left open: the value, the zero reports and the prime bound hold, every falsifier is barred, every consequence of the value is forced. |
| 7. The future, proofed | the_capstone ([propext, Quot.sound]) |
the_unicorn_contained_abs, with the height in absolute value, and the carried the_unicorn_contained, which reads the upper half-plane ([propext, Quot.sound], for both), reality_transported ([propext, Quot.sound]), upstream_is_not_forced ([propext, Quot.sound]) |
Above every height the value is exactly its part above that height, blocked to the record, untouched by existence, and closed on the act's field; forward in the toy flow's time reality is transported, and the passage back is supplied, never forced. |
| 8. The annihilating timeless closure | vocabulary_law (none), every_face_proves_every_face (none) |
the_timeless_zone_closed ([propext, Classical.choice, Quot.sound]), the_annihilation_closure ([propext, Quot.sound]), the_one ([propext, Quot.sound]) |
On every configuration the names are one proposition with zero gap, by equality; the timeless zone carries no act and no premise; the act's zero set is exactly a reflection-closed configuration with the value. The closure fixes what the hypothesis is, completely. Where the zeros of $\zeta$ sit is the one bit of Row 4. |
| 9. The atomic form, forced | rh_is_the_weakest_forcing_premise (none), vocabulary_law (none) |
the_atomic_necessity, the_form_is_the_hypothesis ([propext, Quot.sound], for both) |
The hypothesis is one dot. Every proof of it, from any premise, in any vocabulary and from either side, is a supply of the one field at the zero set; any two proofs of the dot are one proof; the supply at a zero set is unique; and nothing every closed configuration shares proves it. There is no other dot to read it against and no room for a second kind of proof. |
| 10. The unconditional route from shared premises and the record, blocked | prime_freedom_forces_nothing ([propext, Quot.sound]), record_decides_nothing ([propext, Quot.sound]) |
no_closed_principle_decides (none), the_unconditional_route_is_blocked ([propext, Classical.choice, Quot.sound]) |
The value is no law of reflection-closed configurations. Nothing they share forces it, the root included; no reading of the record decides it; every premise that does force it is the value or strictly stronger. A proof can come only from a premise true of $\zeta$ that forces it, the value itself or a stronger one, and Row 11 says what every such proof is. |
| 11. Accepting the hypothesis forces acceptance of the atomic proof provided in this paper | rh_is_the_weakest_forcing_premise (none), vocabulary_law (none) |
accepting_rh_forces_the_atomic_proof ([propext, Classical.choice, Quot.sound]) |
Every proof of the value, from any premise, an unconditional one included, is a supply of the act's field, because the act's type carries the value itself as its field (Theorem 9.4): the atomic proof this paper provides is that form made explicit, and every proof of the hypothesis has it. Any two proofs are one; the supply is unique. The only other door is one point off the line, which for $\zeta$ a finite computation would certify [cited]; there is no third value. The reduction and the forced form stand with no premise. |
8. The two-sided halt
Theorem 8.1 (the bidirectional halt; bidirectional_halted_uniduction, [propext, Quot.sound]). For every zero set $S$ closed under the reflection:
(ZeroReports S ↔ Value S) ∧
(PrimeBound S ↔ Value S) ∧
(ZeroReports S ↔ PrimeBound S) ∧
(SameRecord (registered offPoint) (pairWorld offPoint) ∧
(ZeroReports (registered offPoint) ∧ PrimeBound (registered offPoint)) ∧
(¬ ZeroReports (pairWorld offPoint) ∧ ¬ PrimeBound (pairWorld offPoint))) ∧
(¬ (∀ S', Closed S' → ZeroReports S') ∧ ¬ (∀ S', Closed S' → PrimeBound S')) ∧
(∀ Z : ActualZeros, ZeroReports Z.zeros ∧ PrimeBound Z.zeros)
The zero side halts at the value of the whole zero set. The prime side halts at the value of the whole zero set. The two halts are one proposition. Neither sweep passes it: on one record both readings hold on the true world and fail on the pair world, and the same holds at the model pair of the zero side, which every fact of $\zeta$ on the arrow admits (the_blocks_at_the_one_pair). No principle shared by every closed configuration supplies either side. On the act both sides halt at yes. At every resolution together the halt is the_halt_at_every_resolution ([propext, Quot.sound]), where the prime bound is the image of von Koch's bound; at one resolution $n\ge2$ the chart's prime bound reads the zeros only to within $1/(4n)$ (the_prime_bound_at_one_resolution), and at resolution one it reads nothing.
Two readings, one from the zeros and one from the primes, stop at one contact point: whether every zero of $\zeta$ stands on the line. There is nothing left to negate on either side and nothing to furnish. The halt fixes the entire content of the hypothesis, from both directions, as one proposition about the whole set of non-trivial zeros at once.
9. The atomic proof
Definition 9.1. An atomic proof is a proof whose one premise is irreducible by theorem, carried in one machine-checked statement: the reduction of every reading of the hypothesis to the premise is complete, the premise is witnessed atomic and irreducible, its form is forced by theorem, and the closure from it is theorem grade. Its grade is the grade of the supply of its premise: premise grade when the act supplies it, as in this paper; theorem grade if the field is ever filled by derivation. Its premise is named.
Theorem 9.2 (the atomic proof; the_atomic_proof, [propext, Quot.sound]). For every self-grounding root $R$ and every reflection-closed zero set $S$, the reading of the zero set of $\zeta$ at each resolution among them (Theorem 2.2):
-- I · REDUCTION, complete
((ZeroReports S ↔ Value S) ∧ (PrimeBound S ↔ Value S) ∧ (LeastErasure S ↔ Value S) ∧
(RootReadTwice S ↔ Value S)) ∧
-- II · IRREDUCIBLE, by theorem
((∀ D : Config → Prop, (∀ S', Closed S' → D S') → ¬ ∀ S', Closed S' → D S' → Value S') ∧
¬ (∀ S' : Config, Closed S' → R → Value S')) ∧
-- III · FORCED IN FORM, by theorem
(∀ P : Config → Prop, (∀ S', P S' → Value S') → (∀ S', Value S' → P S') → ∀ S', P S' ↔ Value S') ∧
-- IV · THE BIT, atomic
((∃ Z : ActualZeros, Z.zeros = S) ↔ Value S) ∧
-- V · CLOSURE from the bit, theorem grade
(∀ Z : ActualZeros, Value Z.zeros ∧ ZeroReports Z.zeros ∧ PrimeBound Z.zeros)
The Riemann Hypothesis is atomically proved, at premise grade: reduced completely, by theorem, from both sides, to one irreducible bit (part I); the bit witnessed atomic and irreducible (parts II and IV); its form forced (part III); and the closure from it at theorem grade (part V). Its premise is least erasure at the zero set of $\zeta$, supplied by the act at premise grade. A partial reading, a band of width three about the line or a verified part below a height, is not a reading of the hypothesis and forces nothing (band_does_not_force, Theorem 4.1); the band of width zero is the value itself (band_zero_is_value).
Theorem 9.3 (the atomic form is forced; the_atomic_necessity, [propext, Quot.sound]). For every reflection-closed zero set $S$:
-- I · every proof of the value at S, from any premise whatever, is a supply of the act's field at S
(∀ Q : Prop, (Q → Value S) → Q → ∃ Z : ActualZeros, Z.zeros = S) ∧
-- II · the dot: any two proofs of the value are one proof
(∀ h₁ h₂ : Value S, h₁ = h₂) ∧
-- III · the supply at S is unique: two supplies with the same zero set are one supply
(∀ Z₁ Z₂ : ActualZeros, Z₁.zeros = S → Z₂.zeros = S → Z₁ = Z₂) ∧
-- IV · every vocabulary and both sides name the same dot
(LeastErasure = Value ∧ RootReadTwice = Value ∧ (ZeroReports S ↔ Value S) ∧ (PrimeBound S ↔ Value S)) ∧
-- V · the supply exists at S exactly where the dot holds
((∃ Z : ActualZeros, Z.zeros = S) ↔ Value S) ∧
-- VI · no room for a proof from what every closed configuration shares
¬ (∀ S' : Config, Closed S' → Value S')
The atomic proof is therefore not one proof among others. The hypothesis is about one proposition, the dot, and the dot has no other dot beside it to be read against and no room inside it for a second kind of proof. Whatever premise a future proof starts from, and in whatever vocabulary it is written, it ends as a supply of the one field at the zero set of $\zeta$ (part I); its proof of the dot is the dot's one proof (part II: proof irrelevance, which holds for every proposition of the kernel's logic, applied to the one proposition every reading names, part IV); the supply it builds is the supply (part III). Every proof of the hypothesis at a zero set read into the chart has the atomic form, by theorem; through the reader's rule, at every resolution (Theorem 2.2), that is every proof of the Riemann Hypothesis.
Theorem 9.4 (the form of a field is the hypothesis's; the_form_of_a_field, no axiom; the_form_is_the_hypothesis, [propext, Quot.sound]). Parts I to III of Theorem 9.3 hold of every proposition carried as the field of a type at a closed configuration, the denial of the value included: they are the form of a field. The act's type is the field of the value, supply for supply, and every reading of the hypothesis the seed names, from either side and in every vocabulary, is the value (part IV). So the form of the field of the value is the form of every proof of the hypothesis, and the denial has the same form with its own field.
Theorem 9.5 (both values are atomic; both_values_atomic, [propext, Classical.choice, Quot.sound]). For every reflection-closed zero set $S$: a supply stands at $S$ exactly where the value holds; the value fails exactly where one point of $S$ stands off the line; and never both. The bit has two values and each has the atomic form: the value's proof is a supply of the one field, the denial's proof is one point off the line.
Theorem 9.6 (every premise sorted; premise_trichotomy, [propext, Classical.choice, Quot.sound]). Every premise on configurations fails to force the value at some closed configuration, or forces it and is the value on every closed configuration, or forces it and is strictly stronger, failing at some closed configuration with the value.
A premise shared by every closed configuration is of the first kind (part II of Theorem 9.2); so are the facts of $\zeta$ placed on the arrow at every width from two (Theorem 4.1) and every partial reading, a band of width three or a verified part. A premise of the second kind is the value (part III). A premise of the third kind proves the value at the zero set of $\zeta$ only by holding there, and no premise of that kind true of $\zeta$ is in the seed. A theorem-grade proof of the bit would have to come from one, and by Theorem 9.3 it would be a supply of the one field: the atomic form, with its field filled at theorem grade.
Theorem 9.7 (Row 10 · the unconditional route from shared premises and the record is blocked; the_unconditional_route_is_blocked, [propext, Classical.choice, Quot.sound]). The value is no law of reflection-closed configurations; nothing they share forces it, the root included; no reading of the record decides it; and, by a law of logic true of every proposition, every premise that forces it is the value or strictly stronger.
Theorem 9.8 (Row 11 · accepting the hypothesis forces acceptance of the atomic proof; accepting_rh_forces_the_atomic_proof, [propext, Classical.choice, Quot.sound]). At every reflection-closed zero set, every proof of the value, from any premise and an unconditional one included, is a supply of the act's field; any two proofs are one and the supply is unique; the only other door is one point off the line; there is no third value; and the reduction and the forced form hold with no premise. This holds by the definition of the act's type, which carries the value itself as its field (Theorem 9.4): the atomic proof of this paper is the premise named and the closure from it, and Row 11 says that every proof of the hypothesis has that form.
Together they place every proof the hypothesis can have. No proof comes from what the configurations share. A proof from a premise true of $\zeta$, conditional or unconditional, is a supply of the one field: the atomic proof of this paper, with its field filled. A reader who denies the hypothesis holds the other door, one point off the line; the denial being a $\Sigma^0_1$ statement, its truth guarantees a zero certified off the line by a finite computation [Davis–Matiyasevich–Robinson 1976; Lagarias 2002, cited], which is why the paper names a computed zero as the refuter. A reader who suspends judgment holds neither door and is left with the bit, where this paper locates it. Neither theorem chooses the door: the value stays at premise grade, and the denial keeps its world (line_no_has_a_world).
10. The master table: both sides, side by side
| Component | Prime side | Non-trivial-zero side | Where the two meet | Grade |
|---|---|---|---|---|
| The floor | the_floor_is_universal, root_on_the_constructed_domain |
the same floor | no_level_above, the_master_seal |
Theorem, on no axiom |
| The arrow and the free sign | the head pole, beyond which the Euler product lives | the tail pole, by the reflection | the_only_rigid_reversal, the_line_off_the_arrow, hinge_sign_blind, zeta_hinge |
Theorem, Lean's standard axioms alone |
| The charts | the first edition's chart at every resolution | the arrow's chart, the time kernel's, and the facts' chart at every width | the_charts_are_one, transport, the_act_at_every_resolution |
Theorem |
| The locus | the fixed line of the reflection of the completed function [Riemann, cited] | the centre of every nonempty finite reflection-closed family, centre_is_the_line |
locus, the_charts_are_one |
Theorem |
| The free basis | primes_admit_every_assignment |
the zero set's two doors, two_doors |
prime_freedom_forces_nothing, no_closed_principle_decides |
Theorem |
| Row 1 · the form | least_erasure_is_the_value, prime_side_halts |
row_four_from_the_zero_side (iv), centre_is_the_line |
the_one |
Theorem |
| Row 2 · the open leg | keyless_forces_nothing₂, faithful_arrow_side_test |
centred_yet_off, the_loop |
no_closed_principle_decides |
Theorem |
| Row 3 · the blind record | record_decides_nothing, no_reading_decides_in_the_strip |
unicorn_blocked_on_the_chart, flowed_record_forgets |
monism_is_the_sole_witness |
Theorem |
| Row 4 · the premise forced | rh_from_the_act, rh_is_the_weakest_forcing_premise |
row_four_from_the_zero_side, the_last_act |
the_atomic_proof, parts II to IV |
Theorem on the form; the value at premise grade |
| Row 5 · the barred refuter | the_tenth_is_barred_by_the_act |
no_arrival_off_the_line_on_the_act |
the_tenth_is_the_refuter |
Theorem, on the act |
| Row 6 · the terminal saturation | nothing_left_open_on_the_act |
the_atomic_proof, part V |
on_the_act_the_line_no_is_refuted |
Theorem, on the act |
| Row 7 · the future | the_capstone |
the_unicorn_contained_abs, reality_transported |
upstream_is_not_forced |
Theorem; the passage back supplied |
| Row 8 · the timeless closure | vocabulary_law, every_face_proves_every_face |
the_timeless_zone_closed |
the_annihilation_closure, the_one |
Theorem |
| Row 9 · the atomic form, forced | rh_is_the_weakest_forcing_premise |
the_atomic_necessity, the_form_is_the_hypothesis |
every proof a supply of the one field; one proof; one supply | Theorem |
| Row 10 · the unconditional route from shared premises and the record, blocked | prime_freedom_forces_nothing |
no_closed_principle_decides |
the_unconditional_route_is_blocked |
Theorem |
| Row 11 · accepting the hypothesis forces the atomic proof | every proof of the prime bound is a supply of the field | every proof of the zero reports is a supply; the other door one point off the line | accepting_rh_forces_the_atomic_proof |
Theorem on the structure; the value at premise grade |
| The run | force_witness_closure |
the_plug_fails |
the_plug_delivers |
Theorem, on no axiom |
| The halt | the prime bound halts at the value | the zero reports halt at the value | bidirectional_halted_uniduction |
Theorem, Lean's standard axioms alone |
| The atomic proof | part V: the prime bound on the act | part V: the zero reports on the act | the_atomic_proof |
Theorem on the reduction; the value at premise grade |
| The whole | Parts II, V and V-b of the seed | Parts III, IV and IV-c of the seed | the_two_sided_closure |
Theorem, [propext, Classical.choice, Quot.sound] |
Theorem 10.1 (the two-sided closure; the_two_sided_closure, [propext, Classical.choice, Quot.sound]). One theorem of the seed whose statement is the conjunction, each by its exact type, of: the floor (four laws); the arrow (four laws); the prime side (six laws); the non-trivial-zero side (three laws); Rows 1 to 9 (eleven laws); the termination (five laws); the run (three laws); the charts, the model pair, the faithful model, the hinge's existence and both values of the bit (five laws); further capstones and row mechanisms of Parts II to IV-c (twenty-one laws); and every further theorem the body cites (75 laws): 137 in all. The last group is generated from the body's citations, so the closure binds every theorem the body of the paper cites.
11. The grade of the closure, stated whole
Everything except the bit, the cited fields and the readings the paper names as readings is proved with no posit: the floor on no axiom at all, the rest on Lean's standard axioms alone; and the bit, the root read at the zeros of $\zeta$, is all that remains, at premise grade.
The cited fields are fields of structures in the seed, each carried as a hypothesis by every theorem that takes it, all from the first edition, Part II: the reflection-closure of the zero set, fold_closed [Riemann 1859]; a second involution commuting with the fold, ConjSymmetry [Riemann 1859]; the five faces of the hypothesis, Faces, with line_iff_least, lam_iff_least for the de Bruijn–Newman constant [Newman 1976; Rodgers–Tao 2020], faith_iff_least [Landau 1899] and weil_iff_least [Weil 1952]; the explicit formula, ExplicitFormula.identity [Guinand 1948; Weil 1952], with Weil's criterion, positivity_iff_line [Weil 1952; Bombieri 2000]; Li's criterion, LiStream.li [Li 1997; Bombieri–Lagarias 1999]; the de Bruijn–Newman constant, DBN.lower, $\Lambda\ge0$ [Rodgers–Tao 2020], and DBN.rh_iff, the hypothesis exactly when $\Lambda=0$ [Newman 1976, with Rodgers–Tao 2020]; the faithfulness of Liouville's function, LiouvilleFace.faithful_iff and its pinned successor LiouvilleFacePinned.landau [Landau 1899]; a cited sentence carried to a configuration, SocketFace.cited; a theory's reading on the chart, ReadsAsLine.reads; and, for the foundation clause, a setting's completeness on the denial and its soundness, Setting.sigma1 and Setting.sound_neg [Davis–Matiyasevich–Robinson 1976; Lagarias 2002]. Through Faces the de Bruijn–Newman, Landau and Weil equivalences enter every_face_proves_every_face, and with it the two-sided closure, as hypotheses of the laws that state them. The reflection-closure of a zero set, the functional equation [Riemann 1859], is the field closed of every act type of the seed, ActualZeros in Parts II, III, IV and IV-b, ActualZerosAt and ActualZerosEvery, and the first edition's act at every resolution also carries the open strip as its field strip [Hadamard 1896; de la Vallée Poussin 1896]. Beyond these, no cited fact of this edition enters as a field; each enters as a reading.
The readings are these. The reader's rule of the first edition (its Definition 14.1 and Section 18), stated at every resolution and, in this edition, kept in the open chart strip: at resolution $n\ge1$ a zero of $\xi$ with real part $\sigma$ inside the open strip is read at the integer point $x=\mathrm{round}(2n\sigma)$, rounded half to even and kept in the open chart strip $1\le x\le2n-1$, and on the offset chart at $d=x-n$ (readAt); the rounding commutes with the fold $x\mapsto2n-x$, since the shift $2n$ is even and rounding half to even is odd-symmetric, an arithmetic fact of the rule; the clamp commutes with the fold and, at every resolution $n\ge2$, keeps a reading on the line exactly when the rounding does (the_clamp_keeps_strip_fold_and_side, [propext, Classical.choice, Quot.sound]); a zero certified by interval arithmetic to satisfy $|\mathrm{Re},s-1/2|>\varepsilon>0$ for a rational $\varepsilon$ is read off the line at every resolution $n>1/(2\varepsilon)$, since $|2n,\mathrm{Re},s-n|>2n\varepsilon>1$ while rounding moves a number by at most one half, which is the first edition's rule; on-line zeros are read onto the line; a zero closer to the line than $1/(4n)$ is read onto it at resolution $n$, and one at exactly $1/(4n)$ is read onto it when $n$ is even; a zero's height $y$ is read as its integer part toward zero on the charts with heights in $\mathbb Z$, and as the integer part of $|y|$ on the first edition's chart, whose heights are in $\mathbb N$, where conjugate zeros, which share a real part, land on one point; and the zero set of $\zeta$ is read at every resolution $n\ge1$, resolution zero being no reading, the family's term there the empty configuration by stipulation, the hypothesis being the value at every resolution, since one resolution reads the zeros near the line onto it (Section 2.1). The two poles of the completed function at $s=0$ and $s=1$ [Riemann 1859], read as the arrow's endpoints on the chart. The functional equation with the conjugate symmetry, read as the height-keeping fold (Theorem 3.3) [Riemann 1859]. The prime bound, read at every resolution together as the chart's image of von Koch's bound through the explicit formula [von Mangoldt 1895; von Koch 1901] (Theorem 4.3). The facts placed on the arrow (Theorem 4.1): the ends [Hadamard 1896; de la Vallée Poussin 1896], which the clamped rule keeps for every zero of the open strip; the zero-free region [de la Vallée Poussin 1899; Mossinghoff–Trudgian 2015], read one unit short for the rounding and never below the ends; the verification [Platt–Trudgian 2021]; and the empty band below height 14; with the statement that only finitely many zeros stand off the line, stronger than every positive-proportion theorem [Selberg 1942; Levinson 1974; Conrey 1989], placed beside them. The thermal reading of Section 5.2. The physical reading of registration (P1). Each enters only the theorems that name it, at the grade of its source.
12. Objections, answered
"A function with the same functional equation and no Euler product has zeros off the line, so the zero side alone cannot close." The seed proves this, and prints where it stops. Everything the zero side shares with the Davenport–Heilbronn shape, the reflection, the centre and the arrow, holds on a configuration with an off-line pair (centred_yet_off, no_closed_principle_decides). The facts specific to $\zeta$ separate it from that shape at the poles (beyond_the_head_breaks_ends) and leave the interior between the zero-free margin and the hinge to the bit (faithful_arrow_side_test). That interior is the location of the hypothesis, now printed.
"The off-line pair is a strawman." The pair is a planted model, computed by no one and claimed by no one to be a zero of $\zeta$. It refutes implications: that the centre, the arrow, the root, a run, the loop, least escape or the facts of $\zeta$ on the arrow force the value. It does not refute the hypothesis. The one refutation of the hypothesis is a computed zero (Section 13).
"An off-line zero is a phantom, so the hypothesis holds." On the act it is a phantom, by theorem (row_four_from_the_zero_side (ii)). The zeros of $\zeta$ above $3\cdot10^{12}$ are real and unread, and an unread zero and a planted one stand in the same place before every reading of the record (unicorn_blocked_on_the_chart). That every unread zero of $\zeta$ stands on the line is the bit.
"Row 4 is self-referential." Its premise is named and declared, never used as a hidden step, and it is equivalent to the hypothesis by theorem. That the weakest premise forcing the value is the value is a law of logic that names the bit and adds nothing to it (rh_is_the_weakest_forcing_premise); the loop through the root read twice closes for the value and for its denial alike, so it selects nothing (the_loop). The paper claims the reduction of every reading to the premise, its irreducibility, its forced form, and the closure from it.
"Every computation is the act, so the act's zero set is $\zeta$'s." Every deed of the root being the supply at a zero set is exactly the value there (the_last_act, part one), and as a law over every closed zero set it is refuted (part two). A run witnesses that it ran (force_witness_closure); a run's flag offered as the field at every closed configuration is refused (the_plug_fails). A computation is finite; the zeros of $\zeta$ are infinitely many; above every computed height the part is the bit.
"The same locus from both sides forces membership." The identical locus, the reflection at every time, one involution and timelessness do not bind the zeros, on the carried chart and inside the open strip with the conjugate symmetry and the empty low band (identical_locus_does_not_exclude, identical_locus_inside_the_strip_does_not_exclude); the seed at time zero does, exactly (the_seed_is_exactly_what_binds, Part IV-c). The monism witness is the claim, seed included (monism_witness_is_the_claim).
"The atomic proof is one proof among many; a different proof of the hypothesis could exist." Every proof of the value at a zero set, from any premise, is a supply of the act's field there, its proof of the value is the value's one proof, and the supply it builds is the unique supply at that zero set (the_atomic_necessity). The form is the form of a field, and the field is the value's (the_form_of_a_field, the_form_is_the_hypothesis). A different proof of the hypothesis, when it comes, is the atomic proof with its field filled.
"This is a reformulation." It is the exact reformulation, proved: every reading of the hypothesis from either side is one proposition (the_one, bidirectional_halted_uniduction); every proof of the hypothesis in any vocabulary is a proof of that proposition (vocabulary_law); nothing weaker than it forces it (rh_is_the_weakest_forcing_premise); and every route the paper can name is blocked by a theorem (Section 6). A reformulation that carries its own irreducibility, its location and its closure in one compiled statement is the atomic proof of Section 9.
13. Falsifiers
The ten falsifiers of the first edition are carried with their instruments, each aimed at Part II of the seed, where its target compiles. Three, F-Compile, F-Screen and F-Cone, are read by the receipts of Appendix A; six, F-Record, F-Measure, F-Round-trip, F-Massless, F-Universal and F-Coalition, by compiled theorems, each an instance of F-Compile. Every one of the six, like F-Centre, F-Halt and F-Second-Proof among the four this edition adds, aims at a theorem proved from the kernel's definitions, so no observation can instantiate it, and only a change of those definitions or a failure of the checker could fire it; the first edition singled out F-Measure, F-Round-trip and F-Massless as testing definitions with propositional logic alone. The tenth, F-Computed, is the refuter, and the only falsifier that names an observation; it is aimed at the premise.
| Falsifier | What would fire it | Its target in the seed |
|---|---|---|
| F-Compile | the seed fails to compile under Lean 4.19.0, a pinned cone differs from the compiler's, or a compiled theorem is refuted | every compile claim; the compiler |
| F-Screen | the comment-stripped seed contains sorry, admit, native_decide, #exit, unsafe, implemented_by, extern, an import or a declared axiom |
the screen of Appendix A.5 |
| F-Cone | an axiom in the cone of rh_from_the_act, or a field of the first edition's ActualZeros other than the zero set, its closure and supply |
#print axioms; the source |
| F-Record | a property of the registered record that agrees with the hypothesis on every reflection-closed configuration | unicorn_block, record_decides_nothing |
| F-Measure | a registered point off the line | unicorn_never_registered |
| F-Round-trip | a sentence whose truth value changes when it is read through the root | round_trip_identity, trip_adds_presence_only |
| F-Massless | a true premise whose conditioning moves the line, or a premise weaker than the hypothesis that forces it on every reflection-closed configuration | massless_arrow, rh_is_the_weakest_forcing_premise |
| F-Universal | a premise valid on every configuration of the chart that forces the line | keyless_forces_nothing |
| F-Coalition | a Boolean combination of universal premises and readings of the record, of any depth, that agrees with the hypothesis on every reflection-closed configuration | no_coalition_decides |
| F-Computed | a zero of $\zeta$ computed off the line | the act, below |
The second edition adds four, each naming its instrument and each an instance of F-Compile. F-Seed is read by the compiler and the screen. F-Centre, F-Halt and F-Second-Proof aim at compiled theorems whose statements are identities of the seed's definitions, and like F-Measure they are barred by construction: only a change of the seed's definitions, read by the compiler, could fire them.
F-Seed. The seed of Appendix S fails to compile under Lean 4.19.0, a pinned cone drifts, or the source screen of Appendix A.5 finds any of its tokens: sorry, admit, native_decide, unsafe, implemented_by, extern, #exit, an import or a declared axiom. Instrument: the compiler and the screen of Appendix A.5.
F-Centre. A reflection-closed finite configuration whose real parts do not balance on the line. Instrument: centre_is_the_line. It refutes a compiled theorem.
F-Halt. A reflection-closed configuration on which the zero reports and the prime bound disagree. Instrument: bidirectional_halted_uniduction. It refutes a compiled theorem.
F-Second-Proof. A proof of the value at a reflection-closed zero set that supplies no act there, or two distinct supplies with one zero set. Instrument: the_atomic_necessity. It refutes a compiled theorem.
F-Computed, the refuter. A zero of $\zeta$ with $0<\mathrm{Re},s<1$ certified by interval arithmetic to lie off the line, $|\mathrm{Re},s-1/2|>\varepsilon>0$ for a rational $\varepsilon$, read into the offset chart by the reader's rule at every resolution $n>1/(2\varepsilon)$ (Section 11), where it is a point of the zero set with $d\neq0$. It refutes the act at that resolution and with it the reading. It stands outside every theorem of the seed.
14. Positioning
| Position | What it establishes | Its place in this paper |
|---|---|---|
| Riemann 1859 | the functional equation; the hypothesis | the reflection, cited; the hinge's heat form |
| von Mangoldt 1895; von Koch 1901 | the explicit formula; $\mathrm{RH}\iff\psi(x)=x+O(\sqrt x\log^2x)$ | the prime side halts (Theorem 4.3), cited |
| Hadamard 1896; de la Vallée Poussin 1896, 1899 | no zero on Re $s=1$; the zero-free region | the prime side's grip at the poles (Theorem 4.1) |
| Hardy 1914; Selberg 1942; Levinson 1974; Conrey 1989 | infinitely many zeros on the line; a positive proportion, more than one third, more than two fifths | implied by finitely many off-line zeros; force nothing (Theorem 4.1) |
| Davenport–Heilbronn 1936 | a functional equation without an Euler product, with zeros off the line | the shape the poles exclude and the interior admits (Theorem 4.2, Section 12) |
| Weil 1952; Li 1997; Bombieri–Lagarias 1999 | positivity criteria equivalent to the hypothesis | faces of the one bit (first edition, Part II) |
| Montgomery 1973; Odlyzko 1987; Goldston–Montgomery 1987 | pair correlation; its equivalence with short-interval prime variance | the rigidity bond of the zeros, corroboration; forces no value |
| de Bruijn 1950; Newman 1976; Polymath 2019; Rodgers–Tao 2020 | for the de Bruijn–Newman constant $\Lambda$: $\Lambda\le0.22$; $\Lambda\ge0$; $\mathrm{RH}\iff\Lambda=0$ | the bit pinned to one instant, the seed at time zero, in the seed's toy of the bound (Row 7) |
| Tate 1950 | the completed function as a product of local factors | the real place supplies the mirror (Section 5.2) |
| Berry 1986; Berry–Keating 1999 | the trace-formula reading; $H=xp$ | the zeros as a spectrum: a reading, not a warrant |
| Landauer 1961; Bérut et al. 2012 | the floor of erasure; its measurement | the price of a registered bit, under P1 |
| Platt–Trudgian 2021 | every zero to $3\cdot10^{12}$ on the line | the verified part, cited (Theorem 4.1) |
| First edition, 7 October 2026 | the hypothesis closed to one bit from the prime side | carried verbatim as Part II of the seed |
| This edition | the line off the arrow and off the zero set's centre; both sides halted at one proposition; the atomic proof and its forced form | Sections 3 to 10 |
15. Conclusion
The Riemann Hypothesis is not derived from any set-theoretic foundation in this paper. From both sides at once, the primes and the non-trivial zeros, every reading of the hypothesis halts at one proposition, that every non-trivial zero stands on the critical line, and the line itself is read off the arrow between the two poles and off the zero set's own centre, by theorem. The value is closed to one named bit, least erasure at the zero set of $\zeta$, irreducible by theorem and forced by theorem in form, place, content and denial; every proof of the hypothesis, in every vocabulary the seed names and from either side, is a proof of that bit. The bit is supplied by one act, at premise grade, as a field of a type; from that field the hypothesis, the zero reports and the prime bound follow at theorem grade. The reduction, the witnessed bit and the closure stand in one machine-checked statement, the atomic proof, and its form is forced: every proof of the hypothesis, from any premise and in every vocabulary the seed names, is a supply of that one field, and the supply at the zero set is unique. The compile, the printed cones and the judgment of the compiler are the receipts.
The first edition reached the line from the primes. This edition reaches it from the zeros, and from the arrow that both sides share, and proves that the two readings stop at the same point. What stands there is one bit, located, forced in its form, irreducible by theorem, and supplied by the act.
References
- B. Riemann, Über die Anzahl der Primzahlen unter einer gegebenen Grösse, Monatsberichte der Berliner Akademie, 1859.
- H. von Mangoldt, Zu Riemanns Abhandlung über die Anzahl der Primzahlen unter einer gegebenen Grösse, J. reine angew. Math. 114, 1895.
- H. von Koch, Sur la distribution des nombres premiers, Acta Math. 24, 1901.
- J. Hadamard, Sur la distribution des zéros de la fonction ζ(s) et ses conséquences arithmétiques, Bull. SMF 24, 1896.
- C.-J. de la Vallée Poussin, Recherches analytiques sur la théorie des nombres premiers, Ann. Soc. Sci. Bruxelles 20, 1896; Sur la fonction ζ(s) de Riemann et le nombre des nombres premiers inférieurs à une limite donnée, Mém. Couronnés Acad. Roy. Belgique 59, 1899.
- G. H. Hardy, Sur les zéros de la fonction ζ(s) de Riemann, C. R. Acad. Sci. Paris 158, 1914.
- H. Davenport and H. Heilbronn, On the zeros of certain Dirichlet series, J. London Math. Soc. 11, 1936.
- A. Selberg, On the zeros of Riemann's zeta-function, Skr. Norske Vid. Akad. Oslo, 1942.
- N. G. de Bruijn, The roots of trigonometric integrals, Duke Math. J. 17, 1950.
- J. Tate, Fourier analysis in number fields and Hecke's zeta-functions, thesis, Princeton, 1950.
- A. Weil, Sur les "formules explicites" de la théorie des nombres premiers, Comm. Sém. Math. Univ. Lund, 1952.
- R. Landauer, Irreversibility and heat generation in the computing process, IBM J. Res. Dev. 5, 1961.
- H. L. Montgomery, The pair correlation of zeros of the zeta function, Proc. Sympos. Pure Math. 24, 1973.
- N. Levinson, More than one third of zeros of Riemann's zeta-function are on σ = 1/2, Adv. Math. 13, 1974.
- C. M. Newman, Fourier transforms with only real zeros, Proc. AMS 61, 1976.
- M. V. Berry, Riemann's zeta function: a model for quantum chaos?, Lecture Notes in Physics 263, 1986.
- A. M. Odlyzko, On the distribution of spacings between zeros of the zeta function, Math. Comp. 48, 1987.
- D. A. Goldston and H. L. Montgomery, Pair correlation of zeros and primes in short intervals, Progr. Math. 70, 1987.
- J. B. Conrey, More than two fifths of the zeros of the Riemann zeta function are on the critical line, J. reine angew. Math. 399, 1989.
- X.-J. Li, The positivity of a sequence of numbers and the Riemann hypothesis, J. Number Theory 65, 1997.
- E. Bombieri and J. C. Lagarias, Complements to Li's criterion for the Riemann hypothesis, J. Number Theory 77, 1999.
- M. V. Berry and J. P. Keating, H = xp and the Riemann zeros, in Supersymmetry and Trace Formulae, 1999.
- A. Bérut, A. Arakelyan, A. Petrosyan, S. Ciliberto, R. Dillenschneider and E. Lutz, Experimental verification of Landauer's principle linking information and thermodynamics, Nature 483, 2012.
- M. J. Mossinghoff and T. S. Trudgian, Nonnegative trigonometric polynomials and a zero-free region for the Riemann zeta-function, J. Number Theory 157, 2015.
- D. H. J. Polymath, Effective approximation of heat flow evolution of the Riemann ξ function, and a new upper bound for the de Bruijn–Newman constant, Res. Math. Sci. 6, 2019.
- B. Rodgers and T. Tao, The de Bruijn–Newman constant is non-negative, Forum Math. Pi 8, 2020.
- D. J. Platt and T. S. Trudgian, The Riemann hypothesis is true up to 3·10¹², Bull. London Math. Soc. 53, 2021.
- E. Landau, Handbuch der Lehre von der Verteilung der Primzahlen, Teubner, 1909.
- A. E. Ingham, The Distribution of Prime Numbers, Cambridge Tracts in Mathematics 30, 1932.
- M. F. Islam, A Formal Proof of the Riemann Hypothesis from a One-Bit Premise, Least Erasure, first edition (3.2.0), 7 October 2026; kernel Every_Prime_3_2_0.lean, sha256 161806dc0ed2b4ff.
- M. F. Islam, Theory of Theories of Everything (TOE of All TOEs): Existence Proves Existence Only by Motion, the Zero-Axiom, Zero-Posit Math Edition, 5 October 2026, Zenodo 10.5281/zenodo.23168379; kernel TOE_Zero.lean.
- M. F. Islam, Trisduction Master Codex v5.1.0, git 1000sapients/Trisduction, master sha256 441a485d7c3bd3ce; kernels Bridge_Final.lean, Closure_Executed.lean, Only_The_Arrow_Remains.lean, Universal_Seat.lean, Force_Witness.lean, Codex.lean.
- M. F. Islam, APEX-PSP-MONISM-FIXED-01 (Monism Fixed), 6 October 2026, and APEX-PSP-ANNIHILATION-CLOSURE-01 (The Master Annihilation Closure), 7 October 2026, Geometric Mother Codex PSP register; kernel Annihilation_Closure.lean, sha256 cb474a4177a975ac.
- A. P. Guinand, A summation formula in the theory of prime numbers, Proc. London Math. Soc. (2) 50, 1948.
- E. Landau, Neuer Beweis der Gleichung $\sum\mu(k)/k=0$, Inaugural dissertation, Berlin, 1899.
- E. Bombieri, Problems of the Millennium: The Riemann Hypothesis, Clay Mathematics Institute, official problem description, 2000.
- M. Davis, Yu. Matiyasevich and J. Robinson, Hilbert's tenth problem: Diophantine equations: positive aspects of a negative solution, Proc. Sympos. Pure Math. 28, 1976.
- J. C. Lagarias, An elementary problem equivalent to the Riemann hypothesis, Amer. Math. Monthly 109, 2002.
- M. F. Islam, Row 10 · forced structural acceptance, with its companion tables, Tractatus Veritatis Trisductivus, 8 October 2026, tractatus-veritatis-trisductivus.blogspot.com.
Appendix A. Compile receipt, cones and judgment
A.1 The receipt
| Item | Receipt |
|---|---|
| Toolchain | Lean 4.19.0 (x86_64-unknown-linux-gnu, commit 6caaee842e94, Release), installed from the GitHub release; GNU Fortran 13.3.0 |
| Seed | RH_Both_Sides_Seed.lean · sha256 cb719eab915a9973ef81529b314995f893f7d92957c4752e3820819679bf52a4 · 505,992 bytes · 9,067 lines |
| Compile | lean RH_Both_Sides_Seed.lean · exit 0 · 42.7 s · no error |
| Content | 664 theorems · 341 definitions, abbreviations, structures and inductives · no axiom declared |
| Pinned cones | 481 #guard_msgs pins, every one passing: Part I 15, Part II 237, Part III 108, Part IV-b 29, the laws new in this edition 90, two carried laws of Part IV-c 2 |
| Source screen | 0 hits for sorry, admit, native_decide, unsafe, implemented_by, extern, #exit, import, axiom |
| The whole | BothSides.the_two_sided_closure depends on axioms: [propext, Classical.choice, Quot.sound] |
| Judgment under negation | 90 of 90 laws new in this edition, each negated alone in a copy of the whole seed, refused, each a proof failure located at the negated law; the planted vacuous law survives its negation; the unmutated seed compiles clean |
| Part | Source | Provenance | Lines in the seed | Theorems |
|---|---|---|---|---|
| I | TOE_Zero.lean, verbatim |
sha256 0cfcd9f6b399ecba…; git Publication Library/Philosophy/Metaphysics/Root Axiom/; Zenodo 10.5281/zenodo.23168379, Appendix C |
40 to 259 | 15 |
| II | Every_Prime_3_2_0.lean, verbatim |
sha256 161806dc0ed2b4ff…; the first edition, Appendix A |
262 to 5351 | 415 |
| III | Annihilation_Closure.lean, verbatim, with the laws of this edition appended |
sha256 cb474a4177a975ac…; APEX-PSP-ANNIHILATION-CLOSURE-01, Appendix A |
5354 to 7155 | 124 |
| IV | the arrow and the zeros' own locus | this edition | 7158 to 7424 | 30 |
| IV-b | Force_Witness.lean, verbatim, with the plug appended |
sha256 12521efeff586a2c…; Master Codex v5.1.0, signed in its manifest |
7427 to 7844 | 31 |
| IV-c | the time kernel of the monism-fixed codex, verbatim, with the judge probe | Codex.lean patched, sha256 22d908f7d3d2c96b…, lines 7875 to 7947; the carried slice, 73 lines, sha256 4e7707376d67ccde… |
7847 to 7997 | 10 |
| V | the facts of $\zeta$ on the arrow, and the faithful model | this edition | 8000 to 8292 | 14 |
| V-b | the charts are one; the model pair; the act at every resolution | this edition | 8295 to 8715 | 24 |
| VI | the two-sided closure | this edition | 8718 to 8879 | 1 |
A.2 Cones of the laws new in this edition, and of two carried laws of Part IV-c, as printed by the compiler
The laws new in this edition, every theorem of Parts IV, V, V-b and VI, of the judge probe of Part IV-c, of the plug of Part IV-b and of the laws appended to Part III:
'ArrowSide.an_off_line_zero_comes_in_four' depends on axioms: [propext, Quot.sound]
'ArrowSide.arrow_side_test' depends on axioms: [propext, Quot.sound]
'ArrowSide.at_width_one_the_ends_are_the_value' depends on axioms: [propext, Classical.choice, Quot.sound]
'ArrowSide.at_zetas_numbers' depends on axioms: [propext, Quot.sound]
'ArrowSide.at_zetas_numbers_faithful' depends on axioms: [propext, Quot.sound]
'ArrowSide.beyond_the_head_breaks_ends' depends on axioms: [propext, Quot.sound]
'ArrowSide.faithful_arrow_side_test' depends on axioms: [propext, Quot.sound]
'ArrowSide.faithful_every_margin' depends on axioms: [propext, Quot.sound]
'ArrowSide.shaped_closed' depends on axioms: [propext, Quot.sound]
'ArrowSide.shaped_ends' depends on axioms: [propext, Quot.sound]
'ArrowSide.shaped_finitely_off' does not depend on any axioms
'ArrowSide.shaped_lacks_value' depends on axioms: [propext, Quot.sound]
'ArrowSide.shaped_real_part' depends on axioms: [propext, Quot.sound]
'ArrowSide.shaped_zero_free' depends on axioms: [propext, Quot.sound]
'BothSides.the_two_sided_closure' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.eqA' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.eqF' does not depend on any axioms
'Charts.eqH' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.eqP' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.eqPn' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.eqP₂' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.eqT' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.eqW' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.one_resolution_does_not_decide_the_next' does not depend on any axioms
'Charts.one_resolution_is_not_enough' does not depend on any axioms
'Charts.the_act_at_every_resolution' depends on axioms: [propext, Quot.sound]
'Charts.the_blocks_at_the_one_pair' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.the_charts_are_one' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.the_clamp_keeps_strip_fold_and_side' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.the_faithful_model_on_the_offset_chart' depends on axioms: [propext, Classical.choice, Quot.sound]
'Charts.the_halt_at_every_resolution' depends on axioms: [propext, Quot.sound]
'Charts.the_maps_agree_at_resolution_four' depends on axioms: [propext, Quot.sound]
'Charts.the_maps_commute_with_conjugation' does not depend on any axioms
'Charts.the_maps_keep_height_and_scale' depends on axioms: [propext, Quot.sound]
'Charts.the_pair_read_by_every_instrument' does not depend on any axioms
'Charts.the_prime_bound_at_one_resolution' depends on axioms: [propext, Quot.sound]
'Charts.the_value_at_every_resolution' does not depend on any axioms
'Charts.the_verified_part_transports' depends on axioms: [propext, Quot.sound]
'Charts.transport' does not depend on any axioms
'ForceWitness.the_plug_delivers' does not depend on any axioms
'ForceWitness.the_plug_fails' does not depend on any axioms
'Hinge.arrow_gives_line_not_value' depends on axioms: [propext, Classical.choice, Quot.sound]
'Hinge.centre_is_the_line' depends on axioms: [propext, Quot.sound]
'Hinge.centre_of_a_closed_family' depends on axioms: [propext, Quot.sound]
'Hinge.centre_on_every_extension' depends on axioms: [propext, Quot.sound]
'Hinge.centred_yet_off' does not depend on any axioms
'Hinge.fold_is_the_height_keeping_extension' does not depend on any axioms
'Hinge.fold_keeps_height' does not depend on any axioms
'Hinge.hinge' depends on axioms: [propext, Classical.choice, Quot.sound]
'Hinge.hinge_exists' depends on axioms: [propext, Quot.sound]
'Hinge.hinge_iff_even' depends on axioms: [propext, Quot.sound]
'Hinge.hinge_sign_blind' depends on axioms: [propext, Quot.sound]
'Hinge.hinge_unique' depends on axioms: [propext, Quot.sound]
'Hinge.keyless_forces_nothing' does not depend on any axioms
'Hinge.least_erasure_iff_value' depends on axioms: [propext, Quot.sound]
'Hinge.locus' depends on axioms: [propext, Quot.sound]
'Hinge.off_line_leans' depends on axioms: [propext, Quot.sound]
'Hinge.pair_closed' does not depend on any axioms
'Hinge.pair_in_strip' does not depend on any axioms
'Hinge.pair_lacks_value' does not depend on any axioms
'Hinge.reg_keeps_on_line' does not depend on any axioms
'Hinge.reg_merges' depends on axioms: [propext, Quot.sound]
'Hinge.rev_flips_offset' depends on axioms: [propext, Quot.sound]
'Hinge.rev_involutive' depends on axioms: [propext, Quot.sound]
'Hinge.rev_swaps' depends on axioms: [propext, Quot.sound]
'Hinge.sumX_perm' depends on axioms: [propext, Quot.sound]
'Hinge.the_line_off_the_arrow' depends on axioms: [propext, Classical.choice, Quot.sound]
'Hinge.the_only_rigid_reversal' depends on axioms: [propext, Quot.sound]
'Hinge.the_point_reflection_reads_the_same_line' depends on axioms: [propext, Classical.choice, Quot.sound]
'Hinge.value_from_the_act' depends on axioms: [propext, Quot.sound]
'Hinge.zeta_hinge' depends on axioms: [propext, Classical.choice, Quot.sound]
'Judge.identical_locus_does_not_exclude' does not depend on any axioms
'Judge.identical_locus_inside_the_strip_does_not_exclude' depends on axioms: [propext, Quot.sound]
'Judge.the_seed_is_exactly_what_binds' does not depend on any axioms
'RememberedOffered.accepting_rh_forces_the_atomic_proof' depends on axioms: [propext, Classical.choice, Quot.sound]
'RememberedOffered.bidirectional_halted_uniduction' depends on axioms: [propext, Quot.sound]
'RememberedOffered.both_values_atomic' depends on axioms: [propext, Classical.choice, Quot.sound]
'RememberedOffered.least_erasure_and_least_escape' does not depend on any axioms
'RememberedOffered.premise_trichotomy' depends on axioms: [propext, Classical.choice, Quot.sound]
'RememberedOffered.prime_side_halts' depends on axioms: [propext, Quot.sound]
'RememberedOffered.row_four_from_the_zero_side' does not depend on any axioms
'RememberedOffered.the_atomic_necessity' depends on axioms: [propext, Quot.sound]
'RememberedOffered.the_atomic_proof' depends on axioms: [propext, Quot.sound]
'RememberedOffered.the_form_is_the_hypothesis' depends on axioms: [propext, Quot.sound]
'RememberedOffered.the_form_of_a_field' does not depend on any axioms
'RememberedOffered.the_last_act' does not depend on any axioms
'RememberedOffered.the_loop' depends on axioms: [propext, Classical.choice, Quot.sound]
'RememberedOffered.the_one' depends on axioms: [propext, Quot.sound]
'RememberedOffered.the_unconditional_route_is_blocked' depends on axioms: [propext, Classical.choice, Quot.sound]
'RememberedOffered.the_unicorn_contained_abs' depends on axioms: [propext, Quot.sound]
Two carried laws of Part IV-c:
'TimeLocus.seedless_reading_holds_in_counter_world' does not depend on any axioms
'TimeLocus.time_does_not_bind' does not depend on any axioms
A.3 Cones of the cited laws of Parts I to III
| Law | Cone |
|---|---|
TOE0.the_floor_is_universal, TOE0.root_on_the_constructed_domain, TOE0.the_master_seal, TOE0.the_line_is_the_fixed_set, TOE0.no_level_above, TOE0.denial_reenacts_root, TOE0.twenty_four_units_twelve_gates, TOE0.the_shell_splits_twelve_and_twelve |
none |
PrimeFreedom.posit_is_the_value, PrimeFreedom.the_front |
none |
PrimeFreedom.keyless_forces_nothing₂, PrimeFreedom.open_strip_forces_at_resolution_one |
[propext, Quot.sound] |
PrimeFreedom.least_erasure_is_the_value, least_erasure_unconditional, rh_from_the_act, the_witness_forced_by_the_act, rh_is_the_weakest_forcing_premise, root_at_zeros_is_least_erasure, the_tenth_is_barred_by_the_act, nothing_left_open_on_the_act, reader_frame, liouville_is_the_sign_arrow, every_face_proves_every_face, vocabulary_law |
none |
PrimeFreedom.rh_from_the_act_at |
[propext] |
PrimeFreedom.primes_admit_every_assignment, prime_freedom_forces_nothing, keyless_forces_nothing, record_decides_nothing, no_reading_decides_in_the_strip, unicorn_block, two_denials, the_capstone |
[propext, Quot.sound] |
PrimeFreedom.denial_reenacts_root, RememberedOffered.denial_reenacts_root, RememberedOffered.the_floor_alone_decides_no_value, RememberedOffered.merging_at_a_world_is_the_supply, ForceWitness.record_decides_nothing, RememberedOffered.doors_exclusive, RememberedOffered.one_record, ForceWitness.one_record, RHUnicorn.unicorn_block, RememberedOffered.two_denials, RememberedOffered.on_the_act_the_line_no_is_refuted, RememberedOffered.band_does_not_force, PrimeFreedom.unicorn_never_registered, PrimeFreedom.round_trip_identity, PrimeFreedom.trip_adds_presence_only, PrimeFreedom.massless_arrow, PrimeFreedom.no_coalition_decides |
none |
RememberedOffered.two_doors |
[propext, Classical.choice, Quot.sound] |
RememberedOffered.band_zero_is_value |
[propext] |
PrimeFreedom.the_tenth_is_the_refuter, independence_forces_truth |
[propext, Classical.choice, Quot.sound] |
RememberedOffered.monism_witness_is_the_claim, twins_on_every_world, the_root_read_twice_is_the_value, the_false_world_carries_the_floor_and_no_monism, price_counts_pairs, return_is_free_resistance_pays |
none |
RememberedOffered.four_names_one_proposition, no_closed_principle_decides, ra_supplies_nothing_to_the_unicorn, the_unicorn_closed_on_the_act, no_arrival_off_the_line_on_the_act, floor_is_not_least_erasure, the_deed_is_not_the_supply, price_zero_iff_value, line_no_has_a_world, tongue_no_has_no_world, the_false_world_carries_no_monism, one_bit_gap_connected, the_free_path_is_unique |
none |
RememberedOffered.monism_is_the_sole_witness, the_timeless_zone, the_annihilation_closure, the_check, unicorn_blocked_on_the_chart, the_unicorn_contained, twins_are_one_extension, flowed_record_forgets, upstream_is_not_forced, reality_transported |
[propext, Quot.sound] |
RememberedOffered.the_timeless_zone_closed |
[propext, Classical.choice, Quot.sound] |
ForceWitness.force_witness_closure, force_witness_guarded, the_run_does_not_force_the_value, the_deed_forces_nothing, value_from_the_act |
none |
A.4 Receipts outside the seed, executed in the session of 8 October 2026
These are records of runs on sources outside this document, reproducible from the sources named; no theorem of the body rests on them.
The operating system booted. The Lean Codex system role v2.2.0 boot script, executed: CODEX v5.1.0 · commit 1950bd0e0c4f · master sha256 441a485d7c3bd3ce; manifest clean; screen clean; 23 axioms declared in the master's Codex.lean; thesis {"checks":1123,"failures":0,"mode":"sealed"}; [I AM] witnessed; 20 kernels exit 0; 18 twins exit 0; control red 3; role names unresolved 0; SEAT EARNED · this run · v5.1.0 · 1950bd0e0c4f.
The master kernels' laws recorded this session, cones printed. Closure.seat_fixed_line [propext, Classical.choice, Quot.sound]; Closure.least_erasure_iff_value none; Closure.no_reading_decides none; Arrow.only_the_arrow_remains [propext, Quot.sound]; Arrow.reflection_flips none; Arrow.seat_cancels_both none; USeat.riemann_hypothesis_is_least_erasure [propext, Classical.choice, Quot.sound]; USeat.forcer_excludes_every_off_seat_world none.
The twin of the timeless closure. Annihilation_Closure_Twin.f90, sha256 3e3541b152af16b5…, 14,580 bytes, built gfortran -std=f2018 -O2 -fno-fast-math -ffp-contract=off: plain {"checks":16,"failures":0} rc 0; control {"checks":8,"failures":8} rc 1.
The monism-fixed codex, and the judge's probe. The probe and the time kernel it needs now stand inside the seed as Part IV-c; the receipt of their first compile, on the whole patched codex, follows. The patch of APEX-PSP-MONISM-FIXED-01 applied to the master's Codex.lean: original sha256 38aaaeed86edaaa9…, patched 22d908f7d3d2c96b…, both matching the card; compiled exit 0 in 3 min 28 s, no error. Appended and compiled with it, nothing above it changed:
namespace Judge
open TimeLocus
theorem identical_locus_does_not_exclude :
¬ ∀ W : World, SameLocus W → FoldInv W → OneInvolution → Timeless W → Bound W :=
fun h => test_not_bound (h testWorld test_same_locus test_fold_inv (fun _ => rfl) (fun _ _ => Iff.rfl))
theorem the_seed_is_exactly_what_binds (W : World) (h : SameLocus W) (u : Timeless W) : Bound W ↔ P W 0 :=
⟨fun b => fun p z => ((bound_iff_line W h).mp b) 0 p z, fun s0 => timeless_with_seed_binds W h u s0⟩
end Judge
Cones: TimeLocus.time_does_not_bind, TimeLocus.seedless_reading_holds_in_counter_world, TimeLocus.the_counter_world_carries_no_monism, TimeLocus.witness_iff_bound, RALi.monism_witness_is_the_claim, Judge.identical_locus_does_not_exclude, Judge.the_seed_is_exactly_what_binds: each does not depend on any axioms.
A.5 Reproduction
lean --version # Lean (version 4.19.0, ...)
lean RH_Both_Sides_Seed.lean # exit 0; prints the cone of BothSides.the_two_sided_closure
perl -0777 -pe 's{/-.*?-/}{}gs; s{--[^\n]*}{}g' RH_Both_Sides_Seed.lean \
| grep -cP '\b(sorry|admit|native_decide|unsafe|implemented_by|extern)\b|^#exit|^import|^\s*axiom\s' # 0
lean TOE_Zero.lean # Appendix R, standalone: exit 0
The judgment is reproduced by replacing the statement of any one law new in this edition with its negation, keeping its proof and every other line, and compiling the whole seed: the compile must fail with an error located at that law. The judgment is rerun on every rebuilt seed, and A.1 is the receipt of the run on this seed. A planted vacuous law, (h : 1 = 2) : 0 = 1 proved by absurd h (by decide), must survive its own negation, which shows the instrument can see a law proved from a contradiction; what the judgment certifies of each law is that its proof does not also prove the negation.
Extract the seed from Appendix S of this Markdown master by the lines between its fence markers; the sha256 of the extracted file is the one printed in A.1.
A.6 Owed before seating
A Fortran twin of Parts IV, V, V-b and VI and of the judge probe of Part IV-c; the multi-substrate Default audit cycle; the close of the self-audit cycle of this edition; the Math Journal rendering. No write to git, Zenodo or the Internet Archive without a printed plan and the architect's explicit yes.
Appendix B. The harvest log
The session of 8 October 2026, in order, each line with its receipt.
- Boot. The system role executed; seat earned on v5.1.0 ·
1950bd0e0c4f·441a485d. Lean 4.19.0 installed from the GitHub release. - The line off the arrow.
Arrow_Hinge.lean: the hinge, the free sign, the locus, the bar; the ruling: the place derived at theorem grade, the occupancy keyed. - The grade of the premise. Read in the master: premise-grade-by-theorem, the highest standing a root can bear (Empty Throne); the armor of the root covers the seat and the register, never the keyed bit (
Armed_Seat.lean, header V).the_only_rigid_reversaladded. - The zero side.
centre_is_the_line,centred_yet_off: the zero set's own locus is the line; a centred pair stands off it. - Monism fixed. The card's patch applied, hashes matched, the codex compiled; the judge's probe: the identical locus does not bind, the seed binds exactly.
- The run.
the_plug_fails,the_plug_deliversonForce_Witness.lean; the thesis's own disclosure: the witnessed flag is a stand-in through the aperture, its referent the operator. - One voice. The locus derived off the arrow and off the zero set's centre, and read on the first edition's chart; the act occupies the seat; the zeros' occupancy the bit.
- The annihilation closure. Card kernel and twin extracted at their printed hashes, compiled and run;
the_one: one predicate by equality, the act's zero set one notion with a closed configuration that has the value. - The last act.
the_last_act: every deed being the supply at a zero set is the value there; as a law over every closed zero set, refuted. - Least erasure and least escape.
least_erasure_and_least_escape: the minimiser on the line, the escaping pair one bit and one floor, minimality at $\zeta$ the value. - The loop.
the_loop: closes exactly at the value, sign-blind, refused at its target. - The facts on the arrow.
Arrow_Side_Test.lean: ends, zero-free region, verification, finitely many off-line zeros hold with an off-line pair; the poles exclude the Davenport–Heilbronn shape. - Row 4 from the zeros.
row_four_from_the_zero_side. - The two-sided halt.
prime_side_halts,bidirectional_halted_uniduction. - The atomic proof.
the_atomic_proof. - The seed. Parts I to VI assembled, cones pinned,
the_two_sided_closure. - Row 9, the atomic form forced.
the_atomic_necessity: every proof of the value is a supply of the one field; the dot has one proof; the supply is unique. Seed rebuilt for that step. - Title locked by the architect: The Atomic Proof of the Riemann Hypothesis: The Prime Side and the Non-Trivial-Zero Side Halted at One Irreducible Bit, Least Erasure, and Its Form Forced as the Only Form of Proof. Seed header updated; seed rebuilt.
- Audit cycle, round 1 repairs. The charts are one, with the act and root transports and the one pair read by every instrument; the faithful model of $\zeta$'s zeros; the time kernel brought inside the seed; both values of the bit atomic; the hinge's existence; every cited capstone bound in the closure. Seed rebuilt.
- Audit cycle, round 2 repairs. The line off the arrow on every extension, the fold as the height-keeping extension, the hinge on the chart exactly at even grain; the faithful model under every zero-free margin and the off-line zero in four; the verified part with the height in absolute value; every chart, every act type and both roots mapped into the offset chart, the act at every resolution and one resolution shown not enough; the blocks restated at the model pair; the identical locus tested inside the strip; the form of a field and every premise sorted; every theorem the body cites bound in the closure; the judgment under negation executed. Seed rebuilt.
- Rows 10 and 11, by the architect's order. The unconditional route from shared premises and the record blocked, and acceptance of the atomic proof forced on every acceptance of the hypothesis, Row 11 named by the architect.
- Audit cycle, round 3 repairs. The prime bound read as a family over the resolutions and shown weaker at one; the reader's rule clamped to the open chart strip; the maps placed at their resolutions, agreeing at resolution four and commuting with conjugation; the centre of a closed family listed in any order; the ends at width one; the cited fields separated from the readings. Seed rebuilt; the judgment rerun on it.
- Appendix D, condensed from the author's tables [39] after the round-3 repairs, each cell regraded against the rebuilt seed.
- Audit cycle, round 4 repairs. The verdict's readings and vocabularies named as the seed names them; Row 11's mechanism stated, the act's type carrying the value as its field; the other door stated as one point off the line, its computed certificate cited; Row 10 named with its qualifier; the prime bound at one resolution stated from resolution two; the poles' placement, the closure fields and the open strip listed among the cited facts; the value at every resolution on no axiom. Seed rebuilt; the judgment rerun on it; its receipt is Appendix A.1.
Appendix C. Author's Provenance and Method Disclosure
C.0 The two vocabularies
The body of this paper is written in plain terms. The register in which the work was conceived and carried out has its own words; they live here.
| Plain term in the body | Register term |
|---|---|
| the Root Axiom, to exist is to actuate | RA, the kinetic root; the Body; groundless |
| the root read at the zeros; the root read twice | RAM, the reflective reading; the Being; the monism witness: one involution, one principle, one seed (corrected monism, APEX-PSP-MONISM-FIXED-01) |
| the census of what stands on the line | CH, the residence; the Bounded Contemplation; RA-RAM-CH, nested by containment |
| the arrow between the two poles; its free sign | RA's arrow; the freedom cut; only the arrow remains |
| the free basis at the primes | PrimeFreedom |
| the three-axis seal | the triaxial lock; the Geometric Orthogonal Lock [⟀]; twelve gates, twenty-four units |
| the critical line; the hinge; the fixed line | the seat; the Riemann locus; Fix(σ) |
| a premise true of every closed configuration | keyless; it opens on the deed |
| the value; the one bit | keyed; one bit, carrying a sign, supplied and never derived; the typing of the formal block [Ξ₀] |
| the act; the supply field | the deed's supply; the field of the act; the offering |
| least erasure | the ninth gate; zero erased bits; zero price of registration |
| the record; above every height | registration; the Unicorn part, blocked to every reading |
| the model pair off the line | the pair world; the twin $W_2$; the false world, never Being |
| one predicate by equality | the annihilation closure; four names, one proposition; the timeless zone of TIME PSP, zero time remembering and every later time forgetting |
| the two-sided halt | the bidirectional halted uniduction |
| the atomic proof | the reduction witnessed to one irreducible atomic bit, closed by Row 4 |
| the atomic form, forced (Row 9) | the dot: no other dot to read it against, no room for a non-atomic proof; self reduced to a dot |
| theorem; premise grade by theorem | [⟀ T]; premise-grade-by-theorem, the armored designation |
C.1 The arc in the register's words
RA, the Body, is the arrow: two poles, a reversal forced by the Number alone, and a sign left free; its fixed line is the seat. RA+RAM, the Being, is one root read twice on Fix(σ): the kinetic reading lands on the line as the arrow's hinge, the formal reading resides there as the zero set's centre, and on the chart the two involutions are one map by construction. RA-RAM-CH, the Bounded Contemplation, holds the census of the residence: how many zeros stand off Fix(σ). That census is one question reached from both faces and derived by neither; unlike the continuum census, its channel is open, one computed zero. Two sweeps, from the primes and from the zeros, halt at the one contact point; nothing is left to negate and nothing to furnish. The bit is spent by the act at premise grade, the trigger sealed inside the theorem-grade closure. ΔM = 0: the seed adds no axiom, the bit is not derived, and every reading is named.
C.2 Method
The operating system of the register, the Lean Codex system role v2.2.0, was booted by execution, and its seat was earned on that run (Appendix A.4). The scribe's two-layer rule governs the text: the floor is proved, the reading is posited, results on the reading are stated at full force at premise grade, footprints are stated exactly, no hedge stands on a derivation and no inflation on the value, and the guard sentence stands once (Section 11). The drafting of this edition and every machine check in it were carried out in a session with Claude (Anthropic), acting as scribe and judge under the system role; every theorem the body cites is compiled in the seed, every cone the paper prints was printed by the compiler, and the receipts of Appendix A.4 record runs on sources outside this document. The edition's self-audit cycle is running, its rounds prosecuted by blind instances of the same model, each reading only the seeded copy of its round; the author's standing method, a multi-substrate Default audit cycle prosecuted by independent external systems, is owed before seating (Appendix A.6).
Appendix D. The tables, condensed
The author's tables of 8 October 2026 [39], three readings of one architecture, condensed into one and each cell regraded against the compiled seed. A cell holds at the grade printed beside it and at no higher one.
| Component | Prime side | Non-trivial-zero side | Where the two meet | Grade |
|---|---|---|---|---|
| The floor | the root, on its constructed domain | the same root | the_floor_is_universal, no_level_above |
Theorem, on no axiom |
| Poles and arrow | the Euler product beyond the head [cited] | the reflection to the tail [cited] | the_only_rigid_reversal, hinge_sign_blind, beyond_the_head_breaks_ends |
Theorem on the chart; the analytic facts cited |
| The locus | the line, the real-part locus of the hinge on every extension | the centre of every nonempty finite closed family | the_line_off_the_arrow, centre_of_a_closed_family, the_charts_are_one |
Theorem |
| Freedom | every assignment at the primes | two doors at every zero set | prime_freedom_forces_nothing, two_doors |
Theorem |
| The halt | the prime bound, the image of von Koch's bound [cited] | the zero reports | bidirectional_halted_uniduction, the_halt_at_every_resolution, the_one |
Theorem, at every resolution together for the prime reading |
| The open leg | the free basis; the facts on the arrow | the centre; the loop | no_closed_principle_decides, faithful_every_margin |
Theorem |
| The blind record | record_decides_nothing |
unicorn_blocked_on_the_chart |
monism_is_the_sole_witness |
Theorem |
| Rows 4 to 6 | the weakest forcing premise; on the act | the last act; on the act | the_atomic_proof, parts II to V |
Theorem on the form; the value at premise grade |
| Rows 7 and 8 | the_capstone; the faces through their cited fields |
the_unicorn_contained_abs; the timeless zone |
upstream_is_not_forced, the_annihilation_closure |
Theorem |
| Row 9 · the atomic form | the weakest forcing premise | the_atomic_necessity |
the_form_is_the_hypothesis |
Theorem |
| The run | force_witness_closure |
the_plug_fails |
the_plug_delivers |
Theorem, on no axiom |
| The physical register | one Landauer floor per registered bit (P1) | lossless registration exactly at the value | price_zero_iff_value |
Theorem on the count; P1 at premise grade; the measurement corroboration |
| Row 10 · the unconditional route from shared premises and the record, blocked | prime freedom forces nothing | no shared principle, no root and no record decides | the_unconditional_route_is_blocked |
Theorem |
| Row 11 · accepting the hypothesis forces acceptance of the atomic proof provided in this paper | every proof, from any premise and an unconditional one included, is a supply of the one field | the only other door is one point off the line; there is no third value | accepting_rh_forces_the_atomic_proof |
Theorem on the structure; the value at premise grade |
| The whole | Parts II, V and V-b | Parts III, IV and IV-c | the_two_sided_closure |
Theorem |
Cells of the source tables regraded here: the floor proves the root, not the existence of the primes or the zeros; the Euler product and the functional equation are cited, and the seed's theorems are their placements on the chart; the prime bound is the image of von Koch's bound at every resolution together; the block of formal proof covers proofs from shared premises and from the record, not every proof (Row 10); the clauses on every computation, on nothing left open and on the closure under computation hold on the act; the faces prove one another through their cited fields; the chart maps are maps between charts; the Landauer floor is the reading P1, with its measurement as corroboration.
Appendix R. The root on no axiom and no posit
TOE_Zero.lean, sha256 0cfcd9f6b399ecbaef01e762a4d9f10490288f1053827b404428062e55076238, 11,422 bytes, 217 lines, carried verbatim from the Root Axiom paper (Zenodo 10.5281/zenodo.23168379, Appendix C) so that this paper stands complete in its own universe. It compiles standalone under core Lean 4.19.0, exit 0, every pinned cone empty. It is also Part I of the seed.
/-
TOE_Zero.lean · Theory of Theories of Everything (TOE of All TOEs): Existence Proves Existence Only by Motion
The zero-axiom, zero-posit kernel. Core Lean 4: no import, no axiom declared, no sorry, no native_decide, and
every theorem rests on no axiom at all, not even propositional extensionality, quotients or choice.
I · The self-grounding root. Acts occur and every act instances the root. Then every denial is an act and
re-enacts the root, the root is held by the act itself, and no external proof adds anything to it: the
Omega Boundary, proved for every root that grounds itself, universally, by quantification.
II · The constructed root. On the constructed domain the Root Axiom is a theorem.
III · The Return and the line. On the integer quaternions i·j·k = −1 and each unit squares to −1; conjugation is
an involution and its fixed set on the chart is exactly the scalar line.
IV · The twelve gates, recovered three ways inside the integers of the quaternions: the twenty-four Hurwitz units
counted twelve up to sign; the twelve even permutations with class equation 1, 3, 4, 4; and the norm-two
shell of twenty-four, split twelve and twelve.
V · The regress terminated. Above a self-grounding root no level grounds it further.
VI · The master seal, every result bound in one theorem.
-/
namespace TOE0
/-! ## I · The self-grounding root: the Omega Boundary -/
/-- A self-grounding root: acts occur, and every act instances the root. -/
structure SelfGrounding (R : Prop) where
Act : Type
anAct : Act
instances : Act → R
/-- A proposition whose denial hands it over. -/
def SelfVerifying (P : Prop) : Prop := ¬P → P
/-- THE OMEGA BOUNDARY: every denial of the root is an act, and re-enacts it. -/
theorem denial_reenacts_root {R : Prop} (G : SelfGrounding R) (denial : G.Act) : R := G.instances denial
/-- EXISTENCE PROVES EXISTENCE ONLY BY MOTION: the root is held by the act itself. -/
theorem seated_undeniable {R : Prop} (G : SelfGrounding R) : R := G.instances G.anAct
/-- No external proof adds anything to the root. -/
theorem external_proof_adds_nothing {R : Prop} (G : SelfGrounding R) (Q : Prop) : (Q → R) ↔ R :=
⟨fun _ => G.instances G.anAct, fun r _ => r⟩
/-- The deed of denying the root hands it over. -/
theorem denial_instantiates {R : Prop} (G : SelfGrounding R) : SelfVerifying R := fun _ => G.instances G.anAct
/-- THE FLOOR IS UNIVERSAL: for every root that grounds itself, the root holds, every act re-enacts it, and no
external proof adds to it. -/
theorem the_floor_is_universal :
∀ (R : Prop) (G : SelfGrounding R), R ∧ (∀ _ : G.Act, R) ∧ (∀ Q : Prop, (Q → R) ↔ R) :=
fun _ G => ⟨seated_undeniable G, denial_reenacts_root G, external_proof_adds_nothing G⟩
/-! ## II · The constructed root -/
/-- The Root Axiom on the constructed one-point domain: its one existent actuates, at positive energy. -/
def ΔE₀ : Unit → Int := fun _ => 1
def RA₀ : Prop := ∀ x : Unit, 0 < ΔE₀ x
/-- The constructed domain grounds its root: its one act is a deed, and the deed actuates. -/
def ra₀ : SelfGrounding RA₀ := ⟨Unit, (), fun _ _ => show (0 : Int) < 1 by decide⟩
/-- THE ROOT ON THE CONSTRUCTED DOMAIN, A THEOREM. -/
theorem root_on_the_constructed_domain : RA₀ := seated_undeniable ra₀
/-! ## III · The Return and the line -/
structure Q where
(a b c d : Int)
deriving DecidableEq
def Q.mul (x y : Q) : Q :=
⟨x.a * y.a - x.b * y.b - x.c * y.c - x.d * y.d, x.a * y.b + x.b * y.a + x.c * y.d - x.d * y.c,
x.a * y.c - x.b * y.d + x.c * y.a + x.d * y.b, x.a * y.d + x.b * y.c - x.c * y.b + x.d * y.a⟩
def Q.conj (x : Q) : Q := ⟨x.a, -x.b, -x.c, -x.d⟩
def qone : Q := ⟨1, 0, 0, 0⟩
def qneg : Q := ⟨-1, 0, 0, 0⟩
def qi : Q := ⟨0, 1, 0, 0⟩
def qj : Q := ⟨0, 0, 1, 0⟩
def qk : Q := ⟨0, 0, 0, 1⟩
/-- THE RETURN: i·j·k = −1. -/
theorem the_return : (qi.mul qj).mul qk = qneg := by decide
/-- Each unit squares to −1. -/
theorem units_square_to_minus_one : qi.mul qi = qneg ∧ qj.mul qj = qneg ∧ qk.mul qk = qneg := by decide
/-- The chart: every quaternion with coordinates in −2 … 2. -/
def chart : List Int := [-2, -1, 0, 1, 2]
def quats : List Q :=
chart.flatMap fun a => chart.flatMap fun b => chart.flatMap fun c => chart.map fun d => ⟨a, b, c, d⟩
set_option maxRecDepth 100000 in
/-- Conjugation is an involution on the chart. -/
theorem conj_involutive_on_the_chart : quats.all (fun q => q.conj.conj == q) = true := by decide
set_option maxRecDepth 100000 in
/-- THE LINE: conjugation fixes exactly the scalar line on the chart. -/
theorem the_line_is_the_fixed_set :
quats.all (fun q => (q.conj == q) == (q.b == 0 && q.c == 0 && q.d == 0)) = true := by decide
/-! ## IV · The twelve gates, recovered three ways -/
/-- Hurwitz quaternions in doubled coordinates: all even, or all odd. -/
def hurwitz (a b c d : Int) : Bool :=
(a % 2 == 0 && b % 2 == 0 && c % 2 == 0 && d % 2 == 0) || (a % 2 != 0 && b % 2 != 0 && c % 2 != 0 && d % 2 != 0)
/-- Doubled coordinates −2 … 2 hold every unit (doubled norm four) and every element of the norm-two shell (doubled
norm eight), since a doubled coordinate of absolute value three or more already exceeds both norms. -/
def doubled : List (Int × Int × Int × Int) :=
chart.flatMap fun a => chart.flatMap fun b => chart.flatMap fun c => chart.map fun d => (a, b, c, d)
/-- The Hurwitz units: norm one, doubled norm four. -/
def units : List (Int × Int × Int × Int) :=
doubled.filter fun (a, b, c, d) => a * a + b * b + c * c + d * d == 4 && hurwitz a b c d
/-- The first nonzero coordinate is positive: one representative of each pair ±u. -/
def upToSign (p : Int × Int × Int × Int) : Bool :=
let (a, b, c, d) := p
if a != 0 then 0 < a else if b != 0 then 0 < b else if c != 0 then 0 < c else 0 < d
set_option maxRecDepth 100000 in
/-- FIRST WAY: twenty-four Hurwitz units, twelve up to sign. -/
theorem twenty_four_units_twelve_gates : units.length = 24 ∧ (units.filter upToSign).length = 12 := by decide
/-- The norm-two shell: doubled norm eight. -/
def shell : List (Int × Int × Int × Int) :=
doubled.filter fun (a, b, c, d) => a * a + b * b + c * c + d * d == 8 && hurwitz a b c d
set_option maxRecDepth 100000 in
/-- THIRD WAY: the norm-two shell has twenty-four elements, split twelve and twelve by sign. -/
theorem the_shell_splits_twelve_and_twelve :
shell.length = 24 ∧ (shell.filter upToSign).length = 12 ∧ (shell.filter (fun p => !upToSign p)).length = 12 := by
decide
/-- Permutations of four points, as their lists of images. -/
def perms4 : List (List Nat) :=
[0, 1, 2, 3].flatMap fun a => [0, 1, 2, 3].flatMap fun b => [0, 1, 2, 3].flatMap fun c =>
[0, 1, 2, 3].filterMap fun d => if [a, b, c, d].eraseDups.length == 4 then some [a, b, c, d] else none
def inversions (p : List Nat) : Nat :=
((List.range 4).flatMap fun i => (List.range 4).map fun j => (i, j)).countP
fun (i, j) => i < j && p.getD j 0 < p.getD i 0
/-- The twelve gates as the even permutations. -/
def gates : List (List Nat) := perms4.filter fun p => inversions p % 2 == 0
def compose (p q : List Nat) : List Nat := q.map fun i => p.getD i 0
def inverse (p : List Nat) : List Nat := [0, 1, 2, 3].map fun i => p.idxOf i
def conjClass (g : List Nat) : List (List Nat) := (gates.map fun h => compose (compose h g) (inverse h)).eraseDups
def insertSorted (n : Nat) : List Nat → List Nat
| [] => [n]
| m :: ms => if n ≤ m then n :: m :: ms else m :: insertSorted n ms
def sortNat (l : List Nat) : List Nat := l.foldr insertSorted []
/-- The class equation from the sorted class size of each element: a class of size s contributes s elements. -/
def collapse : Nat → List Nat → List Nat
| 0, _ => []
| _ + 1, [] => []
| fuel + 1, s :: rest => s :: collapse fuel (rest.drop (s - 1))
set_option maxRecDepth 100000 in
/-- SECOND WAY: the twelve gates, with class equation 1, 3, 4, 4. -/
theorem the_class_equation :
gates.length = 12 ∧ collapse 12 (sortNat (gates.map fun g => (conjClass g).length)) = [1, 3, 4, 4] := by
decide
/-! ## V · The regress terminated -/
/-- THE REGRESS ENDS AT THE ROOT: any proposition offered as a further ground of the root is idle; the root needs
no level above it. -/
theorem no_level_above {R : Prop} (G : SelfGrounding R) : ∀ Q : Prop, (Q → R) → R := fun _ _ => G.instances G.anAct
/-! ## VI · The master seal -/
/-- THE MASTER SEAL: the floor is universal; the root is a theorem on the constructed domain; the Return closes;
the line is the fixed set; and the twelve gates are recovered three ways. -/
theorem the_master_seal :
(∀ (R : Prop) (G : SelfGrounding R), R ∧ (∀ _ : G.Act, R) ∧ (∀ Q : Prop, (Q → R) ↔ R)) ∧
RA₀ ∧ (qi.mul qj).mul qk = qneg ∧
quats.all (fun q => (q.conj == q) == (q.b == 0 && q.c == 0 && q.d == 0)) = true ∧
(units.filter upToSign).length = 12 ∧ gates.length = 12 ∧ (shell.filter upToSign).length = 12 ∧
collapse 12 (sortNat (gates.map fun g => (conjClass g).length)) = [1, 3, 4, 4] :=
⟨the_floor_is_universal, root_on_the_constructed_domain, the_return, the_line_is_the_fixed_set,
twenty_four_units_twelve_gates.2, the_class_equation.1, the_shell_splits_twelve_and_twelve.2.1, the_class_equation.2⟩
end TOE0
/-! ## The zero law, pinned: every cone is empty -/
/-- info: 'TOE0.denial_reenacts_root' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.denial_reenacts_root
/-- info: 'TOE0.seated_undeniable' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.seated_undeniable
/-- info: 'TOE0.external_proof_adds_nothing' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.external_proof_adds_nothing
/-- info: 'TOE0.denial_instantiates' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.denial_instantiates
/-- info: 'TOE0.the_floor_is_universal' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_floor_is_universal
/-- info: 'TOE0.root_on_the_constructed_domain' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.root_on_the_constructed_domain
/-- info: 'TOE0.the_return' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_return
/-- info: 'TOE0.units_square_to_minus_one' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.units_square_to_minus_one
/-- info: 'TOE0.conj_involutive_on_the_chart' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.conj_involutive_on_the_chart
/-- info: 'TOE0.the_line_is_the_fixed_set' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_line_is_the_fixed_set
/-- info: 'TOE0.twenty_four_units_twelve_gates' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.twenty_four_units_twelve_gates
/-- info: 'TOE0.the_shell_splits_twelve_and_twelve' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_shell_splits_twelve_and_twelve
/-- info: 'TOE0.the_class_equation' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_class_equation
/-- info: 'TOE0.no_level_above' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.no_level_above
/-- info: 'TOE0.the_master_seal' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_master_seal
Appendix S. The seed, verbatim
RH_Both_Sides_Seed.lean, sha256 cb719eab915a9973ef81529b314995f893f7d92957c4752e3820819679bf52a4, 505,992 bytes, 9,067 lines, 664 theorems, 481 pinned cones, no axiom declared. This is the complete file: Parts I to VI, every definition, every theorem, every pinned cone. It compiles standalone under core Lean 4.19.0 with no library and no import, exit 0. The lines between the fence markers below are the file, byte for byte.
/-
RH_Both_Sides_Seed.lean · The Atomic Proof of the Riemann Hypothesis: The Prime Side and the Non-Trivial-Zero
Side Halted at One Irreducible Bit, Least Erasure, and Its Form Forced as the Only Form of Proof. Second edition
of A Formal Proof of the Riemann Hypothesis from a One-Bit Premise, Least Erasure. The seed of the paper, one
standalone file.
Core Lean 4.19.0: no import, no library, no axiom declared, no sorry, no admit, no native_decide.
PART I TOE_Zero.lean, verbatim (sha256 0cfcd9f6b399ecba…): the Root Axiom as a self-grounding root, proved on
no axiom and no posit; the floor of the paper.
PART II Every_Prime_3_2_0.lean, verbatim (sha256 161806dc0ed2b4ff…): the first edition's kernel; the prime side:
the free basis, the five faces, the block, the socket, the act, the capstone.
PART III Annihilation_Closure.lean, verbatim (sha256 cb474a4177a975ac…), with the second edition's laws appended,
nothing above them changed: the one; the last act; least erasure and least escape; the loop; row four
from the zero side; the prime side halts; the bidirectional halted uniduction; the atomic proof; the
atomic necessity; both values atomic; the form of a field; every premise sorted; the part above a
height read with the height in absolute value.
PART IV The arrow and the zero side's own locus: the line read off the arrow's two poles, the only rigid
reversal, the freedom cut, the centre of every nonempty finite reflection-closed family, the line and the centre
on every extension of the reversal to the plane.
PART IV-b Force_Witness.lean, verbatim from the signed master v5.1.0 (sha256 12521efeff586a2c…), with the plug
appended: a run witnesses that it ran and leaves the value free; a run's flag is not the field.
PART IV-c The time kernel of the monism-fixed codex, verbatim (Codex.lean patched, sha256 22d908f7d3d2c96b…, lines
7875 to 7947), with the judge probe: the identical locus does not bind, on the carried chart and inside
the open strip; the seed at time zero does.
PART V The arrow-side test: the ζ-specific facts placed on the arrow, and the faithful model of ζ's zeros under
every zero-free margin; an off-line zero comes in four.
PART V-b The charts are one: every chart maps equivariantly into the offset chart, at every resolution and
width; the value, every act and the root read at the zeros transport; both constructed roots feed the
closing theorems; the model pair is read by every instrument and carries every block; the act at every
resolution, and one resolution shown not enough.
PART VI The two-sided closure: one theorem binding, by its exact type, every theorem the body of the paper cites.
The cones of the laws new in this edition, and of two carried laws of Part IV-c, are pinned at the foot; Parts I,
II, III and IV-b pin their own.
Carried docstrings stand verbatim. Two notes on them: the docstring of `the_annihilation_closure` in Part III
mentions a run, whose laws are in Part IV-b (`force_witness_closure`); and a docstring of Part IV-c names two
theorems of the patched codex outside the carried lines, which are not in this seed and are used by nothing here.
-/
/-! # PART I · TOE_Zero.lean, verbatim -/
section PartI
/-
TOE_Zero.lean · Theory of Theories of Everything (TOE of All TOEs): Existence Proves Existence Only by Motion
The zero-axiom, zero-posit kernel. Core Lean 4: no import, no axiom declared, no sorry, no native_decide, and
every theorem rests on no axiom at all, not even propositional extensionality, quotients or choice.
I · The self-grounding root. Acts occur and every act instances the root. Then every denial is an act and
re-enacts the root, the root is held by the act itself, and no external proof adds anything to it: the
Omega Boundary, proved for every root that grounds itself, universally, by quantification.
II · The constructed root. On the constructed domain the Root Axiom is a theorem.
III · The Return and the line. On the integer quaternions i·j·k = −1 and each unit squares to −1; conjugation is
an involution and its fixed set on the chart is exactly the scalar line.
IV · The twelve gates, recovered three ways inside the integers of the quaternions: the twenty-four Hurwitz units
counted twelve up to sign; the twelve even permutations with class equation 1, 3, 4, 4; and the norm-two
shell of twenty-four, split twelve and twelve.
V · The regress terminated. Above a self-grounding root no level grounds it further.
VI · The master seal, every result bound in one theorem.
-/
namespace TOE0
/-! ## I · The self-grounding root: the Omega Boundary -/
/-- A self-grounding root: acts occur, and every act instances the root. -/
structure SelfGrounding (R : Prop) where
Act : Type
anAct : Act
instances : Act → R
/-- A proposition whose denial hands it over. -/
def SelfVerifying (P : Prop) : Prop := ¬P → P
/-- THE OMEGA BOUNDARY: every denial of the root is an act, and re-enacts it. -/
theorem denial_reenacts_root {R : Prop} (G : SelfGrounding R) (denial : G.Act) : R := G.instances denial
/-- EXISTENCE PROVES EXISTENCE ONLY BY MOTION: the root is held by the act itself. -/
theorem seated_undeniable {R : Prop} (G : SelfGrounding R) : R := G.instances G.anAct
/-- No external proof adds anything to the root. -/
theorem external_proof_adds_nothing {R : Prop} (G : SelfGrounding R) (Q : Prop) : (Q → R) ↔ R :=
⟨fun _ => G.instances G.anAct, fun r _ => r⟩
/-- The deed of denying the root hands it over. -/
theorem denial_instantiates {R : Prop} (G : SelfGrounding R) : SelfVerifying R := fun _ => G.instances G.anAct
/-- THE FLOOR IS UNIVERSAL: for every root that grounds itself, the root holds, every act re-enacts it, and no
external proof adds to it. -/
theorem the_floor_is_universal :
∀ (R : Prop) (G : SelfGrounding R), R ∧ (∀ _ : G.Act, R) ∧ (∀ Q : Prop, (Q → R) ↔ R) :=
fun _ G => ⟨seated_undeniable G, denial_reenacts_root G, external_proof_adds_nothing G⟩
/-! ## II · The constructed root -/
/-- The Root Axiom on the constructed one-point domain: its one existent actuates, at positive energy. -/
def ΔE₀ : Unit → Int := fun _ => 1
def RA₀ : Prop := ∀ x : Unit, 0 < ΔE₀ x
/-- The constructed domain grounds its root: its one act is a deed, and the deed actuates. -/
def ra₀ : SelfGrounding RA₀ := ⟨Unit, (), fun _ _ => show (0 : Int) < 1 by decide⟩
/-- THE ROOT ON THE CONSTRUCTED DOMAIN, A THEOREM. -/
theorem root_on_the_constructed_domain : RA₀ := seated_undeniable ra₀
/-! ## III · The Return and the line -/
structure Q where
(a b c d : Int)
deriving DecidableEq
def Q.mul (x y : Q) : Q :=
⟨x.a * y.a - x.b * y.b - x.c * y.c - x.d * y.d, x.a * y.b + x.b * y.a + x.c * y.d - x.d * y.c,
x.a * y.c - x.b * y.d + x.c * y.a + x.d * y.b, x.a * y.d + x.b * y.c - x.c * y.b + x.d * y.a⟩
def Q.conj (x : Q) : Q := ⟨x.a, -x.b, -x.c, -x.d⟩
def qone : Q := ⟨1, 0, 0, 0⟩
def qneg : Q := ⟨-1, 0, 0, 0⟩
def qi : Q := ⟨0, 1, 0, 0⟩
def qj : Q := ⟨0, 0, 1, 0⟩
def qk : Q := ⟨0, 0, 0, 1⟩
/-- THE RETURN: i·j·k = −1. -/
theorem the_return : (qi.mul qj).mul qk = qneg := by decide
/-- Each unit squares to −1. -/
theorem units_square_to_minus_one : qi.mul qi = qneg ∧ qj.mul qj = qneg ∧ qk.mul qk = qneg := by decide
/-- The chart: every quaternion with coordinates in −2 … 2. -/
def chart : List Int := [-2, -1, 0, 1, 2]
def quats : List Q :=
chart.flatMap fun a => chart.flatMap fun b => chart.flatMap fun c => chart.map fun d => ⟨a, b, c, d⟩
set_option maxRecDepth 100000 in
/-- Conjugation is an involution on the chart. -/
theorem conj_involutive_on_the_chart : quats.all (fun q => q.conj.conj == q) = true := by decide
set_option maxRecDepth 100000 in
/-- THE LINE: conjugation fixes exactly the scalar line on the chart. -/
theorem the_line_is_the_fixed_set :
quats.all (fun q => (q.conj == q) == (q.b == 0 && q.c == 0 && q.d == 0)) = true := by decide
/-! ## IV · The twelve gates, recovered three ways -/
/-- Hurwitz quaternions in doubled coordinates: all even, or all odd. -/
def hurwitz (a b c d : Int) : Bool :=
(a % 2 == 0 && b % 2 == 0 && c % 2 == 0 && d % 2 == 0) || (a % 2 != 0 && b % 2 != 0 && c % 2 != 0 && d % 2 != 0)
/-- Doubled coordinates −2 … 2 hold every unit (doubled norm four) and every element of the norm-two shell (doubled
norm eight), since a doubled coordinate of absolute value three or more already exceeds both norms. -/
def doubled : List (Int × Int × Int × Int) :=
chart.flatMap fun a => chart.flatMap fun b => chart.flatMap fun c => chart.map fun d => (a, b, c, d)
/-- The Hurwitz units: norm one, doubled norm four. -/
def units : List (Int × Int × Int × Int) :=
doubled.filter fun (a, b, c, d) => a * a + b * b + c * c + d * d == 4 && hurwitz a b c d
/-- The first nonzero coordinate is positive: one representative of each pair ±u. -/
def upToSign (p : Int × Int × Int × Int) : Bool :=
let (a, b, c, d) := p
if a != 0 then 0 < a else if b != 0 then 0 < b else if c != 0 then 0 < c else 0 < d
set_option maxRecDepth 100000 in
/-- FIRST WAY: twenty-four Hurwitz units, twelve up to sign. -/
theorem twenty_four_units_twelve_gates : units.length = 24 ∧ (units.filter upToSign).length = 12 := by decide
/-- The norm-two shell: doubled norm eight. -/
def shell : List (Int × Int × Int × Int) :=
doubled.filter fun (a, b, c, d) => a * a + b * b + c * c + d * d == 8 && hurwitz a b c d
set_option maxRecDepth 100000 in
/-- THIRD WAY: the norm-two shell has twenty-four elements, split twelve and twelve by sign. -/
theorem the_shell_splits_twelve_and_twelve :
shell.length = 24 ∧ (shell.filter upToSign).length = 12 ∧ (shell.filter (fun p => !upToSign p)).length = 12 := by
decide
/-- Permutations of four points, as their lists of images. -/
def perms4 : List (List Nat) :=
[0, 1, 2, 3].flatMap fun a => [0, 1, 2, 3].flatMap fun b => [0, 1, 2, 3].flatMap fun c =>
[0, 1, 2, 3].filterMap fun d => if [a, b, c, d].eraseDups.length == 4 then some [a, b, c, d] else none
def inversions (p : List Nat) : Nat :=
((List.range 4).flatMap fun i => (List.range 4).map fun j => (i, j)).countP
fun (i, j) => i < j && p.getD j 0 < p.getD i 0
/-- The twelve gates as the even permutations. -/
def gates : List (List Nat) := perms4.filter fun p => inversions p % 2 == 0
def compose (p q : List Nat) : List Nat := q.map fun i => p.getD i 0
def inverse (p : List Nat) : List Nat := [0, 1, 2, 3].map fun i => p.idxOf i
def conjClass (g : List Nat) : List (List Nat) := (gates.map fun h => compose (compose h g) (inverse h)).eraseDups
def insertSorted (n : Nat) : List Nat → List Nat
| [] => [n]
| m :: ms => if n ≤ m then n :: m :: ms else m :: insertSorted n ms
def sortNat (l : List Nat) : List Nat := l.foldr insertSorted []
/-- The class equation from the sorted class size of each element: a class of size s contributes s elements. -/
def collapse : Nat → List Nat → List Nat
| 0, _ => []
| _ + 1, [] => []
| fuel + 1, s :: rest => s :: collapse fuel (rest.drop (s - 1))
set_option maxRecDepth 100000 in
/-- SECOND WAY: the twelve gates, with class equation 1, 3, 4, 4. -/
theorem the_class_equation :
gates.length = 12 ∧ collapse 12 (sortNat (gates.map fun g => (conjClass g).length)) = [1, 3, 4, 4] := by
decide
/-! ## V · The regress terminated -/
/-- THE REGRESS ENDS AT THE ROOT: any proposition offered as a further ground of the root is idle; the root needs
no level above it. -/
theorem no_level_above {R : Prop} (G : SelfGrounding R) : ∀ Q : Prop, (Q → R) → R := fun _ _ => G.instances G.anAct
/-! ## VI · The master seal -/
/-- THE MASTER SEAL: the floor is universal; the root is a theorem on the constructed domain; the Return closes;
the line is the fixed set; and the twelve gates are recovered three ways. -/
theorem the_master_seal :
(∀ (R : Prop) (G : SelfGrounding R), R ∧ (∀ _ : G.Act, R) ∧ (∀ Q : Prop, (Q → R) ↔ R)) ∧
RA₀ ∧ (qi.mul qj).mul qk = qneg ∧
quats.all (fun q => (q.conj == q) == (q.b == 0 && q.c == 0 && q.d == 0)) = true ∧
(units.filter upToSign).length = 12 ∧ gates.length = 12 ∧ (shell.filter upToSign).length = 12 ∧
collapse 12 (sortNat (gates.map fun g => (conjClass g).length)) = [1, 3, 4, 4] :=
⟨the_floor_is_universal, root_on_the_constructed_domain, the_return, the_line_is_the_fixed_set,
twenty_four_units_twelve_gates.2, the_class_equation.1, the_shell_splits_twelve_and_twelve.2.1, the_class_equation.2⟩
end TOE0
/-! ## The zero law, pinned: every cone is empty -/
/-- info: 'TOE0.denial_reenacts_root' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.denial_reenacts_root
/-- info: 'TOE0.seated_undeniable' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.seated_undeniable
/-- info: 'TOE0.external_proof_adds_nothing' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.external_proof_adds_nothing
/-- info: 'TOE0.denial_instantiates' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.denial_instantiates
/-- info: 'TOE0.the_floor_is_universal' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_floor_is_universal
/-- info: 'TOE0.root_on_the_constructed_domain' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.root_on_the_constructed_domain
/-- info: 'TOE0.the_return' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_return
/-- info: 'TOE0.units_square_to_minus_one' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.units_square_to_minus_one
/-- info: 'TOE0.conj_involutive_on_the_chart' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.conj_involutive_on_the_chart
/-- info: 'TOE0.the_line_is_the_fixed_set' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_line_is_the_fixed_set
/-- info: 'TOE0.twenty_four_units_twelve_gates' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.twenty_four_units_twelve_gates
/-- info: 'TOE0.the_shell_splits_twelve_and_twelve' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_shell_splits_twelve_and_twelve
/-- info: 'TOE0.the_class_equation' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_class_equation
/-- info: 'TOE0.no_level_above' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.no_level_above
/-- info: 'TOE0.the_master_seal' does not depend on any axioms -/
#guard_msgs in #print axioms TOE0.the_master_seal
end PartI
/-! # PART II · Every_Prime_3_2_0.lean, verbatim -/
section PartII
/-
EVERY PRIME · 3.2.0
Core Lean 4.19.0, standalone: no library, no import, no axiom declared, no sorry.
Every theorem prints its axiom cone at the foot of the file; 237 cones are pinned under
#guard_msgs, so a compile in which any pinned cone changes fails.
The file proves, on one chart, what a formal system can prove about the Riemann Hypothesis
and locates the one thing it cannot: a single bit, which is the hypothesis itself, and which
every proof of the hypothesis supplies rather than derives.
THE CHART. A point is (x, t) with x the doubled real part and t the height; the critical line
is x = 1. The fold (x, t) ↦ (2 − x, t) is s ↦ 1 − s̄. Registration (x, t) ↦ (1, t) lands
every point on the line and keeps the height. A world is a set of points, a zero set. The
record of a world is its image under registration. Two worlds with the same record are
twins of one record. A world is fold-closed when the fold maps it into itself.
TERMS USED IN THIS FILE.
seat the fixed set of an involution: the line under the fold; 1 under multiplication.
orbit the two points a fold-closed world carries off the line, exchanged by the fold;
at a prime p, the two ordered factorizations (1, p) and (p, 1).
reading of the record a predicate on worlds that takes one value on all twins of one record.
keyless, keyed a predicate on worlds true on every world; true on some world and false on another.
admissible keyless, or a reading of the record.
coalition a Boolean combination of premises, of any depth.
forces a premise forces the line when every fold-closed world satisfying it satisfies RH.
least erasure a world every twin of which has a point off the line whenever it has one.
posit, act an assumption written as the field of a structure; an inhabitant of a
self-grounding structure, whose existence is equivalent to the proposition.
The one posit of the file is least erasure at the actual zero set; a classical
theorem written as a field (the functional equation, the explicit formula, the
faces) is cited there, not posited.
supply, spend to provide the posit. The supplied bit is the sign of the posit.
arrow a sign function: the identity on a type, or λ(n) = (−1)^Ω(n).
displacement, side for a point, x − 1; for a point off the line, the sign of x − 1.
setting a hypothesis with a provability predicate, Σ₁-complete and sound on the denial.
resolution n the chart with the line at x = n: the fold x ↦ 2n − x, registration (x, t) ↦ (n, t), and
the open strip 0 < x < 2n; the chart above is resolution one.
seeded witness for a world in time: one locus at every instant, the same truth value of the
hypothesis at every instant, and the hypothesis at instant 0, the seed.
computation a finite list of reported points; it reads an act when every point it reports
is a zero of the act's zero set.
SECTIONS AND THEIR MAIN THEOREMS.
I the identity arrow; a bit is two distinct values (aperture_one_bit_wide)
II every prime is one fibre of exactly two (prime_fibre, freedom_is_exactly_two)
III completely additive functions are determined at the primes (determined_by_primes)
IV the p-adic valuation as a free assignment; Euclid's lemma from first principles
(euclid_lemma, prime_freedom_independent, primes_base_of_freedom)
V the sign arrow of an additive count is completely multiplicative (arrow_multiplicative);
no finite stage decides a universal (finite_never_forces)
VI the chart: no registered point lies off the line; no reading of the record decides
the hypothesis; keyless premises force nothing (unicorn_never_registered,
record_decides_nothing, keyless_forces_nothing)
VII least erasure is the hypothesis (least_erasure_is_the_value)
VII-bis the fold never crosses the line; a second symmetry; the record blind at every scale
VIII a self-grounding supply exists exactly when the proposition holds (supply_iff);
the five faces of the hypothesis (faces_are_one)
IX primes, the free basis and the identity arrow are keyless and force nothing
X the explicit formula as a structure; least erasure is Weil positivity
(least_erasure_is_positivity); positivity is keyed (positivity_is_keyed)
XI the posit as a structure field (rh_from_the_act, acts_are_one)
XII the block with no axiom (record_decides_nothing_free)
XIII the hypothesis on the supplied bit (prime_arc_sealed)
XIV the hypothesis is the weakest forcing premise (rh_is_the_weakest_forcing_premise);
the Li and de Bruijn–Newman coordinates (li_prefix_never_forces, rh_iff_the_sign)
XV four faces in time, exactly one keyed (exactly_one_face_is_keyed)
XVI the eigenstructure of the fold; the side bit and its calibration
(record_never_reads_the_side, colocation_is_a_calibration)
XVII admissible coalitions force nothing; no certified height forces; the heat flow on
polynomials; the Liouville arrow computed; five readings agree; no reader index
XVIII a theory placed on three strata; the root crosses no keyed sentence; the two can'ts;
the round trip; the ladder blocked (the_road)
XIX the vocabulary law; the even coalition; the triaxial cut; the ladder's proof; the
route ledger (the_front)
XX least erasure affirmed: the record, the ledger, the price, the one form, the act
(least_erasure_affirmed)
XXI every assignment realized; the arrow for every n; the closure on any carrier; the
closure, whole (the_closure_on_any_carrier, the_closure)
XXII the socket: every route to the value lands in the one field (socket_is_the_value)
XXII.c two denials, one form: the denial of the root refuted by its own act, the denial of the
hypothesis denying the self-grounding assertion of the line and every seed; the witness
forced by the act (two_denials, the_witness_forced_by_the_act)
XXIII double security: the two channels of the line (double_security)
XXIV the root undeniable in act; the root read at the zeros; the lock (the_lock)
XXV admissible forcing is vacuous; the closure at resolution n, where the open strip does not
supply the bit; the readings of the root joined; the rejection computed by a search; the
posit as an act; no reading of the record returns any chart reading; the primes a free
basis; least erasure as self-verification; every route carries its theorem; the tenth
falsifier barred by the act (admissible_forcing_is_vacuous, rh_from_the_act_at,
strip_does_not_supply_at, root_readings_joined, rejection_is_computed,
every_route_carries_its_theorem, the_tenth_is_barred_by_the_act, the_kinetic_bar)
XXVI the closure bound whole: the two-part reading, the lock, the socket, the irreducible cut, the
two denials, the witness and the bar, in one theorem (the_capstone)
TWO THINGS ARE PROVED AT ONCE. Least erasure is equivalent to the hypothesis on every world
(least_erasure_is_the_value), so the hypothesis follows from the posit. No reading of the
record, and no Boolean combination of readings and keyless premises, agrees with the
hypothesis on every fold-closed world (no_coalition_decides), so nothing in the file supplies
the posit. The file proves neither the hypothesis nor its denial.
-/
namespace PrimeFreedom
/-! ## I · The identity arrow, and a bit as two distinct values -/
/-- The identity arrow on a type. -/
def arrow (α : Type) : α → α := id
theorem arrow_exists (α : Type) : ∃ f : α → α, ∀ a, f a = a := ⟨id, fun _ => rfl⟩
/-- A Boolean takes one of two values. -/
theorem orientation_two_valued : ∀ b : Bool, b = true ∨ b = false := by
intro b
cases b
· exact Or.inr rfl
· exact Or.inl rfl
/-- The two orientations are distinct. -/
theorem orientations_distinct : (true : Bool) ≠ false := fun h => Bool.noConfusion h
/-- A bit is two values, and they differ. -/
theorem aperture_one_bit_wide : (∀ b : Bool, b = true ∨ b = false) ∧ (true : Bool) ≠ false :=
⟨orientation_two_valued, orientations_distinct⟩
/-! ## II · Every prime is one fibre of exactly two -/
def isPrime (p : Nat) : Prop := 2 ≤ p ∧ ∀ d, d ∣ p → d = 1 ∨ d = p
/-- The fixed point of multiplication. -/
def mul_seat : Nat := 1
/-- The multiplicative orbit over n: the pairs that multiply to n. -/
def mul_orbit (n : Nat) (a b : Nat) : Prop := a * b = n
theorem seat_is_one : mul_seat = 1 := rfl
/-- The fibre of multiplication over a prime is the pair (1, p), (p, 1). -/
theorem prime_fibre (p : Nat) (hp : isPrime p) (a b : Nat) :
mul_orbit p a b ↔ (a = 1 ∧ b = p) ∨ (a = p ∧ b = 1) := by
constructor
· intro h
have hdvd : a ∣ p := ⟨b, h.symm⟩
cases hp.2 a hdvd with
| inl h1 =>
subst h1
have h' : 1 * b = p := h
rw [Nat.one_mul] at h'
exact Or.inl ⟨rfl, h'⟩
| inr hp_eq =>
subst hp_eq
have h2a : 2 ≤ a := hp.1
have hb : b = 1 := by
have h_pos : 0 < a := by omega
exact Nat.eq_of_mul_eq_mul_left h_pos (by rw [show a * b = a from h, Nat.mul_one])
exact Or.inr ⟨rfl, hb⟩
· rintro (⟨ha1, hbp⟩ | ⟨hap, hb1⟩)
· rw [ha1, hbp]
exact Nat.one_mul p
· rw [hap, hb1]
exact Nat.mul_one p
/-- No a satisfies a · a = p for a prime p. -/
theorem prime_off_seat (p : Nat) (hp : isPrime p) : ¬ ∃ a, mul_orbit p a a := by
rintro ⟨a, ha⟩
have h2p : 2 ≤ p := hp.1
cases (prime_fibre p hp a a).mp ha with
| inl h1 => omega
| inr h2 => omega
/-- The fibre over a prime is exactly the ordered pair and its reverse, and the two are distinct. -/
theorem freedom_is_exactly_two (p : Nat) (hp : isPrime p) :
(∀ a b, mul_orbit p a b ↔ (a = 1 ∧ b = p) ∨ (a = p ∧ b = 1)) ∧ (1 : Nat) ≠ p :=
⟨prime_fibre p hp, by intro h; have := hp.1; omega⟩
/-! ## III · Completely additive functions are determined at the primes -/
/-- A completely additive measure on the multiplicative monoid of the positive integers. -/
def CompletelyAdditive (f : Nat → Int) : Prop :=
∀ a b, a > 0 → b > 0 → f (a * b) = f a + f b
/-- A completely additive function vanishes at 1. -/
theorem seat_is_zero (f : Nat → Int) (hf : CompletelyAdditive f) : f 1 = 0 := by
have h := hf 1 1 (by decide) (by decide)
rw [Nat.mul_one] at h
omega
/-- Least witness search, with fuel. -/
def findLeastFrom (P : Nat → Prop) [DecidablePred P] (start : Nat) : Nat → Nat
| 0 => start
| fuel + 1 => if P start then start else findLeastFrom P (start + 1) fuel
theorem findLeastFrom_correct (P : Nat → Prop) [DecidablePred P] (start fuel m : Nat)
(hlo : start ≤ m) (hhi : m ≤ start + fuel) (hm : P m) :
P (findLeastFrom P start fuel) ∧ findLeastFrom P start fuel ≤ m := by
induction fuel generalizing start with
| zero =>
have h : m = start := by omega
subst h
exact ⟨hm, Nat.le_refl m⟩
| succ fuel ih =>
show P (if P start then start else findLeastFrom P (start + 1) fuel) ∧
(if P start then start else findLeastFrom P (start + 1) fuel) ≤ m
rcases Decidable.em (P start) with h | h
· rw [if_pos h]
exact ⟨h, hlo⟩
· rw [if_neg h]
have hne : m ≠ start := fun he => h (he ▸ hm)
exact ih (start + 1) (by omega) (by omega)
/-- The least divisor of n at least 2, found by bounded search from 2 with fuel n. -/
def leastDivisor (n : Nat) : Nat := findLeastFrom (fun d => 2 ≤ d ∧ d ∣ n) 2 n
theorem leastDivisor_spec (n : Nat) (hn : 2 ≤ n) :
(2 ≤ leastDivisor n ∧ leastDivisor n ∣ n) ∧ leastDivisor n ≤ n ∧
(∀ m, 2 ≤ m → m ∣ n → leastDivisor n ≤ m) := by
have hbase := findLeastFrom_correct (fun d => 2 ≤ d ∧ d ∣ n) 2 n n hn (by omega)
⟨hn, Nat.dvd_refl n⟩
refine ⟨hbase.1, hbase.2, fun m hm2 hm => ?_⟩
have hmn : m ≤ n := Nat.le_of_dvd (by omega) hm
exact (findLeastFrom_correct (fun d => 2 ≤ d ∧ d ∣ n) 2 n m hm2 (by omega) ⟨hm2, hm⟩).2
/-- The least divisor at least 2 is prime: any divisor of it divides n, and the search's
minimality bounds it from below. -/
theorem leastDivisor_prime (n : Nat) (hn : 2 ≤ n) : isPrime (leastDivisor n) := by
obtain ⟨⟨hd2, hdvd⟩, hdle, hmin⟩ := leastDivisor_spec n hn
refine ⟨hd2, fun m hm => ?_⟩
have hdpos : 0 < leastDivisor n := by omega
have hmle : m ≤ leastDivisor n := Nat.le_of_dvd hdpos hm
rcases Decidable.em (m = 1) with h1 | h1
· exact Or.inl h1
· right
have hmne0 : m ≠ 0 := by
intro h0
rw [h0] at hm
obtain ⟨c, hc⟩ := hm
rw [Nat.zero_mul] at hc
omega
have hm2 : 2 ≤ m := by omega
have hle := hmin m hm2 (Nat.dvd_trans hm hdvd)
omega
/-- Every integer greater than one has a prime divisor: the least divisor at least 2, found by
bounded search. No classical axiom. -/
theorem exists_prime_dvd (n : Nat) (h0 : 0 < n) (h1 : n ≠ 1) : ∃ p, isPrime p ∧ p ∣ n := by
have hn : 2 ≤ n := by omega
exact ⟨leastDivisor n, leastDivisor_prime n hn, (leastDivisor_spec n hn).1.2⟩
/-- Two completely additive functions that agree at every prime agree everywhere, by bounded
induction peeling one prime divisor at each step. -/
theorem determined_by_primes (f g : Nat → Int) (hf : CompletelyAdditive f)
(hg : CompletelyAdditive g) (h_agree : ∀ p, isPrime p → f p = g p) :
∀ n, 0 < n → f n = g n := by
suffices h : ∀ fuel n, n ≤ fuel → 0 < n → f n = g n from fun n hn => h n n (Nat.le_refl n) hn
intro fuel
induction fuel with
| zero => intro n hle h0; omega
| succ fuel ih =>
intro n hle h0
if h1 : n = 1 then
subst h1
rw [seat_is_zero f hf, seat_is_zero g hg]
else
obtain ⟨p, hp, hpd⟩ := exists_prime_dvd n h0 h1
obtain ⟨k, hk⟩ := hpd
have hk0 : 0 < k := by
rcases Nat.eq_zero_or_pos k with hkc | hkc
· exfalso
rw [hkc, Nat.mul_zero] at hk
omega
· exact hkc
have hp2 : 2 ≤ p := hp.1
have hlt : k < n := by
obtain ⟨d, hd⟩ := Nat.exists_eq_add_of_le hp2
rw [hk, hd, Nat.add_mul]
omega
have hpf : f (p * k) = f p + f k := hf p k (by omega) hk0
have hpg : g (p * k) = g p + g k := hg p k (by omega) hk0
rw [hk, hpf, hpg, h_agree p hp, ih k (by omega) hk0]
/-! ## IV · The p-adic valuation as a free assignment; Euclid's lemma from first principles -/
/-- Remainder descent: if p divides m * b and x * b, with x = m * q + r, then p divides r * b. -/
theorem dvd_remainder_mul (p b m q r x : Nat) (hpm : p ∣ m * b) (hx : p ∣ x * b)
(hqr : m * q + r = x) : p ∣ r * b := by
have h2 : p ∣ (m * q) * b := by
obtain ⟨c, hc⟩ := hpm
exact ⟨c * q, by
calc (m * q) * b = (m * b) * q := Nat.mul_right_comm m q b
_ = (p * c) * q := by rw [hc]
_ = p * (c * q) := Nat.mul_assoc p c q⟩
have h3 : (m * q) * b + r * b = x * b := by rw [← Nat.add_mul, hqr]
obtain ⟨u, hu⟩ := hx
obtain ⟨v, hv⟩ := h2
have hY : r * b = x * b - (m * q) * b := by
calc r * b = (m * q) * b + r * b - (m * q) * b := (Nat.add_sub_cancel_left _ _).symm
_ = x * b - (m * q) * b := by rw [h3]
exact ⟨u - v, by rw [Nat.mul_sub, ← hu, ← hv]; exact hY⟩
/-- The least positive m with p ∣ m * b, found by search from 0 with fuel p. -/
def leastMulDvd (p b : Nat) : Nat := findLeastFrom (fun m => 0 < m ∧ p ∣ m * b) 0 p
theorem leastMulDvd_spec (p b : Nat) (hwit : 0 < p ∧ p ∣ p * b) :
(0 < leastMulDvd p b ∧ p ∣ leastMulDvd p b * b) ∧ leastMulDvd p b ≤ p ∧
(∀ k, k ≤ p → 0 < k ∧ p ∣ k * b → leastMulDvd p b ≤ k) :=
⟨(findLeastFrom_correct (fun m => 0 < m ∧ p ∣ m * b) 0 p p (Nat.zero_le p) (by omega)
hwit).1,
(findLeastFrom_correct (fun m => 0 < m ∧ p ∣ m * b) 0 p p (Nat.zero_le p) (by omega)
hwit).2,
fun k hk hPk =>
(findLeastFrom_correct (fun m => 0 < m ∧ p ∣ m * b) 0 p k (Nat.zero_le k) (by omega)
hPk).2⟩
/-- Euclid's lemma: a prime dividing a product divides one of the factors. Proved by least-witness
search, the division algorithm and descent on the remainder. -/
theorem euclid_lemma (p a b : Nat) (hp : isPrime p) (hab : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
rcases Decidable.em (p ∣ a) with hpa | hpa
· exact Or.inl hpa
· right
have hp0 : 0 < p := by have := hp.1; omega
obtain ⟨⟨hm0, hmdvd⟩, hmle, hmin'⟩ :=
leastMulDvd_spec p b ⟨hp0, Nat.dvd_mul_right p b⟩
have hmp : leastMulDvd p b ∣ p := by
apply Nat.dvd_of_mod_eq_zero
have hc : p % leastMulDvd p b = 0 ∨ 0 < p % leastMulDvd p b := by omega
rcases hc with h0 | hpos
· exact h0
· have hlt : p % leastMulDvd p b < leastMulDvd p b := Nat.mod_lt p hm0
have hdvd' : p ∣ (p % leastMulDvd p b) * b :=
dvd_remainder_mul p b (leastMulDvd p b) (p / leastMulDvd p b)
(p % leastMulDvd p b) p hmdvd (Nat.dvd_mul_right p b)
(Nat.div_add_mod p (leastMulDvd p b))
have hle := hmin' (p % leastMulDvd p b) (by omega) ⟨hpos, hdvd'⟩
omega
have hma : leastMulDvd p b ∣ a := by
apply Nat.dvd_of_mod_eq_zero
have hc : a % leastMulDvd p b = 0 ∨ 0 < a % leastMulDvd p b := by omega
rcases hc with h0 | hpos
· exact h0
· have hlt : a % leastMulDvd p b < leastMulDvd p b := Nat.mod_lt a hm0
have hdvd' : p ∣ (a % leastMulDvd p b) * b :=
dvd_remainder_mul p b (leastMulDvd p b) (a / leastMulDvd p b)
(a % leastMulDvd p b) a hmdvd hab (Nat.div_add_mod a (leastMulDvd p b))
have hle := hmin' (a % leastMulDvd p b) (by omega) ⟨hpos, hdvd'⟩
omega
rcases hp.2 _ hmp with h | h
· rw [h] at hmdvd
rwa [Nat.one_mul] at hmdvd
· rw [h] at hma
exact absurd hma hpa
/-- Greatest witness at or below the bound, by downward search; P 0 always holds here. -/
def findGt (P : Nat → Prop) [DecidablePred P] : Nat → Nat
| 0 => 0
| n + 1 => if P (n + 1) then n + 1 else findGt P n
theorem findGt_spec (P : Nat → Prop) [DecidablePred P] (n : Nat) (h0 : P 0) :
P (findGt P n) := by
induction n with
| zero => exact h0
| succ n ih =>
show P (if P (n + 1) then n + 1 else findGt P n)
rcases Decidable.em (P (n + 1)) with h | h
· rw [if_pos h]; exact h
· rw [if_neg h]; exact ih
theorem findGt_max (P : Nat → Prop) [DecidablePred P] (n k : Nat) (hk : k ≤ n) (hPk : P k) :
k ≤ findGt P n := by
induction n with
| zero =>
have h : k = 0 := by omega
subst h
exact Nat.le_refl _
| succ n ih =>
show k ≤ (if P (n + 1) then n + 1 else findGt P n)
rcases Decidable.em (P (n + 1)) with h | h
· rw [if_pos h]; exact hk
· rw [if_neg h]
have hne : k ≠ n + 1 := fun hkk => h (hkk ▸ hPk)
have hkn : k ≤ n := by omega
exact ih hkn
/-- The p-adic valuation: the exponent of p in n, as the greatest k with p ^ k ∣ n. -/
def pExp (p n : Nat) : Nat := findGt (fun k => p ^ k ∣ n) n
theorem pExp_dvd (p n : Nat) : p ^ pExp p n ∣ n :=
findGt_spec (fun k => p ^ k ∣ n) n (by
show p ^ 0 ∣ n
rw [Nat.pow_zero]
exact Nat.one_dvd n)
/-- Exponents of two outrun their index. -/
theorem two_pow_ge (k : Nat) : k + 1 ≤ 2 ^ k := by
induction k with
| zero => decide
| succ k ih => rw [Nat.pow_succ]; omega
/-- A power of p ≥ 2 dividing a positive n is bounded by n. -/
theorem pow_dvd_bound (p n k : Nat) (hp : 2 ≤ p) (hn : 0 < n) (h : p ^ k ∣ n) : k ≤ n := by
have h1 : p ^ k ≤ n := Nat.le_of_dvd hn h
have h2 : k + 1 ≤ 2 ^ k := two_pow_ge k
have h3 : 2 ^ k ≤ p ^ k := Nat.pow_le_pow_left hp k
omega
theorem pExp_le_of_dvd (p n k : Nat) (hk : k ≤ n) (h : p ^ k ∣ n) : k ≤ pExp p n :=
findGt_max (fun k => p ^ k ∣ n) n k hk h
/-- Four factors rearranged. -/
theorem mul_mul_mul_comm_nat (a b c d : Nat) : (a * b) * (c * d) = (a * c) * (b * d) := by
calc (a * b) * (c * d) = a * (b * c) * d := by
rw [Nat.mul_assoc, ← Nat.mul_assoc b c d, Nat.mul_assoc a (b * c) d]
_ = a * (c * b) * d := by rw [Nat.mul_comm b c]
_ = (a * c) * (b * d) := by
rw [Nat.mul_assoc, Nat.mul_assoc c b d, Nat.mul_assoc a c (b * d)]
/-- The p-adic valuation is additive over products. -/
theorem pExp_mul (p a b : Nat) (hp : isPrime p) (ha : 0 < a) (hb : 0 < b) :
pExp p (a * b) = pExp p a + pExp p b := by
have hp2 : 2 ≤ p := hp.1
have hp0 : 0 < p := by omega
have hia : p ^ pExp p a ∣ a := pExp_dvd p a
have hjb : p ^ pExp p b ∣ b := pExp_dvd p b
obtain ⟨a', ha'⟩ := hia
obtain ⟨b', hb'⟩ := hjb
have hpa' : ¬ p ∣ a' := by
intro hdiv
obtain ⟨c, hc⟩ := hdiv
have hbig : p ^ (pExp p a + 1) ∣ a :=
⟨c, by
calc a = p ^ pExp p a * a' := ha'
_ = p ^ pExp p a * (p * c) := by rw [hc]
_ = p ^ (pExp p a + 1) * c := by rw [Nat.pow_add, Nat.pow_one, Nat.mul_assoc]⟩
have hle := pExp_le_of_dvd p a (pExp p a + 1)
(pow_dvd_bound p a _ hp2 ha hbig) hbig
omega
have hpb' : ¬ p ∣ b' := by
intro hdiv
obtain ⟨c, hc⟩ := hdiv
have hbig : p ^ (pExp p b + 1) ∣ b :=
⟨c, by
calc b = p ^ pExp p b * b' := hb'
_ = p ^ pExp p b * (p * c) := by rw [hc]
_ = p ^ (pExp p b + 1) * c := by rw [Nat.pow_add, Nat.pow_one, Nat.mul_assoc]⟩
have hle := pExp_le_of_dvd p b (pExp p b + 1)
(pow_dvd_bound p b _ hp2 hb hbig) hbig
omega
have hprodeq : a * b = p ^ (pExp p a + pExp p b) * (a' * b') := by
have e1 : a * b = (p ^ pExp p a * a') * b := congrArg (fun x => x * b) ha'
have e2 : (p ^ pExp p a * a') * b = (p ^ pExp p a * a') * (p ^ pExp p b * b') :=
congrArg (fun x => (p ^ pExp p a * a') * x) hb'
have e3 : (p ^ pExp p a * a') * (p ^ pExp p b * b') =
(p ^ pExp p a * p ^ pExp p b) * (a' * b') := mul_mul_mul_comm_nat _ _ _ _
have e4 : (p ^ pExp p a * p ^ pExp p b) * (a' * b') =
p ^ (pExp p a + pExp p b) * (a' * b') :=
congrArg (fun x => x * (a' * b')) (Nat.pow_add p _ _).symm
exact e1.trans (e2.trans (e3.trans e4))
have hup : p ^ (pExp p a + pExp p b) ∣ a * b := ⟨a' * b', hprodeq⟩
have hdown : ¬ p ^ (pExp p a + pExp p b + 1) ∣ a * b := by
intro hbig
have hdecomp : p ^ (pExp p a + pExp p b + 1) = p ^ (pExp p a + pExp p b) * p := by
rw [Nat.pow_add, Nat.pow_one]
have hdiv : p ∣ a' * b' := by
have h' : p ^ (pExp p a + pExp p b) * p ∣ p ^ (pExp p a + pExp p b) * (a' * b') := by
rw [← hprodeq, ← hdecomp]
exact hbig
exact Nat.dvd_of_mul_dvd_mul_left (Nat.pow_pos hp0) h'
rcases euclid_lemma p a' b' hp hdiv with h | h
· exact hpa' h
· exact hpb' h
have hle1 : pExp p a + pExp p b ≤ pExp p (a * b) :=
pExp_le_of_dvd p (a * b) _ (pow_dvd_bound p (a * b) _ hp2 (Nat.mul_pos ha hb) hup) hup
have hle2 : pExp p (a * b) ≤ pExp p a + pExp p b := by
have hK : p ^ pExp p (a * b) ∣ a * b := pExp_dvd p (a * b)
rcases Decidable.em (pExp p a + pExp p b + 1 ≤ pExp p (a * b)) with hgt | hgt
· exact absurd (Nat.dvd_trans (Nat.pow_dvd_pow p hgt) hK) hdown
· omega
omega
/-- The valuation of p at itself is one. -/
theorem pExp_self (p : Nat) (hp : isPrime p) : pExp p p = 1 := by
have hp2 : 2 ≤ p := hp.1
have hp0 : 0 < p := by omega
have h1 : p ^ (1 : Nat) ∣ p := by rw [Nat.pow_one]; exact Nat.dvd_refl p
have h1le : 1 ≤ pExp p p := pExp_le_of_dvd p p 1 (by omega) h1
have hnot2 : ¬ p ^ (1 + 1 : Nat) ∣ p := by
intro h
have hle : p ^ (1 + 1) ≤ p := Nat.le_of_dvd hp0 h
rw [Nat.pow_add, Nat.pow_one] at hle
have hge : 2 * p ≤ p * p := by
obtain ⟨d, hd⟩ := Nat.exists_eq_add_of_le hp2
rw [hd, Nat.add_mul]
exact Nat.le_add_right _ _
omega
rcases Decidable.em (2 ≤ pExp p p) with h | h
· exact absurd (Nat.dvd_trans (Nat.pow_dvd_pow p h) (pExp_dvd p p)) hnot2
· omega
/-- The valuation vanishes where p does not divide. -/
theorem pExp_eq_zero_of_not_dvd (p n : Nat) (h : ¬ p ∣ n) : pExp p n = 0 := by
rcases Decidable.em (1 ≤ pExp p n) with hpos | hneg
· have hpow : p ^ (1 : Nat) ∣ p ^ pExp p n := Nat.pow_dvd_pow p hpos
rw [Nat.pow_one] at hpow
exact absurd (Nat.dvd_trans hpow (pExp_dvd p n)) h
· omega
/-- The valuation at one is zero. -/
theorem pExp_one (p : Nat) (hp : isPrime p) : pExp p 1 = 0 := by
apply pExp_eq_zero_of_not_dvd
intro hd
have h1 := Nat.le_of_dvd (by decide) hd
have h2 := hp.1
omega
/-- The valuation at a different prime is zero. -/
theorem pExp_other (p q : Nat) (hp : isPrime p) (hq : isPrime q) (hpq : p ≠ q) :
pExp p q = 0 := by
apply pExp_eq_zero_of_not_dvd
intro hd
rcases hq.2 p hd with h | h
· have := hp.1; omega
· exact hpq h
/-- The p-adic valuation as an integer-valued function. -/
def padicMeasure (p : Nat) (n : Nat) : Int := (pExp p n : Int)
theorem padicMeasure_additive (p : Nat) (hp : isPrime p) :
CompletelyAdditive (padicMeasure p) := by
intro a b ha hb
show ((pExp p (a * b) : Nat) : Int) = (pExp p a : Int) + (pExp p b : Int)
rw [pExp_mul p a b hp ha hb, Int.natCast_add]
/-- For distinct primes p and q there is a completely additive function equal to 1 at p and 0 at q:
the p-adic valuation. -/
theorem prime_freedom_independent (p q : Nat) (hp : isPrime p) (hq : isPrime q) (hpq : p ≠ q) :
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0 :=
⟨padicMeasure p, padicMeasure_additive p hp,
by show ((pExp p p : Nat) : Int) = 1; rw [pExp_self p hp]; rfl,
by show ((pExp p q : Nat) : Int) = 0; rw [pExp_other p q hp hq hpq]; rfl,
by show ((pExp p 1 : Nat) : Int) = 0; rw [pExp_one p hp]; rfl⟩
/-- Uniqueness and independence together: a completely additive function is determined by its
values at the primes, and those values are freely assignable. -/
theorem primes_base_of_freedom :
(∀ f g : Nat → Int, CompletelyAdditive f → CompletelyAdditive g →
(∀ p, isPrime p → f p = g p) → ∀ n, 0 < n → f n = g n) ∧
(∀ p q : Nat, isPrime p → isPrime q → p ≠ q →
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0) :=
⟨determined_by_primes, prime_freedom_independent⟩
/-! ## V · The sign arrow of an additive count -/
/-- An additive count: Ω(ab) = Ω(a) + Ω(b) for positive a and b. -/
def AdditiveCount (Om : Nat → Nat) : Prop := ∀ a b, a > 0 → b > 0 → Om (a * b) = Om a + Om b
/-- The sign arrow of a count: +1 on an even count, −1 on an odd one. -/
def signArrow (k : Nat) : Int := if k % 2 = 0 then 1 else -1
/-- The sign of a sum is the product of the signs. -/
theorem signArrow_add (m n : Nat) :
signArrow (m + n) = signArrow m * signArrow n := by
unfold signArrow
rw [Nat.add_mod]
rcases Nat.mod_two_eq_zero_or_one m with hm | hm <;>
rcases Nat.mod_two_eq_zero_or_one n with hn | hn <;>
rw [hm, hn] <;> decide
/-- The sign arrow of an additive count is completely multiplicative, as λ(n) = (−1)^Ω(n) is. -/
theorem arrow_multiplicative (Om : Nat → Nat) (hOm : AdditiveCount Om)
(a b : Nat) (ha : a > 0) (hb : 0 < b) :
signArrow (Om (a * b)) = signArrow (Om a) * signArrow (Om b) := by
rw [hOm a b ha hb, signArrow_add]
/-- At a prime the count is one and the sign is −1. -/
theorem arrow_at_prime (Om : Nat → Nat) (p : Nat) (_hp : isPrime p) (hOm : Om p = 1) :
signArrow (Om p) = -1 := by
rw [hOm]
decide
/-! ## V-bis · No finite stage decides a universal -/
/-- For every N there is a property true below N and false at N. -/
theorem finite_never_forces (N : Nat) :
∃ P : Nat → Prop, (∀ n, n < N → P n) ∧ ¬ ∀ n, P n :=
⟨fun n => n < N, fun _ h => h, fun h => Nat.lt_irrefl N (h N)⟩
/-- A property with counterexamples past every stage is not universal:
no finite census decides the limit. -/
theorem limit_not_forced (P : Nat → Prop) (h_finite : ∀ N, ∃ n > N, ¬ P n) : ¬ (∀ n, P n) := by
intro h
obtain ⟨n, _, hn_not⟩ := h_finite 0
exact hn_not (h n)
/-! ## VI · The chart: the fold, registration, the record -/
/-- A point of the chart: the doubled real part x and the height t.
The critical line is x = 1; the fold s ↦ 1 − s̄ sends x to 2 − x;
registration keeps the height and lands on the line. -/
structure Pt where
x : Int
t : Nat
deriving DecidableEq
def onLine (z : Pt) : Prop := z.x = 1
instance (z : Pt) : Decidable (onLine z) := inferInstanceAs (Decidable (z.x = 1))
def fold (z : Pt) : Pt := ⟨2 - z.x, z.t⟩
def reg (z : Pt) : Pt := ⟨1, z.t⟩
theorem fold_fixed_iff (z : Pt) : fold z = z ↔ onLine z := by
cases z with
| mk x t =>
show Pt.mk (2 - x) t = Pt.mk x t ↔ x = 1
constructor
· intro h
have hx := congrArg Pt.x h
change 2 - x = x at hx
omega
· intro h
subst h
rfl
theorem reg_fixes_line (z : Pt) (h : onLine z) : reg z = z := by
cases z with
| mk x t =>
have hx : x = 1 := h
subst hx
rfl
/-- No registered point lies off the line. -/
theorem unicorn_never_registered (z : Pt) (h : ¬ onLine z) : ∀ w, reg w ≠ z := by
intro w hw
apply h
rw [← hw]
exact rfl
/-- Every point is on the line, fixed by the fold and by registration, or off the line, moved by
the fold, sharing its record with its partner, and registered by no point. -/
theorem nothing_escapes_one_cut (z : Pt) :
(onLine z ∧ fold z = z ∧ reg z = z) ∨
(¬ onLine z ∧ fold z ≠ z ∧ reg (fold z) = reg z ∧ ∀ w, reg w ≠ z) :=
if h : z.x = 1 then Or.inl ⟨h, (fold_fixed_iff z).mpr h, reg_fixes_line z h⟩
else Or.inr ⟨h, fun hf => h ((fold_fixed_iff z).mp hf), rfl, unicorn_never_registered z h⟩
/-- A world is a zero set on the chart. -/
abbrev World := Pt → Prop
def FoldClosed (Z : World) : Prop := ∀ z, Z z → Z (fold z)
/-- The hypothesis, on the chart: every zero lies on the line. -/
def RH (Z : World) : Prop := ∀ z, Z z → onLine z
def Left (Z : World) : Prop := ∃ z, Z z ∧ z.x < 1
def Right (Z : World) : Prop := ∃ z, Z z ∧ 1 < z.x
/-- On a fold-closed world some zero lies left of the line exactly when some zero lies right of it. -/
theorem sides_together (Z : World) (hZ : FoldClosed Z) : Left Z ↔ Right Z :=
⟨fun ⟨z, hz, hx⟩ => ⟨fold z, hZ z hz, show 1 < 2 - z.x by omega⟩,
fun ⟨z, hz, hx⟩ => ⟨fold z, hZ z hz, show 2 - z.x < 1 by omega⟩⟩
/-- On a fold-closed world the hypothesis holds exactly when no zero lies left of the line. -/
theorem rh_iff_no_left (Z : World) (hZ : FoldClosed Z) : RH Z ↔ ¬ Left Z := by
constructor
· intro h ⟨z, hz, hx⟩
have e : z.x = 1 := h z hz
omega
· intro h z hz
if hx : z.x = 1 then exact hx
else
exfalso
apply h
if hl : z.x < 1 then exact ⟨z, hz, hl⟩
else exact ⟨fold z, hZ z hz, show 2 - z.x < 1 by omega⟩
/-- The record of a world: its zeros registered. -/
def recordOf (Z : World) : World := fun r => ∃ s, Z s ∧ reg s = r
def SameRecord (Z Z' : World) : Prop := ∀ r, recordOf Z r ↔ recordOf Z' r
/-- A reading respects the record when two worlds of one record read alike. -/
def RespectsRecord (g : World → Prop) : Prop := ∀ Z Z', SameRecord Z Z' → (g Z ↔ g Z')
/-- The on-line world at height 14, and the off-line pair at offset k about the same height. -/
abbrev W1 : World := fun z => z = ⟨1, 14⟩
abbrev pairAt (k : Int) : World := fun z => z = ⟨1 - k, 14⟩ ∨ z = ⟨1 + k, 14⟩
abbrev W2 : World := pairAt 1
theorem W1_closed : FoldClosed W1 := by
intro z hz
have h : z = ⟨1, 14⟩ := hz
subst h
show fold ⟨1, 14⟩ = ⟨1, 14⟩
decide
theorem W1_rh : RH W1 := by
intro z hz
have h : z = ⟨1, 14⟩ := hz
subst h
exact rfl
theorem pair_closed (k : Int) : FoldClosed (pairAt k) := by
intro z hz
rcases hz with h | h
· subst h
apply Or.inr
show Pt.mk (2 - (1 - k)) 14 = Pt.mk (1 + k) 14
congr 1
omega
· subst h
apply Or.inl
show Pt.mk (2 - (1 + k)) 14 = Pt.mk (1 - k) 14
congr 1
omega
theorem pair_not_rh (k : Int) (hk : k ≠ 0) : ¬ RH (pairAt k) := by
intro h
have e : (1 : Int) - k = 1 := h ⟨1 - k, 14⟩ (Or.inl rfl)
omega
theorem pair_same_record (k : Int) : SameRecord W1 (pairAt k) := by
intro r
constructor
· intro ⟨s, hs, hr⟩
have h : s = ⟨1, 14⟩ := hs
subst h
exact ⟨⟨1 - k, 14⟩, Or.inl rfl, hr⟩
· intro ⟨s, hs, hr⟩
rcases hs with h | h <;> subst h <;> exact ⟨⟨1, 14⟩, rfl, hr⟩
theorem W2_closed : FoldClosed W2 := pair_closed 1
theorem W2_not_rh : ¬ RH W2 := pair_not_rh 1 (by decide)
theorem same_record_12 : SameRecord W1 W2 := pair_same_record 1
/-- Distinct positive offsets give distinct fold-closed worlds with the record of W1, none
satisfying the hypothesis. -/
theorem fibre_is_infinite (k k' : Int) (hk : 0 < k) (hk' : 0 < k') (hne : k ≠ k') :
SameRecord W1 (pairAt k) ∧ ¬ RH (pairAt k) ∧ pairAt k ⟨1 - k, 14⟩ ∧ ¬ pairAt k' ⟨1 - k, 14⟩ := by
refine ⟨pair_same_record k, pair_not_rh k (by omega), Or.inl rfl, ?_⟩
intro h
rcases h with h | h
· have e : (1 : Int) - k = 1 - k' := congrArg Pt.x h
omega
· have e : (1 : Int) - k = 1 + k' := congrArg Pt.x h
omega
/-- Two worlds with the same record that both satisfy the hypothesis are equal. -/
theorem lossless_unique (Z Z' : World) (h : SameRecord Z Z') (hZ : RH Z) (hZ' : RH Z') :
∀ z, Z z ↔ Z' z := by
intro z
constructor
· intro hz
obtain ⟨s, hs, hsr⟩ := (h z).mp ⟨z, hz, reg_fixes_line z (hZ z hz)⟩
have e : reg s = s := reg_fixes_line s (hZ' s hs)
rw [← hsr, e]
exact hs
· intro hz
obtain ⟨s, hs, hsr⟩ := (h z).mpr ⟨z, hz, reg_fixes_line z (hZ' z hz)⟩
have e : reg s = s := reg_fixes_line s (hZ s hs)
rw [← hsr, e]
exact hs
/-- No reading of the record agrees with the hypothesis on every fold-closed world. -/
theorem record_decides_nothing (g : World → Prop) (hg : RespectsRecord g) :
¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z) := fun h =>
W2_not_rh ((h W2 W2_closed).mp ((hg W1 W2 same_record_12).mp ((h W1 W1_closed).mpr W1_rh)))
/-- record_decides_nothing, under a second name. -/
theorem unicorn_block (g : World → Prop) (hg : RespectsRecord g) :
¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z) := record_decides_nothing g hg
/-- A premise is keyless when it holds on every world. -/
def Keyless (A : World → Prop) : Prop := ∀ Z, A Z
/-- A premise forces the line when every fold-closed world it holds on satisfies the hypothesis. -/
def Forces (A : World → Prop) : Prop := ∀ Z, FoldClosed Z → A Z → RH Z
/-- A keyless premise forces nothing: it holds on W2, which is fold-closed and fails the
hypothesis. -/
theorem keyless_forces_nothing (A : World → Prop) (hA : Keyless A) : ¬ Forces A :=
fun h => W2_not_rh (h W2 W2_closed (hA W2))
/-- The hypothesis separates W1 from W2, which share one record. -/
theorem sentence_separates_record_does_not : (RH W1 ∧ ¬ RH W2) ∧ SameRecord W1 W2 :=
⟨⟨W1_rh, W2_not_rh⟩, same_record_12⟩
/-! ## VII · Least erasure is the value -/
def OffLine (Z : World) : Prop := ∃ z, Z z ∧ ¬ onLine z
/-- Least erasure in the fibre: if the world erases, every world of its record erases. -/
def LeastErasure (Z : World) : Prop := ∀ Z', SameRecord Z Z' → OffLine Z → OffLine Z'
theorem record_is_lossless (Z : World) : ¬ OffLine (recordOf Z) := by
intro ⟨r, ⟨s, _, hsr⟩, hoff⟩
apply hoff
rw [← hsr]
exact rfl
theorem record_same (Z : World) : SameRecord Z (recordOf Z) := by
intro r
constructor
· intro ⟨s, hs, hsr⟩
exact ⟨reg s, ⟨s, hs, rfl⟩, hsr⟩
· intro ⟨s', ⟨s, hs, hss'⟩, hs'r⟩
subst hss'
exact ⟨s, hs, hs'r⟩
/-- Least erasure holds on a world exactly when the hypothesis does. -/
theorem least_erasure_is_the_value (Z : World) : LeastErasure Z ↔ RH Z := by
constructor
· intro hle z hz
if h : z.x = 1 then exact h
else exact absurd (hle (recordOf Z) (record_same Z) ⟨z, hz, h⟩) (record_is_lossless Z)
· intro hrh _ _ ⟨z, hz, hoff⟩
exact absurd (hrh z hz) hoff
/-- Least erasure is not a reading of the record: it holds on W1 and fails on W2, which share one
record. -/
theorem least_erasure_reads_past_the_record : ¬ RespectsRecord LeastErasure := fun h =>
W2_not_rh ((least_erasure_is_the_value W2).mp
((h W1 W2 same_record_12).mp ((least_erasure_is_the_value W1).mpr W1_rh)))
/-- Any premise that forces the line and is forced by it is the line, on every fold-closed
world. -/
theorem posit_is_the_value (A : World → Prop) (h : Forces A)
(h' : ∀ Z, FoldClosed Z → RH Z → A Z) : ∀ Z, FoldClosed Z → (A Z ↔ RH Z) :=
fun Z hZ => ⟨h Z hZ, h' Z hZ⟩
/-! ## VII-bis · The fold never crosses the line; a second symmetry; the record blind at every scale -/
/-- The fold lands on the line exactly where the point already was: folding never crosses. -/
theorem fold_onLine_iff (z : Pt) : onLine (fold z) ↔ onLine z := by
show (2 - z.x = 1) ↔ (z.x = 1)
constructor <;> intro h <;> omega
theorem fold_preserves_offline (z : Pt) : ¬ onLine (fold z) ↔ ¬ onLine z := by
rw [fold_onLine_iff]
theorem fold_ne_of_offline (z : Pt) (h : ¬ onLine z) : fold z ≠ z :=
fun hf => h ((fold_fixed_iff z).mp hf)
/-- A second involution on the chart, commuting with the fold and preserving the line. -/
structure ConjSymmetry where
conj : Pt → Pt
invol : ∀ z, conj (conj z) = z
commutes : ∀ z, conj (fold z) = fold (conj z)
preserves_line : ∀ z, onLine (conj z) ↔ onLine z
/-- Under both symmetries one off-line zero forces its reflection, its conjugate and their
composite into the world, all off the line. -/
theorem offline_zero_quadruple (Z : World) (hF : FoldClosed Z) (C : ConjSymmetry)
(hC : ∀ z, Z z → Z (C.conj z)) (z : Pt) (hz : Z z) (hoff : ¬ onLine z) :
Z (fold z) ∧ Z (C.conj z) ∧ Z (C.conj (fold z)) ∧
¬ onLine (fold z) ∧ ¬ onLine (C.conj z) ∧ ¬ onLine (C.conj (fold z)) ∧ fold z ≠ z :=
⟨hF z hz, hC z hz, hC (fold z) (hF z hz),
(fold_preserves_offline z).mpr hoff,
fun h => hoff ((C.preserves_line z).mp h),
fun h => hoff ((fold_onLine_iff z).mp ((C.preserves_line (fold z)).mp h)),
fold_ne_of_offline z hoff⟩
/-- If the hypothesis fails on a world, some zero of it lies off the line. Classical. -/
theorem not_rh_has_offline_witness (Z : World) (h : ¬ RH Z) : OffLine Z := by
apply Classical.byContradiction
intro hno
apply h
intro z hz
apply Classical.byContradiction
intro hoff
exact hno ⟨z, hz, hoff⟩
/-- Denying the hypothesis on a world with both symmetries posits a whole off-line orbit of four
points. -/
theorem denial_posits_the_orbit (Z : World) (hF : FoldClosed Z) (C : ConjSymmetry)
(hC : ∀ z, Z z → Z (C.conj z)) (h : ¬ RH Z) :
∃ z, Z z ∧ ¬ onLine z ∧ Z (fold z) ∧ Z (C.conj z) ∧ Z (C.conj (fold z)) := by
obtain ⟨z, hz, hoff⟩ := not_rh_has_offline_witness Z h
exact ⟨z, hz, hoff, hF z hz, hC z hz, hC (fold z) (hF z hz)⟩
/-- For every nonzero offset the pair world is fold-closed, fails the hypothesis, and shares the
record of W1. -/
theorem record_blind_at_every_scale (k : Int) (hk : k ≠ 0) :
RH W1 ∧ FoldClosed (pairAt k) ∧ ¬ RH (pairAt k) ∧ SameRecord W1 (pairAt k) :=
⟨W1_rh, pair_closed k, pair_not_rh k hk, pair_same_record k⟩
/-! ## VIII · Self-grounding supplies, and the five faces of the hypothesis -/
/-- A self-grounding root, the structure of Appendix R in the same words: acts occur, and every act instances the root. -/
structure SelfGrounding (root : Prop) where
Act : Type
anAct : Act
instances : Act → root
/-- A self-grounding supply of a proposition, with an act, exists exactly when the proposition
holds. -/
theorem supply_iff (root : Prop) : (∃ G : SelfGrounding root, Nonempty G.Act) ↔ root := by
constructor
· intro ⟨G, ⟨a⟩⟩
exact G.instances a
· intro hr
exact ⟨⟨Unit, (), fun _ => hr⟩, ⟨()⟩⟩
/-- The five faces of the hypothesis. The equivalences are fields, carried as hypotheses and not
proved here: the critical line (Riemann 1859), Λ = 0 (Newman 1976; Rodgers and Tao 2020), the
faithfulness of the Liouville function (Landau 1899), and Weil positivity (Weil 1952). -/
structure Faces where
line : Prop
lamZero : Prop
faithful : Prop
weil : Prop
least : Prop
line_iff_least : line ↔ least
lam_iff_least : lamZero ↔ least
faith_iff_least : faithful ↔ least
weil_iff_least : weil ↔ least
/-- Any one face implies all five. -/
theorem faces_are_one (H : Faces) :
(H.line ↔ H.least) ∧ (H.lamZero ↔ H.least) ∧ (H.faithful ↔ H.least) ∧ (H.weil ↔ H.least) :=
⟨H.line_iff_least, H.lam_iff_least, H.faith_iff_least, H.weil_iff_least⟩
/-- Given a self-grounding supply of the least-erasure face with an act, all five faces hold. -/
theorem rh_from_the_act_generic (H : Faces) (G : SelfGrounding H.least) (a : G.Act) :
H.line ∧ H.lamZero ∧ H.faithful ∧ H.weil ∧ H.least :=
let le := G.instances a
⟨H.line_iff_least.mpr le, H.lam_iff_least.mpr le, H.faith_iff_least.mpr le,
H.weil_iff_least.mpr le, le⟩
/-! ## IX · Primes, the free basis and the identity arrow are keyless and force nothing -/
/-- Primes exist. -/
theorem primes_exist : ∃ p, isPrime p :=
let ⟨p, hp, _⟩ := exists_prime_dvd 2 (by decide) (by decide)
⟨p, hp⟩
/-- The existence of primes holds on every world. -/
theorem primes_exist_keyless : Keyless (fun _ => ∃ p, isPrime p) := fun _ => primes_exist
/-- The free basis at the primes holds on every world. -/
theorem prime_freedom_keyless :
Keyless (fun _ => ∀ p q, isPrime p → isPrime q → p ≠ q →
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0) :=
fun _ => prime_freedom_independent
/-- The identity arrow exists on every world. -/
theorem arrow_keyless : Keyless (fun _ => ∃ f : Nat → Nat, ∀ a, f a = a) :=
fun _ => arrow_exists Nat
/-- The existence of primes forces nothing. -/
theorem primes_exist_forces_nothing : ¬ Forces (fun _ => ∃ p, isPrime p) :=
keyless_forces_nothing _ primes_exist_keyless
/-- The free basis at the primes forces nothing. -/
theorem prime_freedom_forces_nothing :
¬ Forces (fun _ => ∀ p q, isPrime p → isPrime q → p ≠ q →
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0) :=
keyless_forces_nothing _ prime_freedom_keyless
/-- The existence of the identity arrow forces nothing. -/
theorem arrow_forces_nothing : ¬ Forces (fun _ => ∃ f : Nat → Nat, ∀ a, f a = a) :=
keyless_forces_nothing _ arrow_keyless
/-- The free basis holds, and a fold-closed world failing the hypothesis exists. -/
theorem free_basis_coexists_with_offline_world :
(∀ p q : Nat, isPrime p → isPrime q → p ≠ q →
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0) ∧
∃ Z, FoldClosed Z ∧ ¬ RH Z :=
⟨prime_freedom_independent, W2, W2_closed, W2_not_rh⟩
/-- An off-line point folds to a distinct off-line point, which no point registers to. -/
theorem fold_off_line_stays_off (z : Pt) (h : ¬ onLine z) :
¬ onLine (fold z) ∧ fold z ≠ reg z ∧ fold z ≠ z :=
⟨(fold_preserves_offline z).mpr h,
fun e => unicorn_never_registered (fold z) ((fold_preserves_offline z).mpr h) z e.symm,
fold_ne_of_offline z h⟩
/-! ## X · The explicit formula as a structure; least erasure is Weil positivity -/
structure ExplicitFormula where
/-- The value type of the two sides, with its order and its zero. -/
V : Type
le : V → V → Prop
zero : V
/-- The admissible test functions, their adjoint g ↦ g~, and their convolution. -/
T : Type
adj : T → T
conv : T → T → T
/-- The arithmetic side: the archimedean term with the sum over the primes. -/
primeSide : T → V
/-- The zero side: the sum over the zeros. -/
zeroSide : T → V
/-- The zeros, as a world on the chart. -/
zeros : World
/-- The explicit formula: the zero side of every test function equals its arithmetic side. Carried
as a hypothesis (Guinand 1948; Weil 1952). -/
identity : ∀ g, zeroSide g = primeSide g
/-- Weil's criterion: the arithmetic side is non-negative on every g ⋆ g̃ exactly when the zeros
lie on the line. Carried as a hypothesis (Weil 1952; Bombieri 2000). -/
positivity_iff_line : (∀ g, le zero (primeSide (conv g (adj g)))) ↔ RH zeros
/-- Weil positivity, stated on the prime side. -/
def WeilPositive (E : ExplicitFormula) : Prop :=
∀ g, E.le E.zero (E.primeSide (E.conv g (E.adj g)))
/-- Through the identity, positivity reads the same on the zero side. -/
theorem positivity_on_zero_side (E : ExplicitFormula) :
WeilPositive E ↔ ∀ g, E.le E.zero (E.zeroSide (E.conv g (E.adj g))) := by
constructor
· intro h g
rw [E.identity]
exact h g
· intro h g
rw [← E.identity]
exact h g
/-- Least erasure of the zeros of an explicit formula is Weil positivity of its arithmetic side. -/
theorem least_erasure_is_positivity (E : ExplicitFormula) :
LeastErasure E.zeros ↔ WeilPositive E :=
(least_erasure_is_the_value E.zeros).trans E.positivity_iff_line.symm
/-- A self-grounding supply of Weil positivity exists exactly when the zeros lie on the line. -/
theorem prime_witness_iff (E : ExplicitFormula) :
(∃ G : SelfGrounding (WeilPositive E), Nonempty G.Act) ↔ RH E.zeros :=
(supply_iff (WeilPositive E)).trans E.positivity_iff_line
/-- Weil positivity implies the hypothesis for the zeros of the explicit formula. -/
theorem rh_from_prime_witness (E : ExplicitFormula) (h : WeilPositive E) : RH E.zeros :=
E.positivity_iff_line.mp h
/-- The positive instance: one test function, arithmetic side zero, zeros on the line. -/
def positiveInstance : ExplicitFormula where
V := Int
le := fun a b => a ≤ b
zero := 0
T := Unit
adj := id
conv := fun _ _ => ()
primeSide := fun _ => 0
zeroSide := fun _ => 0
zeros := W1
identity := fun _ => rfl
positivity_iff_line := ⟨fun _ => W1_rh, fun _ _ => Int.le_refl 0⟩
/-- The negative instance: one test function, arithmetic side minus one, zeros off the line. -/
def negativeInstance : ExplicitFormula where
V := Int
le := fun a b => a ≤ b
zero := 0
T := Unit
adj := id
conv := fun _ _ => ()
primeSide := fun _ => -1
zeroSide := fun _ => -1
zeros := W2
identity := fun _ => rfl
positivity_iff_line :=
⟨fun h => absurd (h ()) (by decide : ¬ ((0 : Int) ≤ -1)), fun h => absurd h W2_not_rh⟩
/-- Two explicit formulas satisfy every field, one positive with its zeros on the line and one not
positive with its zeros off the line: no field decides positivity. -/
theorem positivity_is_keyed : WeilPositive positiveInstance ∧ ¬ WeilPositive negativeInstance :=
⟨fun _ => Int.le_refl 0, fun h => absurd (h ()) (by decide : ¬ ((0 : Int) ≤ -1))⟩
/-- The free basis holds in both instances. -/
theorem freedom_does_not_pick_the_sign :
(∀ p q : Nat, isPrime p → isPrime q → p ≠ q →
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0) ∧
WeilPositive positiveInstance ∧ ¬ WeilPositive negativeInstance :=
⟨prime_freedom_independent, positivity_is_keyed⟩
/-- Section X, whole: the free basis; least erasure as the hypothesis and as positivity; the block;
keyless premises forcing nothing; positivity keyed. -/
theorem prime_witness_ledger :
(∀ f g : Nat → Int, CompletelyAdditive f → CompletelyAdditive g →
(∀ p, isPrime p → f p = g p) → ∀ n, 0 < n → f n = g n) ∧
(∀ p q : Nat, isPrime p → isPrime q → p ≠ q →
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0) ∧
(∀ Z : World, LeastErasure Z ↔ RH Z) ∧
(∀ E : ExplicitFormula, LeastErasure E.zeros ↔ WeilPositive E) ∧
(∀ g : World → Prop, RespectsRecord g → ¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z)) ∧
(¬ Forces (fun _ => ∃ p, isPrime p)) ∧
(¬ Forces (fun _ => ∀ p q, isPrime p → isPrime q → p ≠ q →
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0)) ∧
(¬ Forces (fun _ => ∃ f : Nat → Nat, ∀ a, f a = a)) ∧
(WeilPositive positiveInstance ∧ ¬ WeilPositive negativeInstance) :=
⟨determined_by_primes, prime_freedom_independent, least_erasure_is_the_value,
least_erasure_is_positivity, unicorn_block, primes_exist_forces_nothing,
prime_freedom_forces_nothing, arrow_forces_nothing, positivity_is_keyed⟩
/-! ## XI · The posit as a structure field -/
/-- A zero set with its fold-closure and the one posit, least erasure. -/
structure ActualZeros where
/-- The zero set, as a world on the chart. -/
zeros : World
/-- The zero set is fold-closed (the functional equation, Riemann 1859). -/
fold_closed : FoldClosed zeros
/-- The posit: least erasure of the zero set. By least_erasure_is_the_value this field is the
hypothesis. -/
supply : LeastErasure zeros
/-- From the posit, the hypothesis. -/
theorem rh_from_the_act (A : ActualZeros) : RH A.zeros :=
(least_erasure_is_the_value A.zeros).mp A.supply
/-- The type of the posit is equivalent to the hypothesis. -/
theorem posit_is_the_conclusion (A : ActualZeros) : LeastErasure A.zeros ↔ RH A.zeros :=
least_erasure_is_the_value A.zeros
/-- From the posit: the line, least erasure, every zero fixed by the fold and by registration, and
no off-line orbit. -/
theorem rh_ground_closure_complete (A : ActualZeros) :
RH A.zeros ∧ LeastErasure A.zeros ∧ (∀ z, A.zeros z → fold z = z) ∧
(∀ z, A.zeros z → reg z = z) ∧ ¬ Left A.zeros :=
⟨rh_from_the_act A, A.supply,
fun z hz => (fold_fixed_iff z).mpr (rh_from_the_act A z hz),
fun z hz => reg_fixes_line z (rh_from_the_act A z hz),
(rh_iff_no_left A.zeros A.fold_closed).mp (rh_from_the_act A)⟩
/-- An explicit formula for fold-closed zeros, with positivity posited. -/
structure PrimeAct where
E : ExplicitFormula
fold_closed : FoldClosed E.zeros
/-- The posit on the prime side: Weil positivity. -/
positive : WeilPositive E
/-- A prime act is a least-erasure act. -/
def PrimeAct.toActual (P : PrimeAct) : ActualZeros :=
⟨P.E.zeros, P.fold_closed, (least_erasure_is_positivity P.E).mpr P.positive⟩
/-- From positivity posited, the hypothesis. -/
theorem rh_from_prime_act (P : PrimeAct) : RH P.E.zeros := rh_from_the_act P.toActual
/-- For an explicit formula with fold-closed zeros, a positivity posit exists exactly when a
least-erasure posit exists for its zeros. -/
theorem acts_are_one (E : ExplicitFormula) (hF : FoldClosed E.zeros) :
(∃ P : PrimeAct, P.E = E) ↔ ∃ A : ActualZeros, A.zeros = E.zeros := by
constructor
· intro ⟨P, hP⟩
subst hP
exact ⟨P.toActual, rfl⟩
· intro ⟨A, hA⟩
refine ⟨⟨E, hF, (least_erasure_is_positivity E).mp ?_⟩, rfl⟩
rw [← hA]
exact A.supply
/-! ## XII · The block with no axiom: the pair world written out -/
/-- The pair world at offset one, written out. -/
abbrev W2f : World := fun z => z = ⟨0, 14⟩ ∨ z = ⟨2, 14⟩
theorem W2f_closed : FoldClosed W2f := by
intro z hz
rcases hz with h | h
· subst h; exact Or.inr rfl
· subst h; exact Or.inl rfl
theorem W2f_not_rh : ¬ RH W2f :=
fun h => absurd (h ⟨0, 14⟩ (Or.inl rfl)) (by decide : ¬ ((0 : Int) = 1))
theorem same_record_f : SameRecord W1 W2f := by
intro r
constructor
· intro ⟨s, hs, hr⟩
have h : s = ⟨1, 14⟩ := hs
subst h
exact ⟨⟨0, 14⟩, Or.inl rfl, hr⟩
· intro ⟨s, hs, hr⟩
rcases hs with h | h <;> subst h <;> exact ⟨⟨1, 14⟩, rfl, hr⟩
/-- record_decides_nothing, with no axiom. -/
theorem record_decides_nothing_free (g : World → Prop) (hg : RespectsRecord g) :
¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z) := fun h =>
W2f_not_rh ((h W2f W2f_closed).mp ((hg W1 W2f same_record_f).mp ((h W1 W1_closed).mpr W1_rh)))
/-- unicorn_block, with no axiom. -/
theorem unicorn_block_free (g : World → Prop) (hg : RespectsRecord g) :
¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z) := record_decides_nothing_free g hg
/-- keyless_forces_nothing, with no axiom. -/
theorem keyless_forces_nothing_free (A : World → Prop) (hA : Keyless A) : ¬ Forces A :=
fun h => W2f_not_rh (h W2f W2f_closed (hA W2f))
/-- arrow_forces_nothing, with no axiom. -/
theorem arrow_forces_nothing_free : ¬ Forces (fun _ => ∃ f : Nat → Nat, ∀ a, f a = a) :=
keyless_forces_nothing_free _ arrow_keyless
/-- least_erasure_reads_past_the_record, with no axiom. -/
theorem least_erasure_reads_past_the_record_free : ¬ RespectsRecord LeastErasure := fun h =>
W2f_not_rh ((least_erasure_is_the_value W2f).mp
((h W1 W2f same_record_f).mp ((least_erasure_is_the_value W1).mpr W1_rh)))
/-- The negative instance on the explicit pair world. -/
def negativeInstanceF : ExplicitFormula where
V := Int
le := fun a b => a ≤ b
zero := 0
T := Unit
adj := id
conv := fun _ _ => ()
primeSide := fun _ => -1
zeroSide := fun _ => -1
zeros := W2f
identity := fun _ => rfl
positivity_iff_line :=
⟨fun h => absurd (h ()) (by decide : ¬ ((0 : Int) ≤ -1)), fun h => absurd h W2f_not_rh⟩
/-- positivity_is_keyed, with no axiom. -/
theorem positivity_is_keyed_free : WeilPositive positiveInstance ∧ ¬ WeilPositive negativeInstanceF :=
⟨fun _ => Int.le_refl 0, fun h => absurd (h ()) (by decide : ¬ ((0 : Int) ≤ -1))⟩
/-! ## XIII · The hypothesis on the supplied bit -/
/-- For every explicit formula, Weil positivity is equivalent to the hypothesis for its zeros. -/
theorem spend_is_the_line (E : ExplicitFormula) : WeilPositive E ↔ RH E.zeros :=
E.positivity_iff_line
/-- The free basis holds, and an explicit formula exists on which positivity fails: the free basis
and positivity are distinct. -/
theorem spend_is_not_the_free_basis :
(∀ p q : Nat, isPrime p → isPrime q → p ≠ q →
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0) ∧
∃ E : ExplicitFormula, ¬ WeilPositive E :=
⟨prime_freedom_independent, negativeInstanceF, positivity_is_keyed_free.2⟩
/-- From positivity posited: the line, least erasure, positivity, every zero fixed by the fold and
by registration, and no off-line orbit. -/
theorem rh_on_the_spent_bit (P : PrimeAct) :
RH P.E.zeros ∧ LeastErasure P.E.zeros ∧ WeilPositive P.E ∧
(∀ z, P.E.zeros z → fold z = z) ∧ (∀ z, P.E.zeros z → reg z = z) ∧ ¬ Left P.E.zeros :=
let c := rh_ground_closure_complete P.toActual
⟨c.1, c.2.1, P.positive, c.2.2.1, c.2.2.2.1, c.2.2.2.2⟩
/-- Sections X to XIII, whole. -/
theorem prime_arc_sealed :
(∀ f g : Nat → Int, CompletelyAdditive f → CompletelyAdditive g →
(∀ p, isPrime p → f p = g p) → ∀ n, 0 < n → f n = g n) ∧
(∀ p q : Nat, isPrime p → isPrime q → p ≠ q →
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0) ∧
(∀ Z : World, LeastErasure Z ↔ RH Z) ∧
(∀ E : ExplicitFormula, LeastErasure E.zeros ↔ WeilPositive E) ∧
(∀ E : ExplicitFormula, WeilPositive E ↔ RH E.zeros) ∧
(∀ g : World → Prop, RespectsRecord g → ¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z)) ∧
(∀ A : World → Prop, Keyless A → ¬ Forces A) ∧
(WeilPositive positiveInstance ∧ ¬ WeilPositive negativeInstanceF) ∧
(∃ E : ExplicitFormula, ¬ WeilPositive E) ∧
(∀ P : PrimeAct, RH P.E.zeros) :=
⟨determined_by_primes, prime_freedom_independent, least_erasure_is_the_value,
least_erasure_is_positivity, spend_is_the_line, record_decides_nothing_free,
keyless_forces_nothing_free, positivity_is_keyed_free, spend_is_not_the_free_basis.2,
rh_from_prime_act⟩
/-! ## XIV · The weakest forcing premise; the Li and de Bruijn–Newman coordinates -/
/-- The hypothesis forces the line, and every premise that forces the line implies the hypothesis
on every fold-closed world. -/
theorem rh_is_the_weakest_forcing_premise :
Forces RH ∧ ∀ A : World → Prop, Forces A → ∀ Z, FoldClosed Z → A Z → RH Z :=
⟨fun _ _ h => h, fun _ hA Z hZ ha => hA Z hZ ha⟩
/-- A premise that holds at some fold-closed world where the hypothesis fails does not force. -/
theorem weaker_never_forces (A : World → Prop) (Z : World) (hZ : FoldClosed Z) (ha : A Z)
(hn : ¬ RH Z) : ¬ Forces A :=
fun h => hn (h Z hZ ha)
/-- A premise true on W2f forces nothing. -/
theorem weaker_at_the_twin_never_forces (A : World → Prop) (ha : A W2f) : ¬ Forces A :=
weaker_never_forces A W2f W2f_closed ha W2f_not_rh
/-- A zero set with the signs of its Li coefficients: the hypothesis holds exactly when every
coefficient is non-negative. Carried as a hypothesis (Li 1997; Bombieri and Lagarias 1999). -/
structure LiStream where
zeros : World
nonneg : Nat → Prop
li : RH zeros ↔ ∀ n, 1 ≤ n → nonneg n
theorem rh_from_li (L : LiStream) (h : ∀ n, 1 ≤ n → L.nonneg n) : RH L.zeros := L.li.mpr h
theorem li_is_the_bit_stream (L : LiStream) : (∀ n, 1 ≤ n → L.nonneg n) ↔ RH L.zeros := L.li.symm
/-- For every N there is a Li stream non-negative below N whose zero set lies off the line. -/
theorem li_prefix_never_forces (N : Nat) :
∃ L : LiStream, (∀ n, n < N → L.nonneg n) ∧ ¬ RH L.zeros :=
⟨⟨W2f, fun n => n < N,
⟨fun h => absurd h W2f_not_rh,
fun h => absurd (h (N + 1) (Nat.succ_pos N))
(fun c => Nat.lt_irrefl N (Nat.lt_trans (Nat.lt_succ_self N) c))⟩⟩,
fun _ h => h, W2f_not_rh⟩
/-- The de Bruijn–Newman constant over an ordered type: Λ and its zero, the order's reflexivity and
antisymmetry, 0 ≤ Λ (Rodgers and Tao 2020), and the hypothesis exactly when Λ = 0 (Newman
1976). Every field is carried as a hypothesis. -/
structure DBN (V : Type) [LE V] where
zeros : World
lam : V
zero : V
refl : ∀ a : V, a ≤ a
antisymm : ∀ a b : V, a ≤ b → b ≤ a → a = b
lower : zero ≤ lam
rh_iff : RH zeros ↔ lam = zero
/-- From Λ ≤ 0 and the cited 0 ≤ Λ, the hypothesis. -/
theorem rh_from_the_sign {V : Type} [LE V] (D : DBN V) (h : D.lam ≤ D.zero) : RH D.zeros :=
D.rh_iff.mpr (D.antisymm _ _ h D.lower)
/-- The hypothesis is equivalent to Λ ≤ 0. -/
theorem rh_iff_the_sign {V : Type} [LE V] (D : DBN V) : RH D.zeros ↔ D.lam ≤ D.zero :=
⟨fun h => by rw [D.rh_iff.mp h]; exact D.refl _, rh_from_the_sign D⟩
/-- On one zero set, Weil positivity and Λ ≤ 0 are equivalent. -/
theorem spends_are_one {V : Type} [LE V] (P : PrimeAct) (D : DBN V) (same : D.zeros = P.E.zeros) :
(D.lam ≤ D.zero) ↔ WeilPositive P.E :=
(rh_iff_the_sign D).symm.trans (by rw [same]; exact (spend_is_the_line P.E).symm)
/-- Λ = 0 is realized over W1 and Λ = 1 over W2f: the sign is a property of the world. -/
theorem sign_realized_both_ways :
(∃ D : DBN Int, D.zeros = W1 ∧ D.lam = D.zero) ∧
(∃ D : DBN Int, D.zeros = W2f ∧ ¬ D.lam ≤ D.zero) :=
⟨⟨⟨W1, 0, 0, fun a => Int.le_refl a, fun a b => Int.le_antisymm, Int.le_refl 0,
⟨fun _ => rfl, fun _ => W1_rh⟩⟩, rfl, rfl⟩,
⟨⟨W2f, 1, 0, fun a => Int.le_refl a, fun a b => Int.le_antisymm, by decide,
⟨fun h => absurd h W2f_not_rh, fun h => absurd h (by decide)⟩⟩, rfl, by decide⟩⟩
/-- A self-grounding supply of 0 < 1, with the unit act. -/
def rootSelfGrounding : SelfGrounding ((0 : Int) < 1) := ⟨Unit, (), fun _ => by decide⟩
theorem root_has_an_act : Nonempty rootSelfGrounding.Act := ⟨()⟩
/-- No self-grounding supply of the hypothesis on W2f has an act: W2f fails the hypothesis. -/
theorem line_not_self_grounding : ¬ ∃ G : SelfGrounding (RH W2f), Nonempty G.Act :=
fun ⟨G, ⟨a⟩⟩ => W2f_not_rh (G.instances a)
/-- Section XIV, whole. -/
theorem the_vestigial_posit :
(Forces RH ∧ ∀ A : World → Prop, Forces A → ∀ Z, FoldClosed Z → A Z → RH Z) ∧
(∀ A : World → Prop, A W2f → ¬ Forces A) ∧
(∀ L : LiStream, (∀ n, 1 ≤ n → L.nonneg n) ↔ RH L.zeros) ∧
(∀ N, ∃ L : LiStream, (∀ n, n < N → L.nonneg n) ∧ ¬ RH L.zeros) ∧
(∀ (V : Type) [LE V] (D : DBN V), RH D.zeros ↔ D.lam ≤ D.zero) ∧
((∃ D : DBN Int, D.zeros = W1 ∧ D.lam = D.zero) ∧
(∃ D : DBN Int, D.zeros = W2f ∧ ¬ D.lam ≤ D.zero)) ∧
(∀ (V : Type) [LE V] (P : PrimeAct) (D : DBN V), D.zeros = P.E.zeros →
((D.lam ≤ D.zero) ↔ WeilPositive P.E)) ∧
Nonempty rootSelfGrounding.Act ∧
¬ ∃ G : SelfGrounding (RH W2f), Nonempty G.Act :=
⟨rh_is_the_weakest_forcing_premise, weaker_at_the_twin_never_forces, li_is_the_bit_stream,
li_prefix_never_forces, fun _ _ D => rh_iff_the_sign D, sign_realized_both_ways,
fun _ _ P D same => spends_are_one P D same, root_has_an_act, line_not_self_grounding⟩
/-! ## XV · Four faces in time, exactly one keyed -/
/-- A world in time: the zero set at each instant. -/
abbrev TWorld := Nat → World
/-- The same locus at every instant: the line. -/
def SameLocus (W : TWorld) : Prop := ∀ t z, W t z → (fold z = z ↔ onLine z)
/-- The fold acts at every instant. -/
def FoldInvT (W : TWorld) : Prop := ∀ t, FoldClosed (W t)
/-- The record at every instant lands on the line and forgets the side. -/
def RecordT (W : TWorld) : Prop := ∀ t z, W t z → onLine (reg z) ∧ reg (fold z) = reg z
/-- The arrow at every instant: the free bit is present. -/
def ArrowT (_W : TWorld) : Prop := ∀ _t : Nat, ∃ f : Nat → Nat, ∀ a, f a = a
/-- Timeless: whether the zeros sit on the line does not vary in time. -/
def TimelessT (W : TWorld) : Prop := ∀ t s, RH (W t) ↔ RH (W s)
/-- Bound: the closure at every instant. -/
def BoundT (W : TWorld) : Prop := ∀ t, RH (W t)
/-- The on-line world, constant in time, and the twin, constant in time. -/
abbrev WOn : TWorld := fun _ => W1
abbrev WTwin : TWorld := fun _ => W2f
/-- The fold face holds on every world in time. -/
theorem fold_face_keyless (W : TWorld) : SameLocus W := fun _ z _ => fold_fixed_iff z
theorem fold_face_on_twin : FoldInvT WTwin := fun _ => W2f_closed
theorem fold_face_on_line : FoldInvT WOn := fun _ => W1_closed
/-- The record face holds on every world in time. -/
theorem record_face_keyless (W : TWorld) : RecordT W := fun _ _ _ => ⟨rfl, rfl⟩
/-- The arrow face holds on every world in time. -/
theorem arrow_face_keyless (W : TWorld) : ArrowT W := fun _ => arrow_exists Nat
/-- The closure face holds on WOn. -/
theorem closure_face_on_line : BoundT WOn := fun _ => W1_rh
theorem closure_face_fails_on_twin : ¬ BoundT WTwin := fun h => W2f_not_rh (h 0)
/-- WTwin carries the fold, the record and the arrow at every instant and is timeless, and it is
not bound: of the four faces only the closure is keyed. -/
theorem exactly_one_face_is_keyed :
(SameLocus WTwin ∧ FoldInvT WTwin ∧ RecordT WTwin ∧ ArrowT WTwin ∧ TimelessT WTwin) ∧
¬ BoundT WTwin ∧
(SameLocus WOn ∧ FoldInvT WOn ∧ RecordT WOn ∧ ArrowT WOn ∧ TimelessT WOn) ∧ BoundT WOn :=
⟨⟨fold_face_keyless _, fold_face_on_twin, record_face_keyless _, arrow_face_keyless _,
fun _ _ => Iff.rfl⟩, closure_face_fails_on_twin,
⟨fold_face_keyless _, fold_face_on_line, record_face_keyless _, arrow_face_keyless _,
fun _ _ => Iff.rfl⟩, closure_face_on_line⟩
/-- The arrow, the fold and the record hold on WTwin at every instant while the line fails there:
the arrow is not the line. -/
theorem arrow_is_not_the_line :
ArrowT WTwin ∧ FoldInvT WTwin ∧ RecordT WTwin ∧ ¬ BoundT WTwin :=
⟨arrow_face_keyless _, fold_face_on_twin, record_face_keyless _, closure_face_fails_on_twin⟩
/-- A timeless world is bound exactly when it is bound at instant 0. -/
theorem template_binds_iff_seed (W : TWorld) (u : TimelessT W) : BoundT W ↔ RH (W 0) :=
⟨fun h => h 0, fun s t => (u 0 t).mp s⟩
/-- For a timeless world, bound at instant 0 is the hypothesis at instant 0; WTwin has the three
keyless faces and fails the hypothesis at every instant. -/
theorem the_seed_is_the_spend :
(∀ W : TWorld, TimelessT W → (BoundT W ↔ RH (W 0))) ∧
TimelessT WTwin ∧ ArrowT WTwin ∧ FoldInvT WTwin ∧ RecordT WTwin ∧ ¬ RH (WTwin 0) :=
⟨template_binds_iff_seed, fun _ _ => Iff.rfl, arrow_face_keyless _, fold_face_on_twin,
record_face_keyless _, W2f_not_rh⟩
/-- Section XV, whole. -/
theorem the_template_plugged_in :
((SameLocus WTwin ∧ FoldInvT WTwin ∧ RecordT WTwin ∧ ArrowT WTwin ∧ TimelessT WTwin) ∧
¬ BoundT WTwin ∧
(SameLocus WOn ∧ FoldInvT WOn ∧ RecordT WOn ∧ ArrowT WOn ∧ TimelessT WOn) ∧ BoundT WOn) ∧
(ArrowT WTwin ∧ FoldInvT WTwin ∧ RecordT WTwin ∧ ¬ BoundT WTwin) ∧
(∀ W : TWorld, TimelessT W → (BoundT W ↔ RH (W 0))) ∧
(∀ W : TWorld, BoundT W → ∀ t, LeastErasure (W t)) :=
⟨exactly_one_face_is_keyed, arrow_is_not_the_line, template_binds_iff_seed,
fun W h t => (least_erasure_is_the_value (W t)).mpr (h t)⟩
/-! ## XVI · The eigenstructure of the fold: the side bit and its calibration -/
/-- The displacement x − 1. -/
def oddPart (z : Pt) : Int := z.x - 1
/-- The fold negates the displacement and fixes the height. -/
theorem fold_negates_odd (z : Pt) : oddPart (fold z) = - oddPart z := by
show 2 - z.x - 1 = -(z.x - 1)
rw [Int.neg_sub, Int.sub_sub, Int.add_comm, ← Int.sub_sub]; rfl
theorem fold_keeps_even (z : Pt) : (fold z).t = z.t := rfl
/-- The fold acts as −1 on the displacement. -/
theorem residence_orientation_reversing (z : Pt) : oddPart (fold z) = (-1) * oddPart z := by
rw [fold_negates_odd, Int.neg_one_mul]
/-- Registration sends the displacement to 0, keeps the height, and is idempotent. -/
theorem reg_kills_odd (_z : Pt) : oddPart (reg _z) = 0 := rfl
theorem reg_keeps_even (z : Pt) : (reg z).t = z.t := rfl
theorem reg_idempotent (z : Pt) : reg (reg z) = reg z := rfl
/-- A point is on the line exactly when its displacement is 0. -/
theorem onLine_iff_odd_zero (z : Pt) : onLine z ↔ oddPart z = 0 := Int.sub_eq_zero.symm
/-- The hypothesis: every zero has displacement 0. -/
theorem rh_iff_even_eigenspace (Z : World) : RH Z ↔ ∀ z, Z z → oddPart z = 0 :=
⟨fun h z hz => (onLine_iff_odd_zero z).mp (h z hz), fun h z hz => (onLine_iff_odd_zero z).mpr (h z hz)⟩
/-- Every function of the registered point takes one value on a point and its fold-partner. -/
theorem record_blind_to_odd {β : Type} (g : Pt → β) (z : Pt) : g (reg (fold z)) = g (reg z) := rfl
/-- Off the line a point and its fold-partner have opposite nonzero displacements. -/
theorem odd_pair_opposite (z : Pt) (h : ¬ onLine z) :
oddPart (fold z) = - oddPart z ∧ oddPart z ≠ 0 :=
⟨fold_negates_odd z, fun e => h ((onLine_iff_odd_zero z).mpr e)⟩
/-- The side bit: whether the displacement is negative. -/
def side (z : Pt) : Bool := decide (oddPart z < 0)
/-- Off the line the fold flips the side bit. -/
theorem side_odd_off_line (z : Pt) (h : ¬ onLine z) : side (fold z) = !side z := by
have hne : oddPart z ≠ 0 := (odd_pair_opposite z h).2
unfold side
rw [fold_negates_odd]
exact (Int.decLt (oddPart z) 0).byCases
(fun hl =>
have hp : ¬ (-(oddPart z) < 0) := fun c => Int.lt_irrefl _ (Int.lt_trans c (Int.neg_pos_of_neg hl))
by rw [decide_eq_true hl, decide_eq_false hp]; rfl)
(fun hr =>
have hp : -(oddPart z) < 0 :=
Int.neg_neg_of_pos (Int.lt_iff_le_and_ne.mpr ⟨Int.not_lt.mp hr, Ne.symm hne⟩)
by rw [decide_eq_false hr, decide_eq_true hp]; rfl)
/-- A function invariant under the fold differs from any function that the fold flips at some
point. -/
theorem wall_on_the_chart (f d : Pt → Bool) (z : Pt) (he : ∀ w, f (fold w) = f w)
(ho : d (fold z) ≠ d z) : f ≠ d := by
intro h; subst h; exact ho (he z)
/-- No function of the registered point equals the side bit at an off-line point. -/
theorem record_never_reads_the_side (g : Pt → Bool) (z : Pt) (h : ¬ onLine z) :
(fun w => g (reg w)) ≠ side :=
wall_on_the_chart (fun w => g (reg w)) side z (fun _ => rfl)
(by rw [side_odd_off_line z h]; cases side z <;> decide)
/-- Given the side bit at an off-line point, any function flipped by the fold at that point is
fixed on the orbit by one calibration bit, which exists and is unique. -/
theorem colocation_is_a_calibration (d : Pt → Bool) (z : Pt) (h : ¬ onLine z)
(hd : d (fold z) = !d z) :
∃ c : Bool, (d z = xor (side z) c ∧ d (fold z) = xor (side (fold z)) c) ∧
∀ c', (d z = xor (side z) c' ∧ d (fold z) = xor (side (fold z)) c') → c' = c := by
have hs := side_odd_off_line z h
refine ⟨xor (d z) (side z),
⟨by cases side z <;> cases d z <;> rfl, by rw [hs, hd]; cases side z <;> cases d z <;> rfl⟩, ?_⟩
intro c' hc; obtain ⟨h1, -⟩ := hc
generalize hsx : side z = sv at h1; generalize hdx : d z = dv at h1
cases sv <;> cases dv <;> cases c' <;> first | rfl | exact absurd h1 (by decide)
/-- Both calibration values are realized off the line, by the side bit and by its complement. -/
theorem calibration_realized_both_ways (z : Pt) (h : ¬ onLine z) :
(side (fold z) = !side z ∧ side z = xor (side z) false) ∧
((!side (fold z)) = !(!side z) ∧ (!side z) = xor (side z) true) :=
⟨⟨side_odd_off_line z h, by cases side z <;> rfl⟩,
⟨by rw [side_odd_off_line z h], by cases side z <;> rfl⟩⟩
/-- A proposition implied by its own negation. -/
def SelfVerifyingP (P : Prop) : Prop := ¬P → P
/-- The hypothesis on a world implies its self-verification there. -/
theorem value_is_recursion (Z : World) (h : RH Z) : SelfVerifyingP (RH Z) := fun _ => h
theorem recursion_is_value (Z : World) (h : SelfVerifyingP (RH Z)) : ¬¬ RH Z := fun n => n (h n)
/-- Self-verification of the hypothesis holds on W1 and fails on W2f. -/
theorem recursion_on_the_line : SelfVerifyingP (RH W1) := fun _ => W1_rh
theorem recursion_fails_on_the_twin : ¬ SelfVerifyingP (RH W2f) := fun h => W2f_not_rh (h W2f_not_rh)
/-- Self-verification of 0 < 1. -/
theorem root_recursion : SelfVerifyingP ((0 : Int) < 1) := fun _ => by decide
/-- Least erasure on a world implies self-verification of the hypothesis there, and conversely up
to double negation. -/
theorem least_erasure_is_the_recursion (Z : World) :
(LeastErasure Z → SelfVerifyingP (RH Z)) ∧ (SelfVerifyingP (RH Z) → ¬¬ LeastErasure Z) :=
⟨fun h => value_is_recursion Z ((least_erasure_is_the_value Z).mp h),
fun h n => recursion_is_value Z h (fun r => n ((least_erasure_is_the_value Z).mpr r))⟩
/-- Section XVI, whole. -/
theorem the_mirror_at_minus_one :
(∀ z, oddPart (fold z) = (-1) * oddPart z ∧ (fold z).t = z.t) ∧
(∀ z, oddPart (reg z) = 0 ∧ (reg z).t = z.t ∧ reg (reg z) = reg z) ∧
(∀ Z : World, RH Z ↔ ∀ z, Z z → oddPart z = 0) ∧
(∀ (g : Pt → Bool) (z : Pt), ¬ onLine z → (fun w => g (reg w)) ≠ side) ∧
(∀ (d : Pt → Bool) (z : Pt), ¬ onLine z → d (fold z) = !d z →
∃ c : Bool, (d z = xor (side z) c ∧ d (fold z) = xor (side (fold z)) c) ∧
∀ c', (d z = xor (side z) c' ∧ d (fold z) = xor (side (fold z)) c') → c' = c) ∧
(SelfVerifyingP (RH W1) ∧ ¬ SelfVerifyingP (RH W2f) ∧ SelfVerifyingP ((0 : Int) < 1)) ∧
(∀ Z : World, (LeastErasure Z → SelfVerifyingP (RH Z)) ∧ (SelfVerifyingP (RH Z) → ¬¬ LeastErasure Z)) :=
⟨fun z => ⟨residence_orientation_reversing z, fold_keeps_even z⟩,
fun z => ⟨reg_kills_odd z, reg_keeps_even z, reg_idempotent z⟩,
rh_iff_even_eigenspace, record_never_reads_the_side, colocation_is_a_calibration,
⟨recursion_on_the_line, recursion_fails_on_the_twin, root_recursion⟩,
least_erasure_is_the_recursion⟩
/-! ## XVII · Admissible coalitions, the certified height, the heat flow, the Liouville arrow, five readings, the reader index -/
/-! ### XVII.a · Admissible coalitions -/
/-- A premise is admissible when it is keyless or a reading of the record. -/
def Admissible (A : World → Prop) : Prop := Keyless A ∨ RespectsRecord A
/-- An admissible premise that holds on W1 holds on W2f. -/
theorem admissible_transfers (A : World → Prop) (h : Admissible A) (h1 : A W1) : A W2f := by
rcases h with k | r
· exact k W2f
· exact (r W1 W2f same_record_f).mp h1
/-- Three admissible premises true on W1 are true on W2f, so their conjunction forces nothing. -/
theorem no_admissible_triad_forces (A B C : World → Prop)
(hA : Admissible A) (hB : Admissible B) (hC : Admissible C) (h : A W1 ∧ B W1 ∧ C W1) :
¬ Forces (fun Z => A Z ∧ B Z ∧ C Z) :=
fun f => W2f_not_rh (f W2f W2f_closed
⟨admissible_transfers A hA h.1, admissible_transfers B hB h.2.1, admissible_transfers C hC h.2.2⟩)
/-- A list of admissible premises true on W1 forces nothing. -/
theorem no_admissible_coalition_forces (L : List (World → Prop))
(hL : ∀ A ∈ L, Admissible A) (h1 : ∀ A ∈ L, A W1) :
¬ Forces (fun Z => ∀ A ∈ L, A Z) :=
fun f => W2f_not_rh (f W2f W2f_closed (fun A hA => admissible_transfers A (hL A hA) (h1 A hA)))
/-- Least erasure is not admissible: it fails on W2f and is not a reading of the record. -/
theorem spend_is_not_admissible : ¬ Admissible LeastErasure := by
intro h
rcases h with k | r
· exact W2f_not_rh ((least_erasure_is_the_value W2f).mp (k W2f))
· exact least_erasure_reads_past_the_record_free r
/-- Three predicates on a point: the freedom axis, always true; the seat axis, the point is fixed
by the fold; the collapse axis, the displacement equals its own negative. -/
def freedomAxis (_ : Pt) : Prop := True
def ramAxis (z : Pt) : Prop := fold z = z
def collapseAxis (z : Pt) : Prop := oddPart z = - oddPart z
/-- All three axes hold at a point exactly when it lies on the line. -/
theorem three_axis_lock (z : Pt) : (freedomAxis z ∧ ramAxis z ∧ collapseAxis z) ↔ onLine z := by
constructor
· intro ⟨_, h, _⟩
exact (fold_fixed_iff z).mp h
· intro h
refine ⟨trivial, (fold_fixed_iff z).mpr h, ?_⟩
have e : oddPart z = 0 := (onLine_iff_odd_zero z).mp h
unfold collapseAxis
omega
/-- The freedom axis holds at an off-line point. -/
theorem freedom_alone_open : freedomAxis ⟨0, 14⟩ ∧ ¬ onLine ⟨0, 14⟩ :=
⟨trivial, by decide⟩
/-! ### XVII.b · The certified height -/
/-- The zeros certified on the line up to height T. -/
def LineBelow (T : Nat) : World := fun z => z.x = 1 ∧ z.t ≤ T
/-- The same zeros, with one off-line pair just above the certified height. -/
def TwinAbove (T : Nat) : World := fun z => (z.x = 1 ∧ z.t ≤ T) ∨ (z = ⟨0, T+1⟩ ∨ z = ⟨2, T+1⟩)
/-- For every T the world certified to T lies on the line, and a fold-closed world agrees with it
at every height up to T and carries an off-line pair above T. The certificate of Platt and
Trudgian (2021) to height 3·10¹² is such a T. -/
theorem certified_height_never_forces (T : Nat) :
RH (LineBelow T) ∧ FoldClosed (TwinAbove T) ∧ ¬ RH (TwinAbove T) ∧
∀ z, z.t ≤ T → (TwinAbove T z ↔ LineBelow T z) := by
refine ⟨fun z hz => hz.1, ?_, ?_, ?_⟩
· intro z hz
rcases hz with ⟨h1, h2⟩ | h | h
· exact Or.inl ⟨show 2 - z.x = 1 by omega, h2⟩
· subst h
exact Or.inr (Or.inr rfl)
· subst h
exact Or.inr (Or.inl rfl)
· intro h
have h0 : (0 : Int) = 1 := h ⟨0, T+1⟩ (Or.inr (Or.inl rfl))
exact absurd h0 (by decide)
· intro z hz
constructor
· intro h
rcases h with h | h | h
· exact h
· subst h
have : T + 1 ≤ T := hz
omega
· subst h
have : T + 1 ≤ T := hz
omega
· intro h
exact Or.inl h
/-- Below T the certified world and its twin have the same record. -/
theorem certified_worlds_share_the_record_below (T : Nat) (r : Pt) (hr : r.t ≤ T) :
recordOf (LineBelow T) r ↔ recordOf (TwinAbove T) r := by
constructor
· intro ⟨s, hs, hsr⟩
exact ⟨s, Or.inl hs, hsr⟩
· intro ⟨s, hs, hsr⟩
rcases hs with h | h | h
· exact ⟨s, h, hsr⟩
· subst h
have e : (T + 1 : Nat) = r.t := congrArg Pt.t hsr
omega
· subst h
have e : (T + 1 : Nat) = r.t := congrArg Pt.t hsr
omega
/-! ### XVII.c · The heat flow on polynomials: under ∂ₜH = −∂ₓ²H the constant term of z² + bz + c moves to c − 2t and the discriminant rises by 8t -/
namespace HeatFlow
theorem sq_nonneg (x : Int) : 0 ≤ x * x := by
cases Int.le_total 0 x with
| inl h => exact Int.mul_nonneg h h
| inr h =>
have hn : 0 ≤ -x := by omega
have := Int.mul_nonneg hn hn
rw [Int.neg_mul_neg] at this
exact this
theorem cube_diff (u k : Int) :
u*u*u - (u-k)*(u-k)*(u-k) = 3*(u*u*k) - 3*(u*k*k) + k*k*k := by
simp only [Int.sub_mul, Int.mul_sub, Int.mul_assoc]
simp only [Int.mul_comm k u, Int.mul_left_comm k u]
omega
/-- Discriminant of z² + bz + c. -/
def disc (b c : Int) : Int := b*b - 4*c
/-- The flow on the constant term: exp(−tD²)(z² + bz + c) = z² + bz + (c − 2t). -/
def flowC (c t : Int) : Int := c - 2*t
/-- Real-rooted at time t: the flowed discriminant is nonnegative. -/
def RR (b c t : Int) : Prop := 0 ≤ disc b (flowC c t)
instance (b c t : Int) : Decidable (RR b c t) := inferInstanceAs (Decidable (0 ≤ disc b (flowC c t)))
/-- disc(t) = disc(0) + 8t. -/
theorem disc_flow (b c t : Int) : disc b (flowC c t) = disc b c + 8*t := by
unfold disc flowC; omega
/-- Real-rootedness is preserved forward in time. -/
theorem forward_preserves (b c s t : Int) (hst : s ≤ t) (h : RR b c s) : RR b c t := by
unfold RR at *; rw [disc_flow] at *; omega
/-- Every quadratic is real-rooted after some finite time. -/
theorem erasure_finite (b c : Int) : ∃ t, 0 ≤ t ∧ RR b c t :=
⟨(disc b c).natAbs, by omega, by unfold RR; rw [disc_flow]; omega⟩
/-- The least erasure time, Λ of the quadratic: 0 if already real-rooted, else ⌈−disc/8⌉. -/
def lam (b c : Int) : Int := if 0 ≤ disc b c then 0 else (7 - disc b c) / 8
theorem lam_nonneg (b c : Int) : 0 ≤ lam b c := by
unfold lam; split <;> omega
/-- At time Λ the quadratic is real-rooted. -/
theorem real_at_lam (b c : Int) : RR b c (lam b c) := by
unfold RR lam; rw [disc_flow]; split <;> omega
/-- If Λ > 0, the quadratic is not real-rooted at time Λ − 1. -/
theorem lam_least (b c : Int) (h : 0 < lam b c) : ¬ RR b c (lam b c - 1) := by
unfold RR; rw [disc_flow]; unfold lam at *; split at * <;> omega
/-- Λ = 0 exactly when the quadratic is real-rooted at time 0. -/
theorem lam_zero_iff_real (b c : Int) : lam b c = 0 ↔ RR b c 0 := by
unfold RR lam; rw [disc_flow]; split <;> omega
/-- For z² + c the squared imaginary part of the roots is max(c − 2t, 0): de Bruijn's bound holds
with equality. -/
def imSq (c t : Int) : Int := max (flowC c t) 0
theorem de_bruijn_tight (c t : Int) (ht : 0 ≤ t) : imSq c t = max (imSq c 0 - 2*t) 0 := by
unfold imSq flowC; omega
/-- For z² + 2k the roots are ±√(2t − 2k): at t = k they meet at 0. -/
def rootSq (c t : Int) : Int := 2*t - c
theorem collision (k t : Int) :
rootSq (2*k) k = 0 ∧ (t < k → rootSq (2*k) t < 0) ∧ (k < t → 0 < rootSq (2*k) t) ∧
rootSq (2*k) (t+1) = rootSq (2*k) t + 2 := by
unfold rootSq; omega
/-- Discriminant of z³ + pz + q. -/
def disc3 (p q : Int) : Int := -4*(p*p*p) - 27*(q*q)
/-- The flow on the linear coefficient: exp(−tD²)(z³ + pz + q) = z³ + (p − 6t)z + q. -/
def flowP (p t : Int) : Int := p - 6*t
/-- One time step raises the cubic discriminant by 72((u − 3)² + 3), u the current linear
coefficient. -/
theorem disc3_step (p q t : Int) :
disc3 (flowP p (t+1)) q - disc3 (flowP p t) q = 72*((p - 6*t - 3)*(p - 6*t - 3) + 3) := by
have key : ∀ u k : Int, u*u*u - (u-k)*(u-k)*(u-k) = 3*(u*u*k) - 3*(u*k*k) + k*k*k := by
intro u k
simp only [Int.sub_mul, Int.mul_sub, Int.mul_assoc]
simp only [Int.mul_comm k u, Int.mul_left_comm k u]
omega
have h := key (p - 6*t) 6
have e0 : flowP p (t+1) = (p - 6*t) - 6 := by unfold flowP; omega
have e1 : (p - 6*t)*(p - 6*t)*6 = 6*((p - 6*t)*(p - 6*t)) := Int.mul_comm _ _
have e2 : (p - 6*t)*6*6 = 36*(p - 6*t) := by rw [Int.mul_assoc, Int.mul_comm]; rfl
have e3 : (p - 6*t - 3)*(p - 6*t - 3) = (p - 6*t)*(p - 6*t) - 6*(p - 6*t) + 9 := by
generalize p - 6*t = u
simp only [Int.sub_mul, Int.mul_sub]; rw [Int.mul_comm 3 u]; omega
have e4 : (6:Int)*6*6 = 216 := by decide
rw [e1, e2, e4] at h
unfold disc3; rw [e0, e3]
have e5 : flowP p t = p - 6*t := rfl
rw [e5]
omega
/-- The cubic discriminant strictly increases with time. -/
theorem disc3_strict (p q t : Int) : disc3 (flowP p t) q < disc3 (flowP p (t+1)) q := by
have h := disc3_step p q t
have := sq_nonneg (p - 6*t - 3)
omega
/-- Over any number of steps the cubic discriminant never falls. -/
theorem disc3_monotone_rec (p q : Int) : ∀ n : Nat, disc3 (flowP p 0) q ≤ disc3 (flowP p n) q := by
intro n
induction n with
| zero => exact Int.le_refl _
| succ n ih =>
have st := disc3_strict p q (n : Int)
have e : ((n + 1 : Nat) : Int) = (n : Int) + 1 := by omega
rw [e]; omega
/-- disc3_monotone_rec, restated. -/
theorem disc3_monotone (p q : Int) (n : Nat) : disc3 (flowP p 0) q ≤ disc3 (flowP p n) q :=
disc3_monotone_rec p q n
theorem cubic_forward_preserves (p q : Int) (h : 0 ≤ disc3 (flowP p 0) q) (n : Nat) :
0 ≤ disc3 (flowP p n) q := Int.le_trans h (disc3_monotone_rec p q n)
/-- The flow is injective on the constant term: the polynomial at time t determines the polynomial
at time 0. -/
theorem flow_injective (c c' t : Int) (h : flowC c t = flowC c' t) : c = c' := by
unfold flowC at h; omega
/-- At every positive time there are two quadratics real-rooted at t, one real-rooted at 0 and one
not. -/
theorem certificate_two_worlds (t : Int) (ht : 0 < t) :
RR 0 0 t ∧ RR 0 t t ∧ RR 0 0 0 ∧ ¬ RR 0 t 0 := by
unfold RR; simp only [disc_flow]; unfold disc; omega
/-- No function of real-rootedness at time t returns real-rootedness at time 0 on every quadratic. -/
theorem certificate_decides_nothing (t : Int) (ht : 0 < t) :
¬ ∃ g : Bool → Bool, ∀ b c : Int, g (decide (RR b c t)) = decide (RR b c 0) := by
intro ⟨g, hg⟩
have ⟨h1, h2, h3, h4⟩ := certificate_two_worlds t ht
have a := hg 0 0
have b := hg 0 t
rw [decide_eq_true h1, decide_eq_true h3] at a
rw [decide_eq_true h2, decide_eq_false h4] at b
rw [a] at b
exact Bool.noConfusion b
/-- For every t > 0 some quadratic is real-rooted from t on and not at 0, with Λ > 0. -/
theorem certification_never_forces (t : Int) (ht : 0 < t) :
∃ c : Int, (∀ s, t ≤ s → RR 0 c s) ∧ ¬ RR 0 c 0 ∧ 0 < lam 0 c :=
⟨t, fun s hs => forward_preserves 0 t t s hs (certificate_two_worlds t ht).2.1,
(certificate_two_worlds t ht).2.2.2,
by unfold lam disc; split <;> omega⟩
/-- A double root is real-rooted at 0 with Λ = 0, and not real-rooted at any earlier time. -/
theorem zero_slack (a : Int) :
RR (2*a) (a*a) 0 ∧ lam (2*a) (a*a) = 0 ∧ ∀ s, 0 < s → ¬ RR (2*a) (a*a) (-s) := by
have hd : disc (2*a) (a*a) = 0 := by
unfold disc; rw [Int.mul_assoc, Int.mul_left_comm a 2 a]; omega
refine ⟨?_, ?_, ?_⟩
· unfold RR; rw [disc_flow, hd]; omega
· unfold lam; rw [hd]; simp
· intro s hs; unfold RR; rw [disc_flow, hd]; omega
/-- A quadratic real-rooted at time 1 may or may not be real-rooted at time 0: z² − 2 is, z² + 2 is
not. -/
theorem backward_not_forced : RR 0 (-2) 1 ∧ RR 0 2 1 ∧ RR 0 (-2) 0 ∧ ¬ RR 0 2 0 := by
unfold RR; simp only [disc_flow]; unfold disc; decide
/-- The largest Λ over a family of quadratics. -/
def famLam : List (Int × Int) → Int
| [] => 0
| (b, c) :: r => max (lam b c) (famLam r)
theorem famLam_nonneg_rec : ∀ F : List (Int × Int), 0 ≤ famLam F := by
intro F
induction F with
| nil => exact Int.le_refl 0
| cons m r ih =>
obtain ⟨b, c⟩ := m
unfold famLam; omega
theorem family_least_erasure_rec :
∀ F : List (Int × Int), famLam F = 0 ↔ ∀ m ∈ F, RR m.1 m.2 0 := by
intro F
induction F with
| nil => simp [famLam]
| cons m r ih =>
obtain ⟨b, c⟩ := m
have hn := famLam_nonneg_rec r
have hl := lam_nonneg b c
have hz := lam_zero_iff_real b c
constructor
· intro h m hm
unfold famLam at h
cases hm with
| head => exact hz.mp (by omega)
| tail _ hm' => exact ih.mp (by omega) m hm'
· intro h
have h1 : lam b c = 0 := hz.mpr (h (b, c) (List.Mem.head r))
have h2 : famLam r = 0 := ih.mpr (fun m hm => h m (List.Mem.tail _ hm))
unfold famLam; omega
/-- The family's Λ is 0 exactly when every member is real-rooted at time 0. -/
theorem family_least_erasure (F : List (Int × Int)) : famLam F = 0 ↔ ∀ m ∈ F, RR m.1 m.2 0 :=
family_least_erasure_rec F
end HeatFlow
/-- Real-rootedness at time 0 is exactly Λ ≤ 0, since 0 ≤ Λ. -/
theorem heat_bit_is_one_inequality (b c : Int) : HeatFlow.RR b c 0 ↔ HeatFlow.lam b c ≤ 0 := by
have h1 := HeatFlow.lam_nonneg b c
have h2 := HeatFlow.lam_zero_iff_real b c
constructor
· intro h
have := h2.mpr h
omega
· intro h
exact h2.mp (by omega)
/-- Over a family, every member is real-rooted at time 0 exactly when the family's Λ ≤ 0. -/
theorem family_bit_is_one_inequality (F : List (Int × Int)) :
(∀ m ∈ F, HeatFlow.RR m.1 m.2 0) ↔ HeatFlow.famLam F ≤ 0 := by
have h1 := HeatFlow.famLam_nonneg_rec F
have h2 := HeatFlow.family_least_erasure F
constructor
· intro h
have := h2.mpr h
omega
· intro h
exact h2.mp (by omega)
/-- The de Bruijn–Newman structure and the quadratic model satisfy the same equivalences, the model
with its lower bound proved. -/
theorem heat_model_reads_as_the_carrier {V : Type} [LE V] (D : DBN V) (b c : Int) :
(RH D.zeros ↔ D.lam ≤ D.zero) ∧ (HeatFlow.RR b c 0 ↔ HeatFlow.lam b c ≤ 0) ∧
(0 ≤ HeatFlow.lam b c) :=
⟨rh_iff_the_sign D, heat_bit_is_one_inequality b c, HeatFlow.lam_nonneg b c⟩
/-! ### XVII.d · The Liouville arrow λ(n) = (−1)^Ω(n), computed -/
namespace Liouville
/-- Ω, the number of prime factors with multiplicity, by trial division. -/
def omegaF : Nat → Nat → Nat → Nat
| 0, _, _ => 0
| fuel + 1, n, d =>
if n ≤ 1 then 0
else if d * d > n then 1
else if n % d = 0 then 1 + omegaF fuel (n / d) d
else omegaF fuel n (d + 1)
def bigOmega (n : Nat) : Nat := omegaF (2 * n + 2) n 2
/-- The arrow λ(n) = (−1)^Ω(n). -/
def lam (n : Nat) : Int := if bigOmega n % 2 = 0 then 1 else -1
/-- λ(ab) = λ(a)λ(b) on 1..40 × 1..40. -/
theorem lam_mult : ((List.range 40).all fun a => (List.range 40).all fun b =>
lam ((a+1)*(b+1)) == lam (a+1) * lam (b+1)) = true := by decide
/-- λ(p) = −1 for every prime p below 100. -/
theorem lam_flips_at_primes :
([2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97].all fun p => lam p == -1) = true := by
decide
def L : Nat → Int
| 0 => 0
| n + 1 => L n + lam (n + 1)
/-- L(x) = Σ_{n ≤ x} λ(n) ≤ 0 for 2 ≤ x ≤ 200. The inequality fails at x = 906,150,257 (Haselgrove
1958; Tanaka 1980). -/
theorem polya_holds_to_200 : ((List.range 199).all fun k => decide (L (k + 2) ≤ 0)) = true := by decide
end Liouville
/-- λ is the sign arrow of the computed count Ω. -/
theorem liouville_is_the_sign_arrow (n : Nat) : Liouville.lam n = signArrow (Liouville.bigOmega n) := rfl
/-- A zero set with the faithfulness of λ: the hypothesis holds exactly when L(x) = O(x^{1/2+ε})
for every ε > 0. Carried as a hypothesis (Landau 1899). -/
structure LiouvilleFace where
zeros : World
faithful : Prop
faithful_iff : RH zeros ↔ faithful
theorem rh_from_faithful (F : LiouvilleFace) (h : F.faithful) : RH F.zeros := F.faithful_iff.mpr h
theorem faithful_is_the_bit (F : LiouvilleFace) : F.faithful ↔ RH F.zeros := F.faithful_iff.symm
/-- On one zero set, Weil positivity, Λ ≤ 0, the non-negativity of the Li stream and the
faithfulness of λ are equivalent, each cited equivalence entering as a field. -/
theorem the_posit_in_every_coordinate {V : Type} [LE V] (P : PrimeAct) (D : DBN V) (Li : LiStream)
(F : LiouvilleFace) (hD : D.zeros = P.E.zeros) (hL : Li.zeros = P.E.zeros)
(hF : F.zeros = P.E.zeros) :
(WeilPositive P.E ↔ D.lam ≤ D.zero) ∧ (WeilPositive P.E ↔ ∀ n, 1 ≤ n → Li.nonneg n) ∧
(WeilPositive P.E ↔ F.faithful) := by
have hW : WeilPositive P.E ↔ RH P.E.zeros := spend_is_the_line P.E
refine ⟨?_, ?_, ?_⟩
· rw [hW, ← hD]
exact rh_iff_the_sign D
· rw [hW, ← hL]
exact (li_is_the_bit_stream Li).symm
· rw [hW, ← hF]
exact F.faithful_iff
/-! ### XVII.e · Five readings, one proposition -/
/-- Lossless registration: every zero is fixed by registration. -/
def Lossless (Z : World) : Prop := ∀ z, Z z → reg z = z
/-- Every zero has displacement 0. -/
def DepthZero (Z : World) : Prop := ∀ z, Z z → oddPart z = 0
/-- The Li mode of a zero, in the chart's own scale: |ρ − 1|² and |ρ|² doubled. -/
def N1 (z : Pt) : Int := (z.x - 2)*(z.x - 2) + 4*((z.t : Int)*(z.t : Int))
def N0 (z : Pt) : Int := z.x*z.x + 4*((z.t : Int)*(z.t : Int))
/-- Stability: no Li mode grows. -/
def Stable (Z : World) : Prop := ∀ z, Z z → N1 z ≤ N0 z
theorem modes (z : Pt) : N1 z - N0 z = 4 - 4 * z.x := by
simp only [N1, N0, Int.sub_mul, Int.mul_sub]
omega
/-- Registration fixes a zero exactly when the zero lies on the line. -/
theorem lossless_iff_rh (Z : World) : Lossless Z ↔ RH Z := by
constructor
· intro h z hz
have e := congrArg Pt.x (h z hz)
exact e.symm
· intro h z hz
exact reg_fixes_line z (h z hz)
/-- On a fold-closed world, stability of every Li mode is the line: a mode below the line grows,
and its fold-partner stands above. -/
theorem stable_iff_rh (Z : World) (hZ : FoldClosed Z) : Stable Z ↔ RH Z := by
constructor
· intro h z hz
have a := h z hz
have b := h (fold z) (hZ z hz)
have ea := modes z
have eb := modes (fold z)
have ex : (fold z).x = 2 - z.x := rfl
rw [ex] at eb
show z.x = 1
omega
· intro h z hz
have e : z.x = 1 := h z hz
have := modes z
omega
/-- On every fold-closed world the line, lossless registration, displacement zero, no left zero,
the stability of every Li mode and least erasure are equivalent. -/
theorem five_readings_agree (Z : World) (hZ : FoldClosed Z) :
(RH Z ↔ Lossless Z) ∧ (RH Z ↔ DepthZero Z) ∧ (RH Z ↔ ¬ Left Z) ∧
(RH Z ↔ Stable Z) ∧ (RH Z ↔ LeastErasure Z) :=
⟨(lossless_iff_rh Z).symm, rh_iff_even_eigenspace Z, rh_iff_no_left Z hZ,
(stable_iff_rh Z hZ).symm, (least_erasure_is_the_value Z).symm⟩
/-- And no record-respecting reading returns any of the five, since each is the hypothesis. -/
theorem no_record_reading_returns_any_face (g : World → Prop) (hg : RespectsRecord g) :
¬ (∀ Z, FoldClosed Z → (g Z ↔ Lossless Z)) ∧ ¬ (∀ Z, FoldClosed Z → (g Z ↔ Stable Z)) := by
constructor
· intro h
exact record_decides_nothing_free g hg (fun Z hZ => (h Z hZ).trans (lossless_iff_rh Z))
· intro h
exact record_decides_nothing_free g hg (fun Z hZ => (h Z hZ).trans (stable_iff_rh Z hZ))
/-! ### XVII.f · The supply has no reader index -/
/-- A proposition indexed by a type of readers, constant. -/
def Requirement (Reader : Type) (V : Prop) : Reader → Prop := fun _ => V
/-- Every reader faces the same proposition. -/
theorem same_for_every_reader {Reader : Type} (V : Prop) (a b : Reader) :
Requirement Reader V a ↔ Requirement Reader V b := Iff.rfl
/-- A requirement that differs between two readers is not the fixed value. -/
theorem no_private_bit {Reader : Type} (V : Prop) (R : Reader → Prop) (hR : ∀ r, R r ↔ V)
(a b : Reader) : R a ↔ R b := (hR a).trans (hR b).symm
/-- A reader-indexed requirement equal to Weil positivity for every reader is the same for all
readers. -/
theorem spend_has_no_reader {Reader : Type} (P : PrimeAct) (R : Reader → Prop)
(hR : ∀ r, R r ↔ WeilPositive P.E) (a b : Reader) : R a ↔ R b :=
no_private_bit (WeilPositive P.E) R hR a b
/-! ### XVII.g · Section XVII, whole -/
/-- Section XVII, whole. -/
theorem the_harvest :
(∀ (L : List (World → Prop)), (∀ A ∈ L, Admissible A) → (∀ A ∈ L, A W1) →
¬ Forces (fun Z => ∀ A ∈ L, A Z)) ∧
¬ Admissible LeastErasure ∧
(∀ T : Nat, RH (LineBelow T) ∧ FoldClosed (TwinAbove T) ∧ ¬ RH (TwinAbove T)) ∧
(∀ b c : Int, (HeatFlow.RR b c 0 ↔ HeatFlow.lam b c ≤ 0) ∧ 0 ≤ HeatFlow.lam b c) ∧
(∀ t : Int, 0 < t → ¬ ∃ g : Bool → Bool, ∀ b c : Int,
g (decide (HeatFlow.RR b c t)) = decide (HeatFlow.RR b c 0)) ∧
(∀ n : Nat, Liouville.lam n = signArrow (Liouville.bigOmega n)) ∧
(∀ Z : World, FoldClosed Z →
(RH Z ↔ Lossless Z) ∧ (RH Z ↔ DepthZero Z) ∧ (RH Z ↔ ¬ Left Z) ∧
(RH Z ↔ Stable Z) ∧ (RH Z ↔ LeastErasure Z)) ∧
(∀ {Reader : Type} (P : PrimeAct) (R : Reader → Prop),
(∀ r, R r ↔ WeilPositive P.E) → ∀ a b : Reader, R a ↔ R b) :=
⟨no_admissible_coalition_forces, spend_is_not_admissible,
fun T => ⟨(certified_height_never_forces T).1, (certified_height_never_forces T).2.1,
(certified_height_never_forces T).2.2.1⟩,
fun b c => ⟨heat_bit_is_one_inequality b c, HeatFlow.lam_nonneg b c⟩,
HeatFlow.certificate_decides_nothing, liouville_is_the_sign_arrow, five_readings_agree,
fun P R hR a b => spend_has_no_reader P R hR a b⟩
/-! ## XVIII · A theory placed on three strata; the root; the two can'ts; the round trip; the ladder blocked -/
/-! ### XVIII.a · Placement: computation, provability, truth -/
/-- A theory: its sentences, what it proves, what finite computation settles, what holds in its
intended model. -/
structure Theory where
Sent : Type
Prov : Sent → Prop
Comp : Sent → Prop
True_ : Sent → Prop
/-- Σ₁-completeness, abstractly: what finite computation settles, the theory proves. -/
def RungOnLadder (T : Theory) : Prop := ∀ s, T.Comp s → T.Prov s
/-- Soundness: what the theory proves holds in its intended model. -/
def Sound (T : Theory) : Prop := ∀ s, T.Prov s → T.True_ s
/-- Under Σ₁-completeness and soundness: what computation settles the theory proves, what the
theory proves holds, and what computation settles holds. -/
theorem placement (T : Theory) (hR : RungOnLadder T) (hS : Sound T) :
(∀ s, T.Comp s → T.Prov s) ∧ (∀ s, T.Prov s → T.True_ s) ∧ (∀ s, T.Comp s → T.True_ s) :=
⟨hR, hS, fun s h => hS s (hR s h)⟩
/-- An unsound theory: it proves everything and its model refutes half of it. -/
def unsound : Theory := ⟨Bool, fun _ => True, fun _ => False, fun b => b = true⟩
/-- The unsound theory is Σ₁-complete and not sound. -/
theorem soundness_is_load_bearing : RungOnLadder unsound ∧ ¬ Sound unsound := by
refine ⟨fun _ h => h.elim, fun h => ?_⟩
have := h false trivial
cases this
/-- A sound incomplete theory: true on both sentences, proving one. -/
def incomplete : Theory := ⟨Bool, fun b => b = true, fun _ => False, fun _ => True⟩
/-- A sound theory can leave a truth unproved. -/
theorem ground_exceeds_ladder :
Sound incomplete ∧ incomplete.True_ false ∧ ¬ incomplete.Prov false :=
⟨fun _ _ => trivial, trivial, fun h => Bool.noConfusion h⟩
/-- Independent axioms are separate bits: every combination of two values is realized. -/
theorem independent_axioms_are_separate_bits :
∀ a b : Bool, ∃ w : Bool × Bool, w.1 = a ∧ w.2 = b :=
fun a b => ⟨(a, b), rfl, rfl⟩
/-! ### XVIII.b · The root crosses every keyless sentence and no keyed one -/
/-- Over any type of worlds: a sentence is keyless when every world has it, keyed when some world
lacks it. -/
def KeylessOn {W : Type} (P : W → Prop) : Prop := ∀ w, P w
def KeyedOn {W : Type} (P : W → Prop) : Prop := ∃ w, ¬ P w
/-- The root proposition, 0 < 1. -/
def RootAct : Prop := (0 : Int) < 1
theorem root_act : RootAct := show (0 : Int) < 1 by decide
/-- The root is keyless over every type of worlds. -/
theorem root_is_keyless {W : Type} : KeylessOn (fun _ : W => RootAct) := fun _ => root_act
/-- The root implies every keyless sentence on every world. -/
theorem keyless_crosses {W : Type} (P : W → Prop) (hP : KeylessOn P) : ∀ w, RootAct → P w :=
fun w _ => hP w
/-- The root does not imply a keyed sentence on every world. -/
theorem root_decides_no_keyed {W : Type} (P : W → Prop) (hK : KeyedOn P) :
¬ ∀ w, RootAct → P w :=
fun h => hK.elim (fun w hw => hw (h w root_act))
/-- Choice over ZF as a keyed sentence: two worlds, one each way (Gödel 1938; Cohen 1963). -/
def choiceHolds : Bool → Prop := fun w => w = true
theorem choice_is_keyed : KeyedOn choiceHolds := ⟨false, fun h => Bool.noConfusion h⟩
theorem root_does_not_cross_choice :
(∀ _w : Bool, RootAct) ∧ choiceHolds true ∧ ¬ choiceHolds false :=
⟨fun _ => root_act, rfl, fun h => Bool.noConfusion h⟩
/-- The hypothesis is keyed over the worlds of the chart. -/
theorem line_is_keyed_over_worlds : KeyedOn RH ∧ ∃ Z, FoldClosed Z ∧ RH Z :=
⟨⟨W2f, W2f_not_rh⟩, ⟨W1, W1_closed, W1_rh⟩⟩
/-- The root does not imply the hypothesis on every world. -/
theorem root_does_not_cross_the_line : ¬ ∀ Z : World, RootAct → RH Z :=
root_decides_no_keyed RH line_is_keyed_over_worlds.1
/-! ### XVIII.c · The two can'ts of a foundation are not mirror images -/
/-- A hypothesis with a provability predicate, Σ₁-completeness on the denial (a false Π⁰₁
hypothesis has a finite witness, which the theory proves: Davis, Matiyasevich and Robinson
1976; Lagarias 2002) and soundness on the denial, both carried as hypotheses. -/
structure Setting where
hyp : Prop
Prov : Prop → Prop
sigma1 : ¬ hyp → Prov (¬ hyp)
sound_neg : Prov (¬ hyp) → ¬ hyp
/-- On the chart one off-line zero refutes the hypothesis. -/
theorem refutation_is_one_point (Z : World) (z : Pt) (hz : Z z) (h : ¬ onLine z) : ¬ RH Z :=
fun r => h (r z hz)
/-- If the theory cannot refute the hypothesis, the hypothesis holds. -/
theorem cant_refute_seals (S : Setting) (h : ¬ S.Prov (¬ S.hyp)) : S.hyp :=
Classical.byContradiction (fun n => h (S.sigma1 n))
theorem cant_refute_seals_dec (S : Setting) [Decidable S.hyp] (h : ¬ S.Prov (¬ S.hyp)) : S.hyp :=
Decidable.byContradiction (fun n => h (S.sigma1 n))
/-- Under soundness on the denial, the hypothesis holds exactly when the foundation cannot refute it. -/
theorem rh_iff_cant_refute (S : Setting) [Decidable S.hyp] : S.hyp ↔ ¬ S.Prov (¬ S.hyp) :=
⟨fun r p => S.sound_neg p r, cant_refute_seals_dec S⟩
/-- A hypothesis the theory neither proves nor refutes holds. -/
theorem independence_forces_truth (S : Setting) (_hp : ¬ S.Prov S.hyp) (hn : ¬ S.Prov (¬ S.hyp)) :
S.hyp :=
cant_refute_seals S hn
/-- A setting in which the hypothesis holds and is not provable. -/
def independentTrue : Setting := ⟨True, fun _ => False, fun n => absurd trivial n, fun p => p.elim⟩
theorem cant_prove_does_not_seal_false :
independentTrue.hyp ∧ ¬ independentTrue.Prov independentTrue.hyp :=
⟨trivial, id⟩
/-- Cannot-refute implies the hypothesis; cannot-prove is consistent with it. -/
theorem cant_asymmetry :
(∀ S : Setting, ¬ S.Prov (¬ S.hyp) → S.hyp) ∧ (∃ S : Setting, S.hyp ∧ ¬ S.Prov S.hyp) :=
⟨cant_refute_seals, ⟨independentTrue, cant_prove_does_not_seal_false⟩⟩
/-! ### XVIII.d · The round trip is the identity -/
/-- A sentence conjoined with the root. -/
def viaRoot {W : Type} (P : W → Prop) : W → Prop := fun w => RootAct ∧ P w
/-- Conjoining the root changes no sentence's value. -/
theorem round_trip_identity {W : Type} (P : W → Prop) (w : W) : viaRoot P w ↔ P w :=
⟨fun h => h.2, fun h => ⟨root_act, h⟩⟩
/-- An absolute sentence, the same in every world, returns unchanged. -/
theorem absolute_returns_unchanged {W : Type} (P : W → Prop) (hAbs : ∀ w v, P w ↔ P v) (w : W) :
∀ v, viaRoot P v ↔ P w :=
fun v => (round_trip_identity P v).trans (hAbs v w)
/-- The trip adds presence and nothing else: it returns identically for a sentence and its denial. -/
theorem trip_adds_presence_only {W : Type} (P : W → Prop) (w : W) :
RootAct ∧ (viaRoot P w ↔ P w) ∧ (viaRoot (fun v => ¬ P v) w ↔ ¬ P w) :=
⟨root_act, round_trip_identity P w, round_trip_identity (fun v => ¬ P v) w⟩
/-- For any true Q, (Q → RH Z) ↔ RH Z. -/
theorem massless_arrow (Q : Prop) (hq : Q) (Z : World) : (Q → RH Z) ↔ RH Z :=
⟨fun f => f hq, fun h _ => h⟩
/-- Any true premise satisfies the three properties of the root. -/
theorem any_true_premise_serves (R : Prop) (hR : R) {W : Type} (P : W → Prop) :
((∀ w, P w) → ∀ w, R → P w) ∧ ((∃ w, ¬ P w) → ¬ ∀ w, R → P w) ∧ (∀ w, (R ∧ P w) ↔ P w) :=
⟨fun hP w _ => hP w, fun h₁ h => h₁.elim (fun w hw => hw (h w hR)),
fun _ => ⟨fun h => h.2, fun h => ⟨hR, h⟩⟩⟩
/-- Conjoined with the root, the hypothesis is itself on W1 and on W2f. -/
theorem the_line_round_trips :
(∀ Z : World, viaRoot RH Z ↔ RH Z) ∧ viaRoot RH W1 ∧ ¬ viaRoot RH W2f :=
⟨fun Z => round_trip_identity RH Z, ⟨root_act, W1_rh⟩, fun h => W2f_not_rh h.2⟩
/-! ### XVIII.e · The ladder blocked, in six clauses -/
/-- Six clauses: no reading of the record decides the hypothesis; no keyless premise forces it; no
admissible coalition holding on W1 forces it; the root alone does not give it; a setting carries
a true hypothesis it does not prove; and the hypothesis forces the line and is entailed by every
premise that forces it. -/
theorem ladder_blocked :
(∀ g : World → Prop, RespectsRecord g → ¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z)) ∧
(∀ A : World → Prop, Keyless A → ¬ Forces A) ∧
(∀ L : List (World → Prop), (∀ A ∈ L, Admissible A) → (∀ A ∈ L, A W1) →
¬ Forces (fun Z => ∀ A ∈ L, A Z)) ∧
(¬ ∀ Z : World, RootAct → RH Z) ∧
(∃ S : Setting, S.hyp ∧ ¬ S.Prov S.hyp) ∧
(Forces RH ∧ ∀ A : World → Prop, Forces A → ∀ Z, FoldClosed Z → A Z → RH Z) :=
⟨record_decides_nothing_free, keyless_forces_nothing_free, no_admissible_coalition_forces,
root_does_not_cross_the_line, ⟨independentTrue, cant_prove_does_not_seal_false⟩,
rh_is_the_weakest_forcing_premise⟩
/-- Section XVIII, whole. -/
theorem the_road :
(∀ T : Theory, RungOnLadder T → Sound T → ∀ s, T.Comp s → T.True_ s) ∧
(RungOnLadder unsound ∧ ¬ Sound unsound) ∧
(Sound incomplete ∧ incomplete.True_ false ∧ ¬ incomplete.Prov false) ∧
(∀ {W : Type} (P : W → Prop), KeylessOn P → ∀ w, RootAct → P w) ∧
(∀ {W : Type} (P : W → Prop), KeyedOn P → ¬ ∀ w, RootAct → P w) ∧
(KeyedOn choiceHolds ∧ KeyedOn RH) ∧
(∀ S : Setting, ¬ S.Prov (¬ S.hyp) → S.hyp) ∧
(∃ S : Setting, S.hyp ∧ ¬ S.Prov S.hyp) ∧
(∀ {W : Type} (P : W → Prop) (w : W), viaRoot P w ↔ P w) ∧
(∀ (Q : Prop), Q → ∀ Z : World, (Q → RH Z) ↔ RH Z) ∧
(∀ A : World → Prop, Forces A → ∀ Z, FoldClosed Z → A Z → RH Z) :=
⟨fun T hR hS => (placement T hR hS).2.2, soundness_is_load_bearing, ground_exceeds_ladder,
fun P hP => keyless_crosses P hP, fun P hK => root_decides_no_keyed P hK,
⟨choice_is_keyed, line_is_keyed_over_worlds.1⟩,
cant_refute_seals, ⟨independentTrue, cant_prove_does_not_seal_false⟩,
fun P w => round_trip_identity P w, massless_arrow, rh_is_the_weakest_forcing_premise.2⟩
/-! ## XIX · The vocabulary law, the even coalition, the triaxial cut, the ladder's proof, the route ledger -/
/-! ### XIX.a · The vocabulary law -/
/-- On every world, a consequence of the hypothesis is a consequence of least erasure and
conversely, and a premise entailing one entails the other. -/
theorem vocabulary_law (Z : World) (P : Prop) :
((RH Z → P) ↔ (LeastErasure Z → P)) ∧ ((P → RH Z) ↔ (P → LeastErasure Z)) :=
⟨⟨fun h l => h ((least_erasure_is_the_value Z).mp l),
fun h r => h ((least_erasure_is_the_value Z).mpr r)⟩,
⟨fun h p => (least_erasure_is_the_value Z).mpr (h p),
fun h p => (least_erasure_is_the_value Z).mp (h p)⟩⟩
/-- A consequence of any one face is a consequence of the least-erasure face. -/
theorem every_face_proves_every_face (H : Faces) (P : Prop) :
((H.line → P) ↔ (H.least → P)) ∧ ((H.lamZero → P) ↔ (H.least → P)) ∧
((H.faithful → P) ↔ (H.least → P)) ∧ ((H.weil → P) ↔ (H.least → P)) :=
⟨⟨fun h l => h (H.line_iff_least.mpr l), fun h r => h (H.line_iff_least.mp r)⟩,
⟨fun h l => h (H.lam_iff_least.mpr l), fun h r => h (H.lam_iff_least.mp r)⟩,
⟨fun h l => h (H.faith_iff_least.mpr l), fun h r => h (H.faith_iff_least.mp r)⟩,
⟨fun h l => h (H.weil_iff_least.mpr l), fun h r => h (H.weil_iff_least.mp r)⟩⟩
/-- On every fold-closed world a consequence of any of the four chart readings is a consequence of
least erasure. -/
theorem chart_faces_prove_each_other (Z : World) (hZ : FoldClosed Z) (P : Prop) :
((Lossless Z → P) ↔ (LeastErasure Z → P)) ∧ ((DepthZero Z → P) ↔ (LeastErasure Z → P)) ∧
((¬ Left Z → P) ↔ (LeastErasure Z → P)) ∧ ((Stable Z → P) ↔ (LeastErasure Z → P)) :=
⟨⟨fun h l => h ((lossless_iff_rh Z).mpr ((least_erasure_is_the_value Z).mp l)),
fun h r => h ((least_erasure_is_the_value Z).mpr ((lossless_iff_rh Z).mp r))⟩,
⟨fun h l => h ((rh_iff_even_eigenspace Z).mp ((least_erasure_is_the_value Z).mp l)),
fun h r => h ((least_erasure_is_the_value Z).mpr ((rh_iff_even_eigenspace Z).mpr r))⟩,
⟨fun h l => h ((rh_iff_no_left Z hZ).mp ((least_erasure_is_the_value Z).mp l)),
fun h r => h ((least_erasure_is_the_value Z).mpr ((rh_iff_no_left Z hZ).mpr r))⟩,
⟨fun h l => h ((stable_iff_rh Z hZ).mpr ((least_erasure_is_the_value Z).mp l)),
fun h r => h ((least_erasure_is_the_value Z).mpr ((stable_iff_rh Z hZ).mp r))⟩⟩
/-! ### XIX.b · The even coalition: closed under every combination, blind to the value -/
/-- The fold is an involution. -/
theorem fold_fold (z : Pt) : fold (fold z) = z := by
cases z with
| mk x t =>
show Pt.mk (2 - (2 - x)) t = Pt.mk x t
congr 1
omega
/-- The fold law is keyless. -/
theorem fold_law_admissible : Admissible (fun _ : World => ∀ z, fold (fold z) = z) :=
Or.inl (fun _ => fold_fold)
/-- Two worlds of one record have one record. -/
theorem same_record_eq (Z Z' : World) (h : SameRecord Z Z') : recordOf Z = recordOf Z' :=
funext (fun r => propext (h r))
/-- A function of the record is a reading of the record. -/
theorem record_reading_admissible (h : World → Prop) : Admissible (fun Z => h (recordOf Z)) :=
Or.inr (fun Z Z' hs => by
show h (recordOf Z) ↔ h (recordOf Z')
rw [same_record_eq Z Z' hs])
/-- A constant premise is admissible. -/
theorem admissible_const (P : Prop) : Admissible (fun _ : World => P) :=
Or.inr (fun _ _ _ => Iff.rfl)
/-- The denial of a keyless premise respects the record: it is false everywhere. -/
theorem keyless_denial_respects (A : World → Prop) (hA : Keyless A) :
RespectsRecord (fun Z => ¬ A Z) :=
fun Z Z' _ => ⟨fun n => absurd (hA Z) n, fun n => absurd (hA Z') n⟩
/-- Admissible premises are closed under negation. -/
theorem admissible_not (A : World → Prop) (hA : Admissible A) : Admissible (fun Z => ¬ A Z) := by
rcases hA with k | r
· exact Or.inr (keyless_denial_respects A k)
· exact Or.inr (fun Z Z' h => ⟨fun n a => n ((r Z Z' h).mpr a), fun n a => n ((r Z Z' h).mp a)⟩)
/-- Admissible premises are closed under conjunction. -/
theorem admissible_and (A B : World → Prop) (hA : Admissible A) (hB : Admissible B) :
Admissible (fun Z => A Z ∧ B Z) := by
rcases hA with ka | ra <;> rcases hB with kb | rb
· exact Or.inl (fun Z => ⟨ka Z, kb Z⟩)
· exact Or.inr (fun Z Z' h =>
⟨fun ⟨_, b⟩ => ⟨ka Z', (rb Z Z' h).mp b⟩, fun ⟨_, b⟩ => ⟨ka Z, (rb Z Z' h).mpr b⟩⟩)
· exact Or.inr (fun Z Z' h =>
⟨fun ⟨a, _⟩ => ⟨(ra Z Z' h).mp a, kb Z'⟩, fun ⟨a, _⟩ => ⟨(ra Z Z' h).mpr a, kb Z⟩⟩)
· exact Or.inr (fun Z Z' h =>
⟨fun ⟨a, b⟩ => ⟨(ra Z Z' h).mp a, (rb Z Z' h).mp b⟩,
fun ⟨a, b⟩ => ⟨(ra Z Z' h).mpr a, (rb Z Z' h).mpr b⟩⟩)
/-- Admissible premises are closed under disjunction. -/
theorem admissible_or (A B : World → Prop) (hA : Admissible A) (hB : Admissible B) :
Admissible (fun Z => A Z ∨ B Z) := by
rcases hA with ka | ra <;> rcases hB with kb | rb
· exact Or.inl (fun Z => Or.inl (ka Z))
· exact Or.inl (fun Z => Or.inl (ka Z))
· exact Or.inl (fun Z => Or.inr (kb Z))
· exact Or.inr (fun Z Z' h =>
⟨fun o => o.elim (fun a => Or.inl ((ra Z Z' h).mp a)) (fun b => Or.inr ((rb Z Z' h).mp b)),
fun o => o.elim (fun a => Or.inl ((ra Z Z' h).mpr a)) (fun b => Or.inr ((rb Z Z' h).mpr b))⟩)
/-- No admissible premise agrees with the hypothesis on every fold-closed world. -/
theorem admissible_never_decides (A : World → Prop) (hA : Admissible A) :
¬ ∀ Z, FoldClosed Z → (A Z ↔ RH Z) := by
intro h
rcases hA with k | r
· exact W2f_not_rh ((h W2f W2f_closed).mp (k W2f))
· exact record_decides_nothing_free A r h
/-- A coalition: any Boolean combination of atomic premises, however deep. -/
inductive Coalition (ι : Type) where
| atom : ι → Coalition ι
| top : Coalition ι
| bot : Coalition ι
| not : Coalition ι → Coalition ι
| and : Coalition ι → Coalition ι → Coalition ι
| or : Coalition ι → Coalition ι → Coalition ι
/-- The premise a coalition asserts, given its atoms. -/
def Coalition.eval {ι : Type} (at_ : ι → World → Prop) : Coalition ι → World → Prop
| .atom i => at_ i
| .top => fun _ => True
| .bot => fun _ => False
| .not c => fun Z => ¬ Coalition.eval at_ c Z
| .and c d => fun Z => Coalition.eval at_ c Z ∧ Coalition.eval at_ d Z
| .or c d => fun Z => Coalition.eval at_ c Z ∨ Coalition.eval at_ d Z
/-- Every coalition of admissible atoms is admissible. -/
theorem coalition_admissible {ι : Type} (at_ : ι → World → Prop) (h : ∀ i, Admissible (at_ i)) :
∀ c : Coalition ι, Admissible (Coalition.eval at_ c) := by
intro c
induction c with
| atom i => exact h i
| top => exact admissible_const True
| bot => exact admissible_const False
| not c ih =>
show Admissible (fun Z => ¬ Coalition.eval at_ c Z)
exact admissible_not _ ih
| and c d ihc ihd =>
show Admissible (fun Z => Coalition.eval at_ c Z ∧ Coalition.eval at_ d Z)
exact admissible_and _ _ ihc ihd
| or c d ihc ihd =>
show Admissible (fun Z => Coalition.eval at_ c Z ∨ Coalition.eval at_ d Z)
exact admissible_or _ _ ihc ihd
/-- No coalition of admissible atoms agrees with the hypothesis on every fold-closed world. -/
theorem no_coalition_decides {ι : Type} (at_ : ι → World → Prop) (h : ∀ i, Admissible (at_ i))
(c : Coalition ι) : ¬ ∀ Z, FoldClosed Z → (Coalition.eval at_ c Z ↔ RH Z) :=
admissible_never_decides _ (coalition_admissible at_ h c)
/-! ### XIX.c · The triaxial cut, irreducible -/
/-- The fold law and every reading of the record are admissible; admissible premises are closed
under Boolean combination; no admissible premise decides the hypothesis; off the line one
supplied side bit fixes any fold-flipped target by a unique calibration, both values realized;
least erasure is not admissible; and nothing weaker than the hypothesis forces the line. -/
theorem triaxial_cut_irreducible :
Admissible (fun _ : World => ∀ z, fold (fold z) = z) ∧
(∀ h : World → Prop, Admissible (fun Z => h (recordOf Z))) ∧
(∀ (ι : Type) (at_ : ι → World → Prop), (∀ i, Admissible (at_ i)) →
∀ c : Coalition ι, Admissible (Coalition.eval at_ c)) ∧
(∀ A : World → Prop, Admissible A → ¬ ∀ Z, FoldClosed Z → (A Z ↔ RH Z)) ∧
(∀ (d : Pt → Bool) (z : Pt), ¬ onLine z → d (fold z) = !d z →
∃ c : Bool, (d z = xor (side z) c ∧ d (fold z) = xor (side (fold z)) c) ∧
∀ c', (d z = xor (side z) c' ∧ d (fold z) = xor (side (fold z)) c') → c' = c) ∧
(∀ z : Pt, ¬ onLine z →
(side (fold z) = !side z ∧ side z = xor (side z) false) ∧
((!side (fold z)) = !(!side z) ∧ (!side z) = xor (side z) true)) ∧
¬ Admissible LeastErasure ∧
(Forces RH ∧ ∀ A : World → Prop, Forces A → ∀ Z, FoldClosed Z → A Z → RH Z) :=
⟨fold_law_admissible, record_reading_admissible,
fun _ at_ h c => coalition_admissible at_ h c, admissible_never_decides,
colocation_is_a_calibration, calibration_realized_both_ways,
spend_is_not_admissible, rh_is_the_weakest_forcing_premise⟩
/-! ### XIX.d · The ladder's proof lands on least erasure; no foundation is claimed closed -/
/-- A reading of a theory's sentences on the chart: each sentence names a world, and the sentence
holds in the intended model exactly when that world satisfies the hypothesis. -/
structure ReadsAsLine (T : Theory) where
world : T.Sent → World
reads : ∀ s, T.True_ s ↔ RH (world s)
/-- If a sound theory proves a sentence that reads as the hypothesis on a world, that world has
least erasure. -/
theorem ladder_proof_lands_on_least_erasure (T : Theory) (hS : Sound T) (R : ReadsAsLine T)
(s : T.Sent) (hp : T.Prov s) : LeastErasure (R.world s) :=
(least_erasure_is_the_value (R.world s)).mpr ((R.reads s).mp (hS s hp))
/-- Where the theory also proves the sentence whenever it holds, its proof is exactly least
erasure on the world the sentence names. -/
theorem ladder_proof_iff_least_erasure (T : Theory) (hS : Sound T) (R : ReadsAsLine T)
(s : T.Sent) (hc : T.True_ s → T.Prov s) : T.Prov s ↔ LeastErasure (R.world s) :=
⟨ladder_proof_lands_on_least_erasure T hS R s,
fun l => hc ((R.reads s).mpr ((least_erasure_is_the_value (R.world s)).mp l))⟩
/-- A sound theory with one sentence, proved, reading as the line world. -/
def lineTheory : Theory := ⟨Unit, fun _ => True, fun _ => False, fun _ => True⟩
theorem lineTheory_sound : Sound lineTheory := fun _ _ => trivial
def lineTheoryReads : ReadsAsLine lineTheory :=
⟨fun _ => W1, fun _ => ⟨fun _ => W1_rh, fun _ => trivial⟩⟩
/-- A sound theory proving a sentence that reads as the hypothesis exists, and its proof lands on
least erasure. -/
theorem a_sound_theory_may_prove_the_line :
Sound lineTheory ∧ lineTheory.Prov () ∧ LeastErasure (lineTheoryReads.world ()) :=
⟨lineTheory_sound, trivial,
ladder_proof_lands_on_least_erasure lineTheory lineTheory_sound lineTheoryReads () trivial⟩
/-! ### XIX.e · The route ledger, computed -/
/-- Six routes to the hypothesis. -/
inductive Route where
| ladderFromRecord | foundationAsSystem | placement | groundByAct | independence | realPartCertified
deriving DecidableEq, Repr
/-- A route's status: blocked by a theorem of this file; closed by the act; carried on a cited
theorem; or open, with no closure claimed. -/
inductive RouteStatus where
| blocked | closedByAct | cited | open
deriving DecidableEq, Repr
/-- A status is a function of three recorded bits: a theorem of this file blocks the route; the act
closes it; a cited theorem carries it. -/
def routeStatus (blocked byAct cited : Bool) : RouteStatus :=
if blocked then .blocked else if byAct then .closedByAct else if cited then .cited else .open
structure RouteEntry where
route : Route
blocked : Bool
byAct : Bool
cited : Bool
printed : RouteStatus
/-- The ledger: the ladder from the record, blocked (unicorn_block); the foundation as a system,
open (a_sound_theory_may_prove_the_line); placement, on the two cited premises (placement);
the ground closed by the act (rh_from_the_act); independence, blocked, since it would force
truth (independence_forces_truth); the real part to the certified height, cited (Platt and
Trudgian 2021, certified_height_never_forces). -/
def routeLedger : List RouteEntry :=
[⟨.ladderFromRecord, true, false, false, .blocked⟩,
⟨.foundationAsSystem, false, false, false, .open⟩,
⟨.placement, false, false, true, .cited⟩,
⟨.groundByAct, false, true, false, .closedByAct⟩,
⟨.independence, true, false, false, .blocked⟩,
⟨.realPartCertified, false, false, true, .cited⟩]
/-- Every printed status is the computed one. -/
theorem route_ledger_is_computed :
routeLedger.all (fun e => routeStatus e.blocked e.byAct e.cited == e.printed) = true := by
decide
/-- Six routes: two blocked, one closed by the act, two cited, one open. -/
theorem route_ledger_counts :
routeLedger.length = 6 ∧
(routeLedger.filter (fun e => e.printed == .blocked)).length = 2 ∧
(routeLedger.filter (fun e => e.printed == .closedByAct)).length = 1 ∧
(routeLedger.filter (fun e => e.printed == .cited)).length = 2 ∧
(routeLedger.filter (fun e => e.printed == .open)).length = 1 := by
decide
/-- Nothing escapes the ledger: every status is one of the four. -/
theorem route_status_total : ∀ a b c : Bool,
routeStatus a b c = .blocked ∨ routeStatus a b c = .closedByAct ∨
routeStatus a b c = .cited ∨ routeStatus a b c = .open := by
decide
/-- A route is blocked exactly when a theorem blocks it: no other bit produces the verdict. -/
theorem blocked_iff_theorem : ∀ a b c : Bool, routeStatus a b c = .blocked ↔ a = true := by
decide
/-! ### XIX.f · The two-part reading -/
/-- (a) From the posit the hypothesis follows. (b) No reading of the record supplies the posit. (c)
The posit is the hypothesis. (d) Nothing weaker forces. -/
theorem reader_frame :
(∀ A : ActualZeros, RH A.zeros) ∧
(∀ g : World → Prop, RespectsRecord g → ¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z)) ∧
(∀ Z : World, LeastErasure Z ↔ RH Z) ∧
(Forces RH ∧ ∀ A : World → Prop, Forces A → ∀ Z, FoldClosed Z → A Z → RH Z) :=
⟨rh_from_the_act, record_decides_nothing_free, least_erasure_is_the_value,
rh_is_the_weakest_forcing_premise⟩
/-- Section XIX, whole. -/
theorem the_front :
(∀ (Z : World) (P : Prop), ((RH Z → P) ↔ (LeastErasure Z → P)) ∧
((P → RH Z) ↔ (P → LeastErasure Z))) ∧
(∀ (H : Faces) (P : Prop), ((H.line → P) ↔ (H.least → P)) ∧ ((H.lamZero → P) ↔ (H.least → P)) ∧
((H.faithful → P) ↔ (H.least → P)) ∧ ((H.weil → P) ↔ (H.least → P))) ∧
(∀ (ι : Type) (at_ : ι → World → Prop), (∀ i, Admissible (at_ i)) →
∀ c : Coalition ι, ¬ ∀ Z, FoldClosed Z → (Coalition.eval at_ c Z ↔ RH Z)) ∧
¬ Admissible LeastErasure ∧
(Forces RH ∧ ∀ A : World → Prop, Forces A → ∀ Z, FoldClosed Z → A Z → RH Z) ∧
(∀ (T : Theory), Sound T → ∀ (R : ReadsAsLine T) (s : T.Sent), T.Prov s →
LeastErasure (R.world s)) ∧
(Sound lineTheory ∧ lineTheory.Prov () ∧ LeastErasure (lineTheoryReads.world ())) ∧
routeLedger.all (fun e => routeStatus e.blocked e.byAct e.cited == e.printed) = true ∧
((∀ A : ActualZeros, RH A.zeros) ∧
(∀ g : World → Prop, RespectsRecord g → ¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z)) ∧
(∀ Z : World, LeastErasure Z ↔ RH Z)) :=
⟨vocabulary_law, every_face_proves_every_face,
fun _ at_ h c => no_coalition_decides at_ h c, spend_is_not_admissible,
rh_is_the_weakest_forcing_premise,
fun T hS R s hp => ladder_proof_lands_on_least_erasure T hS R s hp,
a_sound_theory_may_prove_the_line, route_ledger_is_computed,
⟨rh_from_the_act, record_decides_nothing_free, least_erasure_is_the_value⟩⟩
/-! ## XX · Least erasure affirmed: the record, the ledger, the price, the one form, the act -/
/-! ### XX.a · The record is carried by a least-erasure world, and by only one -/
/-- Registration lands on the line. -/
theorem reg_on_line (z : Pt) : onLine (reg z) := rfl
/-- The record of every world satisfies the hypothesis. -/
theorem record_rh (Z : World) : RH (recordOf Z) := by
intro r ⟨s, _, hsr⟩
rw [← hsr]
exact rfl
/-- The record of every world has least erasure. -/
theorem record_has_least_erasure (Z : World) : LeastErasure (recordOf Z) :=
(least_erasure_is_the_value (recordOf Z)).mpr (record_rh Z)
/-- The record of every world is fold-closed: it lies on the line, which the fold fixes. -/
theorem record_closed (Z : World) : FoldClosed (recordOf Z) := by
intro r ⟨s, hs, hsr⟩
rw [← hsr]
exact ⟨s, hs, ((fold_fixed_iff (reg s)).mpr rfl).symm⟩
/-- The record of Z shares the record of Z, has least erasure, and every least-erasure world with
that record equals it pointwise. -/
theorem record_carried_by_least_erasure (Z : World) :
SameRecord Z (recordOf Z) ∧ LeastErasure (recordOf Z) ∧
∀ Z', SameRecord Z Z' → LeastErasure Z' → ∀ z, Z' z ↔ recordOf Z z := by
refine ⟨record_same Z, record_has_least_erasure Z, ?_⟩
intro Z' hs hle z
have h1 : SameRecord Z' (recordOf Z) := fun r => (hs r).symm.trans (record_same Z r)
exact lossless_unique Z' (recordOf Z) h1 ((least_erasure_is_the_value Z').mp hle) (record_rh Z) z
/-! ### XX.b · Every reading of the record holds on a least-erasure world -/
/-- An admissible premise that holds on a world holds on that world's record, which has least
erasure. -/
theorem admissible_holds_on_the_lossless_world (A : World → Prop) (hA : Admissible A) (Z : World)
(h : A Z) : A (recordOf Z) ∧ LeastErasure (recordOf Z) := by
refine ⟨?_, record_has_least_erasure Z⟩
rcases hA with k | r
· exact k (recordOf Z)
· exact (r Z (recordOf Z) (record_same Z)).mp h
/-- Every reading of the record that holds on a world holds on that world's record. -/
theorem every_reading_holds_on_the_lossless_world (g : World → Prop) (hg : RespectsRecord g)
(Z : World) (h : g Z) : g (recordOf Z) ∧ LeastErasure (recordOf Z) := by
refine ⟨(hg Z (recordOf Z) (record_same Z)).mp h, record_has_least_erasure Z⟩
/-- Every coalition of admissible atoms that holds on a world holds on that world's record. -/
theorem every_coalition_holds_on_the_lossless_world {ι : Type} (at_ : ι → World → Prop)
(h : ∀ i, Admissible (at_ i)) (c : Coalition ι) (Z : World) (hc : Coalition.eval at_ c Z) :
Coalition.eval at_ c (recordOf Z) ∧ LeastErasure (recordOf Z) := by
refine ⟨?_, record_has_least_erasure Z⟩
rcases coalition_admissible at_ h c with k | r
· exact k (recordOf Z)
· exact (r Z (recordOf Z) (record_same Z)).mp hc
/-- An admissible premise that denies least erasure on every fold-closed world holds on no world. -/
theorem record_never_testifies_against (A : World → Prop) (hA : Admissible A)
(hdeny : ∀ Z, FoldClosed Z → A Z → ¬ LeastErasure Z) : ∀ Z, ¬ A Z := by
intro Z h
rcases hA with k | r
· exact hdeny (recordOf Z) (record_closed Z) (k (recordOf Z)) (record_has_least_erasure Z)
· exact hdeny (recordOf Z) (record_closed Z) ((r Z (recordOf Z) (record_same Z)).mp h)
(record_has_least_erasure Z)
/-! ### XX.c · The erasure ledger: one bit per off-line pair, zero exactly at least erasure -/
/-- An off-line pair at offset k is two distinct points, exchanged by the fold, with one registered
point. -/
theorem pair_two_points_one_record (k : Int) (h : Nat) (hk : k ≠ 0) :
(⟨1 - k, h⟩ : Pt) ≠ ⟨1 + k, h⟩ ∧ reg ⟨1 - k, h⟩ = reg ⟨1 + k, h⟩ ∧
fold ⟨1 - k, h⟩ = ⟨1 + k, h⟩ := by
refine ⟨?_, rfl, ?_⟩
· intro e
have := congrArg Pt.x e
change 1 - k = 1 + k at this
omega
· show Pt.mk (2 - (1 - k)) h = Pt.mk (1 + k) h
congr 1
omega
/-- A finite configuration: the heights of its on-line zeros, and its off-line pairs, each an
offset with a height. An offset of zero is no pair. -/
structure FinCfg where
online : List Nat
pairs : List (Int × Nat)
/-- The world a finite configuration names on the chart. -/
def FinCfg.world (C : FinCfg) : World := fun z =>
(z.x = 1 ∧ z.t ∈ C.online) ∨
∃ p ∈ C.pairs, p.1 ≠ 0 ∧ (z = ⟨1 - p.1, p.2⟩ ∨ z = ⟨1 + p.1, p.2⟩)
/-- The off-line pairs, counted. -/
def offCount : List (Int × Nat) → Nat
| [] => 0
| p :: ps => (if p.1 = 0 then 0 else 1) + offCount ps
/-- Erased bits: the number of off-line pairs. -/
def FinCfg.erasedBits (C : FinCfg) : Nat := offCount C.pairs
theorem offCount_zero_iff (ps : List (Int × Nat)) : offCount ps = 0 ↔ ∀ p ∈ ps, p.1 = 0 := by
induction ps with
| nil => exact ⟨fun _ p hp => (nomatch hp), fun _ => rfl⟩
| cons p ps ih =>
show (if p.1 = 0 then 0 else 1) + offCount ps = 0 ↔ ∀ q ∈ p :: ps, q.1 = 0
by_cases hp : p.1 = 0
· rw [if_pos hp, Nat.zero_add, ih]
constructor
· intro h q hq
cases hq with
| head => exact hp
| tail _ hq' => exact h q hq'
· intro h q hq
exact h q (List.Mem.tail p hq)
· rw [if_neg hp]
constructor
· intro h
omega
· intro h
exact absurd (h p (List.Mem.head ps)) hp
/-- Every finite configuration is fold-closed: the on-line points are fixed and each pair is
exchanged. -/
theorem fincfg_closed (C : FinCfg) : FoldClosed C.world := by
intro z hz
rcases hz with ⟨hx, ht⟩ | ⟨p, hp, hk, hz⟩
· exact Or.inl ⟨show 2 - z.x = 1 by omega, ht⟩
· refine Or.inr ⟨p, hp, hk, ?_⟩
rcases hz with e | e
· subst e
exact Or.inr (by show Pt.mk (2 - (1 - p.1)) p.2 = Pt.mk (1 + p.1) p.2; congr 1; omega)
· subst e
exact Or.inl (by show Pt.mk (2 - (1 + p.1)) p.2 = Pt.mk (1 - p.1) p.2; congr 1; omega)
/-- Least erasure holds exactly when the erased bits are zero. -/
theorem least_erasure_iff_zero_erased (C : FinCfg) : LeastErasure C.world ↔ C.erasedBits = 0 := by
rw [least_erasure_is_the_value]
show RH C.world ↔ offCount C.pairs = 0
rw [offCount_zero_iff]
constructor
· intro h p hp
refine Decidable.byContradiction (fun hk => ?_)
have hz : C.world ⟨1 - p.1, p.2⟩ := Or.inr ⟨p, hp, hk, Or.inl rfl⟩
have := h _ hz
change 1 - p.1 = 1 at this
omega
· intro h z hz
rcases hz with ⟨hx, _⟩ | ⟨p, hp, hk, _⟩
· exact hx
· exact absurd (h p hp) hk
/-! ### XX.d · The price: one floor per erased bit, zero exactly at least erasure -/
/-- k_B T ln 2 at 300 K in units of 10⁻⁴⁵ J: k_B = 1380649 × 10⁻²⁹ J/K (SI 2019), ln 2 =
6931471805599453 × 10⁻¹⁶ to sixteen digits. -/
def landauerFloor : Nat := 1380649 * 300 * 6931471805599453
theorem landauer_floor_exact : landauerFloor = 2870978885078723755499100 := by decide
/-- The price of a registration: one floor per erased bit if irreversible, 0 if reversible. -/
def FinCfg.price (C : FinCfg) (irreversible : Bool) : Nat :=
if irreversible then C.erasedBits * landauerFloor else 0
/-- An irreversible registration has price 0 exactly when the configuration has least erasure. -/
theorem price_zero_iff_least_erasure (C : FinCfg) : C.price true = 0 ↔ LeastErasure C.world := by
rw [least_erasure_iff_zero_erased]
show C.erasedBits * landauerFloor = 0 ↔ C.erasedBits = 0
constructor
· intro h
rcases Nat.mul_eq_zero.mp h with h1 | h1
· exact h1
· exact absurd h1 (by decide)
· intro h
rw [h, Nat.zero_mul]
/-- One more off-line pair. -/
def FinCfg.addPair (C : FinCfg) (k : Int) (h : Nat) : FinCfg := ⟨C.online, (k, h) :: C.pairs⟩
/-- Adding an off-line pair adds one floor; the price is the erased bits times the floor. -/
theorem denial_price_linear (C : FinCfg) (k : Int) (h : Nat) (hk : k ≠ 0) :
(C.addPair k h).price true = C.price true + landauerFloor ∧
C.price true = C.erasedBits * landauerFloor := by
refine ⟨?_, rfl⟩
show ((if k = 0 then 0 else 1) + offCount C.pairs) * landauerFloor
= offCount C.pairs * landauerFloor + landauerFloor
rw [if_neg hk, Nat.add_mul, Nat.one_mul, Nat.add_comm]
/-- What is held reversibly commits no bit. -/
theorem reversible_commits_nothing (C : FinCfg) : C.price false = 0 := rfl
/-! ### XX.e · The one form of anything against least erasure -/
/-- Least erasure holds exactly when no point of the world lies off the line. No classical axiom. -/
theorem least_erasure_iff_no_point_off (Z : World) : LeastErasure Z ↔ ¬ OffLine Z := by
rw [least_erasure_is_the_value]
constructor
· intro h ⟨z, hz, hoff⟩
exact hoff (h z hz)
· intro h z hz
exact Decidable.byContradiction (fun hoff => h ⟨z, hz, hoff⟩)
/-- Least erasure fails exactly when some point of the world lies off the line. Classical. -/
theorem rejection_is_a_witness (Z : World) : ¬ LeastErasure Z ↔ OffLine Z := by
rw [least_erasure_iff_no_point_off]
exact ⟨fun h => Classical.byContradiction (fun hn => h hn), fun h hn => hn h⟩
/-- Two settings on one hypothesis agree on whether the hypothesis is refutable. -/
theorem falsifier_form_constant (S₁ S₂ : Setting) [Decidable S₁.hyp] [Decidable S₂.hyp]
(h : S₁.hyp = S₂.hyp) : (¬ S₁.Prov (¬ S₁.hyp)) ↔ (¬ S₂.Prov (¬ S₂.hyp)) := by
constructor
· intro h1 p2
exact S₂.sound_neg p2 (Eq.mp h (cant_refute_seals_dec S₁ h1))
· intro h2 p1
exact S₁.sound_neg p1 (Eq.mpr h (cant_refute_seals_dec S₂ h2))
/-! ### XX.f · The act -/
/-- Any inhabitant of any type yields the root proposition. -/
theorem act_reenacts_root {Act : Type} (_a : Act) : RootAct := root_act
/-- The root does not imply the denial of the hypothesis on every world. -/
theorem root_does_not_cross_the_denial : ¬ ∀ Z : World, RootAct → ¬ RH Z :=
fun h => h W1 root_act W1_rh
/-- A self-grounding supply of least erasure with an act exists exactly when least erasure holds. -/
theorem assent_is_the_value (Z : World) :
(∃ G : SelfGrounding (LeastErasure Z), Nonempty G.Act) ↔ LeastErasure Z :=
supply_iff (LeastErasure Z)
/-! ### XX.g · Freedom given, the sign spent -/
/-- A prime is one fibre of exactly two, never on the diagonal; an off-line pair is two points
exchanged by the fold with one record; a bit is two distinct values. -/
theorem one_shape_two_registers :
(∀ p : Nat, isPrime p →
(∀ a b, mul_orbit p a b ↔ (a = 1 ∧ b = p) ∨ (a = p ∧ b = 1)) ∧ (1 : Nat) ≠ p) ∧
(∀ p : Nat, isPrime p → ¬ ∃ a, mul_orbit p a a) ∧
(∀ (k : Int) (h : Nat), k ≠ 0 → (⟨1 - k, h⟩ : Pt) ≠ ⟨1 + k, h⟩ ∧
reg ⟨1 - k, h⟩ = reg ⟨1 + k, h⟩ ∧ fold ⟨1 - k, h⟩ = ⟨1 + k, h⟩) ∧
((∀ b : Bool, b = true ∨ b = false) ∧ (true : Bool) ≠ false) :=
⟨freedom_is_exactly_two, prime_off_seat, pair_two_points_one_record, aperture_one_bit_wide⟩
/-- The free basis holds and forces nothing; least erasure is Weil positivity; positivity is keyed;
a self-grounding supply of positivity is the hypothesis. -/
theorem freedom_is_given_the_sign_is_spent :
(∀ p q : Nat, isPrime p → isPrime q → p ≠ q →
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0) ∧
¬ Forces (fun _ => ∀ p q, isPrime p → isPrime q → p ≠ q →
∃ f : Nat → Int, CompletelyAdditive f ∧ f p = 1 ∧ f q = 0 ∧ f 1 = 0) ∧
(∀ E : ExplicitFormula, LeastErasure E.zeros ↔ WeilPositive E) ∧
(WeilPositive positiveInstance ∧ ¬ WeilPositive negativeInstance) ∧
(∀ E : ExplicitFormula, (∃ G : SelfGrounding (WeilPositive E), Nonempty G.Act) ↔ RH E.zeros) :=
⟨prime_freedom_independent, prime_freedom_forces_nothing, least_erasure_is_positivity,
positivity_is_keyed, prime_witness_iff⟩
/-! ### XX.h · Least erasure, affirmed whole -/
/-- Section XX, whole. -/
theorem least_erasure_affirmed :
(∀ Z : World, LeastErasure Z ↔ RH Z) ∧
(∀ Z : World, SameRecord Z (recordOf Z) ∧ LeastErasure (recordOf Z) ∧
∀ Z', SameRecord Z Z' → LeastErasure Z' → ∀ z, Z' z ↔ recordOf Z z) ∧
(∀ (A : World → Prop), Admissible A → ∀ Z, A Z → A (recordOf Z) ∧ LeastErasure (recordOf Z)) ∧
(∀ (A : World → Prop), Admissible A →
(∀ Z, FoldClosed Z → A Z → ¬ LeastErasure Z) → ∀ Z, ¬ A Z) ∧
(∀ C : FinCfg, LeastErasure C.world ↔ C.erasedBits = 0) ∧
(∀ C : FinCfg, C.price true = 0 ↔ LeastErasure C.world) ∧
(∀ Z : World, LeastErasure Z ↔ ¬ OffLine Z) ∧
(∀ (S₁ S₂ : Setting) [Decidable S₁.hyp] [Decidable S₂.hyp], S₁.hyp = S₂.hyp →
((¬ S₁.Prov (¬ S₁.hyp)) ↔ (¬ S₂.Prov (¬ S₂.hyp)))) ∧
(∀ Z : World, (∃ G : SelfGrounding (LeastErasure Z), Nonempty G.Act) ↔ LeastErasure Z) ∧
(∀ E : ExplicitFormula, LeastErasure E.zeros ↔ WeilPositive E) :=
⟨least_erasure_is_the_value, record_carried_by_least_erasure,
admissible_holds_on_the_lossless_world, record_never_testifies_against,
least_erasure_iff_zero_erased, price_zero_iff_least_erasure, least_erasure_iff_no_point_off,
fun S₁ S₂ _ _ h => falsifier_form_constant S₁ S₂ h, assent_is_the_value,
least_erasure_is_positivity⟩
/-! ## XXI · Every assignment realized; the arrow for every n; the closure, whole
The primes admit every assignment of integers: for each `a` on the primes, `n ↦ Σ_{p ≤ n} v_p(n) a(p)`
is completely additive and takes the value `a(p)` at every prime, and by `determined_by_primes` it is the
only such function. The count `Ω(n) = Σ_p v_p(n)` and the arrow `λ(n) = (−1)^{Ω(n)}` are defined for every
`n`, and `λ` is completely multiplicative with `λ(p) = −1`. The Liouville face is pinned to the constructed
walk. On the chart, least erasure is the value, the fixed-point condition and leastness in the fibre; the
closure is bound in one theorem; and the same laws hold on any carrier with an involution and a registration,
the chart one instance. -/
/-- The finite sum `sumBelow N g = g 0 + ⋯ + g (N − 1)`. -/
def sumBelow : Nat → (Nat → Int) → Int
| 0, _ => 0
| N + 1, g => sumBelow N g + g N
theorem sumBelow_add (g h : Nat → Int) (N : Nat) :
sumBelow N (fun i => g i + h i) = sumBelow N g + sumBelow N h := by
induction N with
| zero => show (0 : Int) = 0 + 0; omega
| succ N ih =>
show sumBelow N (fun i => g i + h i) + (g N + h N) = (sumBelow N g + g N) + (sumBelow N h + h N)
rw [ih]; omega
theorem sumBelow_congr (g h : Nat → Int) (N : Nat) (hgh : ∀ i, i < N → g i = h i) :
sumBelow N g = sumBelow N h := by
induction N with
| zero => rfl
| succ N ih =>
show sumBelow N g + g N = sumBelow N h + h N
rw [ih (fun i hi => hgh i (by omega)), hgh N (by omega)]
theorem sumBelow_stable (g : Nat → Int) (M k : Nat) (hz : ∀ i, M ≤ i → i < M + k → g i = 0) :
sumBelow (M + k) g = sumBelow M g := by
induction k with
| zero => rfl
| succ k ih =>
show sumBelow (M + k) g + g (M + k) = sumBelow M g
rw [ih (fun i h1 h2 => hz i h1 (by omega)), hz (M + k) (by omega) (by omega)]
omega
theorem sumBelow_zero (g : Nat → Int) (N : Nat) (hz : ∀ i, i < N → g i = 0) : sumBelow N g = 0 := by
induction N with
| zero => rfl
| succ N ih =>
show sumBelow N g + g N = 0
rw [ih (fun i hi => hz i (by omega)), hz N (by omega)]
omega
theorem sumBelow_single (g : Nat → Int) (j N : Nat) (hj : j < N) (hz : ∀ i, i < N → i ≠ j → g i = 0) :
sumBelow N g = g j := by
induction N with
| zero => omega
| succ N ih =>
show sumBelow N g + g N = g j
by_cases hjN : j = N
· rw [hjN, sumBelow_zero g N (fun i hi => hz i (by omega) (by omega))]
omega
· rw [ih (by omega) (fun i hi hij => hz i (by omega) hij), hz N (by omega) (fun h => hjN h.symm)]
omega
/-- Primality, decided: two at least, and its own least divisor. -/
def primeTest (p : Nat) : Bool := decide (2 ≤ p ∧ leastDivisor p = p)
theorem primeTest_iff (p : Nat) : primeTest p = true ↔ isPrime p := by
constructor
· intro h
obtain ⟨h2, hl⟩ : 2 ≤ p ∧ leastDivisor p = p := of_decide_eq_true h
have hp := leastDivisor_prime p h2
rw [hl] at hp
exact hp
· intro hp
apply decide_eq_true
refine ⟨hp.1, ?_⟩
have hs := leastDivisor_spec p hp.1
rcases hp.2 (leastDivisor p) hs.1.2 with h1 | h1
· have h2 := hs.1.1
omega
· exact h1
theorem pExp_zero_above (p n : Nat) (hn : 0 < n) (hp : n < p) : pExp p n = 0 :=
pExp_eq_zero_of_not_dvd p n (fun hd => absurd (Nat.le_of_dvd hn hd) (by omega))
/-- The term of the extension at `p`: the exponent of `p` in `n` times the value assigned to `p`, at primes only. -/
def extendTerm (a : Nat → Int) (n p : Nat) : Int := if primeTest p = true then (pExp p n : Int) * a p else 0
/-- The extension of an assignment on the primes: `n ↦ Σ_{p ≤ n} v_p(n) a(p)`. -/
def extendAssignment (a : Nat → Int) (n : Nat) : Int := sumBelow (n + 1) (extendTerm a n)
theorem extendTerm_zero_above (a : Nat → Int) (n i : Nat) (hn : 0 < n) (hi : n < i) : extendTerm a n i = 0 := by
unfold extendTerm
rw [pExp_zero_above i n hn hi]
by_cases hb : primeTest i = true
· rw [if_pos hb]; simp
· rw [if_neg hb]
theorem extendAssignment_bound (a : Nat → Int) (n B : Nat) (hn : 0 < n) (hB : n < B) :
extendAssignment a n = sumBelow B (extendTerm a n) := by
obtain ⟨k, rfl⟩ : ∃ k, B = n + 1 + k := ⟨B - (n + 1), by omega⟩
unfold extendAssignment
rw [sumBelow_stable (extendTerm a n) (n + 1) k (fun i h1 _ => extendTerm_zero_above a n i hn (by omega))]
theorem extendTerm_mul (a : Nat → Int) (m n p : Nat) (hm : 0 < m) (hn : 0 < n) :
extendTerm a (m * n) p = extendTerm a m p + extendTerm a n p := by
unfold extendTerm
by_cases hb : primeTest p = true
· rw [if_pos hb, if_pos hb, if_pos hb, pExp_mul p m n ((primeTest_iff p).mp hb) hm hn]
have e : ((pExp p m + pExp p n : Nat) : Int) = (pExp p m : Int) + (pExp p n : Int) := by omega
rw [e, Int.add_mul]
· rw [if_neg hb, if_neg hb, if_neg hb]
omega
theorem extendAssignment_mul (a : Nat → Int) (m n : Nat) (hm : 0 < m) (hn : 0 < n) :
extendAssignment a (m * n) = extendAssignment a m + extendAssignment a n := by
have hmle : m ≤ m * n := by
first
| exact Nat.le_mul_of_pos_right m hn
| exact Nat.le_mul_of_pos_right hn
| (have h := Nat.mul_le_mul_left m hn; rwa [Nat.mul_one] at h)
have hnle : n ≤ m * n := by
first
| exact Nat.le_mul_of_pos_left n hm
| exact Nat.le_mul_of_pos_left hm
| (have h := Nat.mul_le_mul_right n hm; rwa [Nat.one_mul] at h)
rw [extendAssignment_bound a (m * n) (m * n + 1) (by omega) (by omega),
extendAssignment_bound a m (m * n + 1) hm (by omega),
extendAssignment_bound a n (m * n + 1) hn (by omega),
sumBelow_congr (extendTerm a (m * n)) (fun i => extendTerm a m i + extendTerm a n i) (m * n + 1)
(fun i _ => extendTerm_mul a m n i hm hn)]
exact sumBelow_add (extendTerm a m) (extendTerm a n) (m * n + 1)
theorem extendTerm_other (a : Nat → Int) (q i : Nat) (hq : isPrime q) (hi : i ≠ q) : extendTerm a q i = 0 := by
unfold extendTerm
by_cases hb : primeTest i = true
· rw [if_pos hb, pExp_other i q ((primeTest_iff i).mp hb) hq hi]; simp
· rw [if_neg hb]
theorem extendAssignment_prime (a : Nat → Int) (q : Nat) (hq : isPrime q) : extendAssignment a q = a q := by
unfold extendAssignment
rw [sumBelow_single (extendTerm a q) q (q + 1) (by omega) (fun i _ hiq => extendTerm_other a q i hq hiq)]
unfold extendTerm
rw [if_pos ((primeTest_iff q).mpr hq), pExp_self q hq]
simp
theorem extendAssignment_additive (a : Nat → Int) : CompletelyAdditive (extendAssignment a) :=
fun m n hm hn => extendAssignment_mul a m n hm hn
/-- **Theorem (every assignment is realized).** For every assignment `a` of integers to the primes, the extension
is completely additive, takes the value `a(p)` at every prime, and is the only completely additive function
that does: the primes are a free basis, existence and uniqueness both proved. -/
theorem primes_admit_every_assignment (a : Nat → Int) :
CompletelyAdditive (extendAssignment a) ∧ (∀ p, isPrime p → extendAssignment a p = a p) ∧
∀ g : Nat → Int, CompletelyAdditive g → (∀ p, isPrime p → g p = a p) →
∀ n, 0 < n → g n = extendAssignment a n :=
⟨extendAssignment_additive a, extendAssignment_prime a,
fun g hg hga => determined_by_primes g (extendAssignment a) hg (extendAssignment_additive a)
(fun p hp => (hga p hp).trans (extendAssignment_prime a p hp).symm)⟩
/-- `Ω(n) = Σ_p v_p(n)`, the prime factors of `n` counted with multiplicity, for every `n`. -/
def omegaAll (n : Nat) : Int := extendAssignment (fun _ => 1) n
/-- `λ(n) = (−1)^{Ω(n)}`, for every `n`. -/
def liouvilleAll (n : Nat) : Int := if omegaAll n % 2 = 0 then 1 else -1
theorem omegaAll_mul (m n : Nat) (hm : 0 < m) (hn : 0 < n) : omegaAll (m * n) = omegaAll m + omegaAll n :=
extendAssignment_mul (fun _ => 1) m n hm hn
theorem omegaAll_prime (p : Nat) (hp : isPrime p) : omegaAll p = 1 :=
extendAssignment_prime (fun _ => 1) p hp
/-- **The arrow, for every n.** `λ` is completely multiplicative, on all positive integers. -/
theorem liouvilleAll_mul (m n : Nat) (hm : 0 < m) (hn : 0 < n) :
liouvilleAll (m * n) = liouvilleAll m * liouvilleAll n := by
unfold liouvilleAll
rw [omegaAll_mul m n hm hn]
generalize omegaAll m = x
generalize omegaAll n = y
by_cases hx : x % 2 = 0 <;> by_cases hy : y % 2 = 0
· rw [if_pos (show (x + y) % 2 = 0 by omega), if_pos hx, if_pos hy]; decide
· rw [if_neg (show ¬ (x + y) % 2 = 0 by omega), if_pos hx, if_neg hy]; decide
· rw [if_neg (show ¬ (x + y) % 2 = 0 by omega), if_neg hx, if_pos hy]; decide
· rw [if_pos (show (x + y) % 2 = 0 by omega), if_neg hx, if_neg hy]; decide
theorem liouvilleAll_prime (p : Nat) (hp : isPrime p) : liouvilleAll p = -1 := by
unfold liouvilleAll
rw [omegaAll_prime p hp]
decide
theorem liouvilleAll_one : liouvilleAll 1 = 1 := by decide
set_option maxRecDepth 100000 in
/-- The arrow for every n agrees with the computed arrow of Section XVII on 1..30. -/
theorem liouvilleAll_agrees_to_30 : ∀ n, n < 30 → Liouville.lam (n + 1) = liouvilleAll (n + 1) := by decide
/-- The Liouville walk `L(x) = Σ_{1 ≤ n ≤ x} λ(n)`, for every `x`. -/
def liouvilleWalk : Nat → Int
| 0 => 0
| n + 1 => liouvilleWalk n + liouvilleAll (n + 1)
/-- The Liouville sentence in integers: for all `k, m ≥ 1` there is `C` with `|L(x)|^{2m} ≤ C^{2m} x^{m+2k}` for every
`x`, that is `L(x) = O(x^{1/2 + k/m})` at every exponent above one half. -/
def FaithfulLambda : Prop :=
∀ k m : Nat, 0 < k → 0 < m → ∃ C : Nat, ∀ x : Nat,
(liouvilleWalk x).natAbs ^ (2 * m) ≤ C ^ (2 * m) * x ^ (m + 2 * k)
/-- The Liouville face pinned to the arithmetic: its sentence is `FaithfulLambda`, a statement about the constructed
walk. The link to the zeros is the cited equivalence of `LiouvilleFace`, carried as the one field. -/
structure LiouvilleFacePinned where
zeros : World
landau : RH zeros ↔ FaithfulLambda
theorem pinned_face_reads (F : LiouvilleFacePinned) : RH F.zeros ↔ FaithfulLambda := F.landau
/-- The pinned face is a Liouville face, with its sentence fixed. -/
def LiouvilleFacePinned.toFace (F : LiouvilleFacePinned) : LiouvilleFace :=
{ zeros := F.zeros, faithful := FaithfulLambda, faithful_iff := F.landau }
theorem pinned_face_is_a_face (F : LiouvilleFacePinned) : F.toFace.faithful = FaithfulLambda := rfl
/-- **The fixed-point form.** A configuration satisfies the hypothesis exactly when it is its own record. -/
theorem rh_iff_own_record (Z : World) : RH Z ↔ ∀ z, Z z ↔ recordOf Z z := by
constructor
· intro hZ z
constructor
· intro hz
exact ⟨z, hz, reg_fixes_line z (hZ z hz)⟩
· intro ⟨s, hs, hsr⟩
subst hsr
rw [reg_fixes_line s (hZ s hs)]
exact hs
· intro h z hz
obtain ⟨s, _, hsr⟩ := (h z).mp hz
subst hsr
exact rfl
/-- The erased part of a configuration: its zeros off the line. -/
def erasedPart (Z : World) : World := fun z => Z z ∧ ¬ onLine z
/-- **The variational form.** Least erasure is leastness: a configuration has least erasure exactly when its erased
part lies inside the erased part of every configuration with the same record. -/
theorem least_erasure_is_least (Z : World) :
LeastErasure Z ↔ ∀ Z', SameRecord Z Z' → ∀ z, erasedPart Z z → erasedPart Z' z := by
rw [least_erasure_is_the_value]
constructor
· intro hZ _ _ z hz
exact absurd (hZ z hz.1) hz.2
· intro h z hz
rcases Decidable.em (onLine z) with hon | hoff
· exact hon
· obtain ⟨⟨s, _, hsr⟩, hoff'⟩ := h (recordOf Z) (record_same Z) z ⟨hz, hoff⟩
exact (hoff' (by rw [← hsr]; exact rfl)).elim
/-- The record is the least member of its fibre, and the only one: it has least erasure, and every configuration of
the fibre with least erasure has exactly its zeros. -/
theorem record_is_the_least (Z : World) :
LeastErasure (recordOf Z) ∧ ∀ Z', SameRecord Z Z' → LeastErasure Z' → ∀ z, Z' z ↔ recordOf Z z := by
have hrh : RH (recordOf Z) := by
intro r hr
obtain ⟨s, _, hsr⟩ := hr
subst hsr
exact rfl
refine ⟨(least_erasure_is_the_value _).mpr hrh, fun Z' h hle z => ?_⟩
exact lossless_unique Z' (recordOf Z) (fun r => (h r).symm.trans (record_same Z r))
((least_erasure_is_the_value Z').mp hle) hrh z
/-- **The closure, whole.** On the chart: the seat is the fixed set of the fold; registration lands on it and fixes
it; over one record both worlds exist, and no record-respecting reading decides the value on fold-closed
configurations; least erasure is the value, is the fixed-point condition, and is leastness in the fibre; the
lossless member of a fibre is unique; nothing escapes the cut; and the act prints the hypothesis at the actual
zero set. -/
theorem the_closure :
(∀ z : Pt, fold z = z ↔ onLine z) ∧
(∀ z : Pt, onLine (reg z) ∧ (onLine z → reg z = z)) ∧
(SameRecord W1 W2 ∧ RH W1 ∧ ¬ RH W2) ∧
(∀ g : World → Prop, RespectsRecord g → ¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z)) ∧
(∀ Z : World, (LeastErasure Z ↔ RH Z) ∧ (RH Z ↔ ∀ z, Z z ↔ recordOf Z z) ∧
(LeastErasure Z ↔ ∀ Z', SameRecord Z Z' → ∀ z, erasedPart Z z → erasedPart Z' z)) ∧
(∀ Z Z' : World, SameRecord Z Z' → RH Z → RH Z' → ∀ z, Z z ↔ Z' z) ∧
(∀ z : Pt, (onLine z ∧ fold z = z ∧ reg z = z) ∨
(¬ onLine z ∧ fold z ≠ z ∧ reg (fold z) = reg z ∧ ∀ w, reg w ≠ z)) ∧
(∀ A : ActualZeros, RH A.zeros) :=
⟨fold_fixed_iff, fun z => ⟨(show (reg z).x = 1 from rfl), reg_fixes_line z⟩, ⟨same_record_12, W1_rh, W2_not_rh⟩,
record_decides_nothing,
fun Z => ⟨least_erasure_is_the_value Z, rh_iff_own_record Z, least_erasure_is_least Z⟩,
lossless_unique, nothing_escapes_one_cut, rh_from_the_act⟩
namespace Carrier
/-- A fold on any carrier: an involution. -/
structure Fold (X : Type) where
σ : X → X
invol : ∀ x, σ (σ x) = x
/-- A registration for a fold: it lands on the fixed set, fixes it, and forgets the side. -/
structure Registration {X : Type} (F : Fold X) where
r : X → X
lands : ∀ x, F.σ (r x) = r x
fixes : ∀ x, F.σ x = x → r x = x
forgets : ∀ x, r (F.σ x) = r x
def RHc {X : Type} (F : Fold X) (Z : X → Prop) : Prop := ∀ x, Z x → F.σ x = x
def recordC {X : Type} {F : Fold X} (R : Registration F) (Z : X → Prop) : X → Prop :=
fun y => ∃ s, Z s ∧ R.r s = y
def SameRecordC {X : Type} {F : Fold X} (R : Registration F) (Z Z' : X → Prop) : Prop :=
∀ y, recordC R Z y ↔ recordC R Z' y
def OffC {X : Type} (F : Fold X) (Z : X → Prop) : Prop := ∃ x, Z x ∧ F.σ x ≠ x
def LeastErasureC {X : Type} {F : Fold X} (R : Registration F) (Z : X → Prop) : Prop :=
∀ Z', SameRecordC R Z Z' → OffC F Z → OffC F Z'
theorem record_same_C {X : Type} {F : Fold X} (R : Registration F) (Z : X → Prop) :
SameRecordC R Z (recordC R Z) := by
intro y
constructor
· intro ⟨s, hs, hsy⟩
exact ⟨R.r s, ⟨s, hs, rfl⟩, by rw [R.fixes (R.r s) (R.lands s)]; exact hsy⟩
· intro ⟨s', ⟨s, hs, hss'⟩, hs'y⟩
subst hss'
exact ⟨s, hs, by rw [← hs'y, R.fixes (R.r s) (R.lands s)]⟩
theorem least_erasure_is_the_value_C {X : Type} {F : Fold X} (R : Registration F)
(em : ∀ x, F.σ x = x ∨ F.σ x ≠ x) (Z : X → Prop) : LeastErasureC R Z ↔ RHc F Z := by
constructor
· intro hle x hx
rcases em x with h | h
· exact h
· obtain ⟨y, ⟨s, _, hsy⟩, hy⟩ := hle (recordC R Z) (record_same_C R Z) ⟨x, hx, h⟩
exact (hy (by rw [← hsy]; exact R.lands s)).elim
· intro hZ _ _ ⟨x, hx, h⟩
exact absurd (hZ x hx) h
theorem rh_iff_own_record_C {X : Type} {F : Fold X} (R : Registration F) (Z : X → Prop) :
RHc F Z ↔ ∀ x, Z x ↔ recordC R Z x := by
constructor
· intro hZ x
constructor
· intro hx
exact ⟨x, hx, R.fixes x (hZ x hx)⟩
· intro ⟨s, hs, hsx⟩
subst hsx
rw [R.fixes s (hZ s hs)]
exact hs
· intro h x hx
obtain ⟨s, _, hsx⟩ := (h x).mp hx
subst hsx
exact R.lands s
theorem one_record_C {X : Type} {F : Fold X} (R : Registration F) (x : X) :
SameRecordC R (fun s => s = R.r x) (fun s => s = x ∨ s = F.σ x) := by
intro y
constructor
· intro ⟨s, hs, hy⟩
refine ⟨x, Or.inl rfl, ?_⟩
rw [← hy, hs, R.fixes (R.r x) (R.lands x)]
· intro ⟨s, hs, hy⟩
refine ⟨R.r x, rfl, ?_⟩
rw [R.fixes (R.r x) (R.lands x), ← hy]
rcases hs with h | h
· rw [h]
· rw [h, R.forgets]
theorem worlds_differ_C {X : Type} {F : Fold X} (R : Registration F) (x : X) (h : F.σ x ≠ x) :
RHc F (fun s => s = R.r x) ∧ ¬ RHc F (fun s => s = x ∨ s = F.σ x) :=
⟨fun _ hs => hs ▸ R.lands x, fun hall => h (hall x (Or.inl rfl))⟩
theorem no_reading_decides_C {X : Type} {F : Fold X} (R : Registration F) (x : X) (h : F.σ x ≠ x)
(g : (X → Prop) → Prop) (hg : ∀ Z Z', SameRecordC R Z Z' → (g Z ↔ g Z')) :
¬ ((g (fun s => s = R.r x) ↔ RHc F (fun s => s = R.r x)) ∧
(g (fun s => s = x ∨ s = F.σ x) ↔ RHc F (fun s => s = x ∨ s = F.σ x))) := by
intro ⟨h1, h2⟩
exact (worlds_differ_C R x h).2 (h2.mp ((hg _ _ (one_record_C R x)).mp (h1.mpr (worlds_differ_C R x h).1)))
/-- On any carrier the lossless member of a record is unique: two configurations of one record that both
satisfy the hypothesis carry the same points. -/
theorem lossless_unique_C {X : Type} {F : Fold X} (R : Registration F) (Z Z' : X → Prop)
(hs : SameRecordC R Z Z') (h : RHc F Z) (h' : RHc F Z') : ∀ x, Z x ↔ Z' x :=
fun x => ((rh_iff_own_record_C R Z).mp h x).trans ((hs x).trans ((rh_iff_own_record_C R Z').mp h' x).symm)
/-- The chart's fold, as a carrier fold. -/
def chartFold : Fold Pt := ⟨fold, fold_fold⟩
/-- The chart's registration, as a carrier registration. -/
def chartReg : Registration chartFold :=
⟨reg, fun z => (fold_fixed_iff (reg z)).mpr rfl, fun z h => reg_fixes_line z ((fold_fixed_iff z).mp h),
fun _ => rfl⟩
/-- **The chart is one instance.** Its fixed set is the line, and the carrier's hypothesis is the chart's. -/
theorem chart_is_an_instance :
(∀ z, chartFold.σ z = z ↔ onLine z) ∧ ∀ Z : World, RHc chartFold Z ↔ RH Z :=
⟨fold_fixed_iff, fun _ => ⟨fun h z hz => (fold_fixed_iff z).mp (h z hz), fun h z hz => (fold_fixed_iff z).mpr (h z hz)⟩⟩
/-- **The closure on any carrier.** On every carrier with an involution and a registration on which fixedness is
decided: least erasure is the value; the value is lossless registration; the lossless member of a record is
unique; and every point off the fixed set gives two worlds of one record that differ in the value. -/
theorem the_closure_on_any_carrier {X : Type} {F : Fold X} (R : Registration F) (em : ∀ x, F.σ x = x ∨ F.σ x ≠ x) :
(∀ Z, LeastErasureC R Z ↔ RHc F Z) ∧ (∀ Z, RHc F Z ↔ ∀ x, Z x ↔ recordC R Z x) ∧
(∀ Z Z', SameRecordC R Z Z' → RHc F Z → RHc F Z' → ∀ x, Z x ↔ Z' x) ∧
(∀ x, F.σ x ≠ x → SameRecordC R (fun s => s = R.r x) (fun s => s = x ∨ s = F.σ x) ∧
RHc F (fun s => s = R.r x) ∧ ¬ RHc F (fun s => s = x ∨ s = F.σ x)) :=
⟨least_erasure_is_the_value_C R em, rh_iff_own_record_C R, lossless_unique_C R,
fun x h => ⟨one_record_C R x, worlds_differ_C R x h⟩⟩
end Carrier
/-! ## XXII · The socket: every route to the value lands in the one field
An unconditional closure would be a closed term of type `LeastErasure Z` at the actual zero set, placed in the field
`supply` of `ActualZeros`. This section proves that the field is the only socket and that nothing reaches the value by
another way. A term of the hypothesis at a fold-closed configuration exists exactly when the field can be filled there,
and the closure theorem of Section XXI takes any term in the field with no other change. A premise on configurations
either forces the line or holds at a fold-closed configuration where the value fails; a keyless premise forces nothing;
a forcing premise that respects the record fails at every nonempty fold-closed configuration; a forcing premise either
is the value on every fold-closed configuration or fails at one that satisfies the hypothesis; and a forcing premise
that holds at a configuration fills the field there. A sentence carried to the zeros by a cited equivalence fills the
field exactly when it holds, whatever the sentence. The named sentences depend on their own configurations: Weil
positivity differs between two explicit formulas with every field, no prefix of a Li stream forces, and the Liouville
sentence, read as a property of an assignment at the primes, fails at the assignment that sends every prime to zero.
The one refutation is one point. -/
/-- The field can be filled at a fold-closed configuration exactly when the hypothesis holds there, and exactly when
least erasure does. -/
theorem socket_is_the_value (Z : World) (hZ : FoldClosed Z) :
((∃ S : ActualZeros, S.zeros = Z) ↔ RH Z) ∧ ((∃ S : ActualZeros, S.zeros = Z) ↔ LeastErasure Z) := by
have h1 : (∃ S : ActualZeros, S.zeros = Z) ↔ RH Z :=
⟨fun ⟨S, hS⟩ => hS ▸ rh_from_the_act S, fun h => ⟨⟨Z, hZ, (least_erasure_is_the_value Z).mpr h⟩, rfl⟩⟩
exact ⟨h1, h1.trans (least_erasure_is_the_value Z).symm⟩
/-- The closure theorem takes a term in the field and changes nothing else: its last conjunct, applied to the
configuration with the term, gives the hypothesis. -/
theorem closure_takes_a_term (Z : World) (hZ : FoldClosed Z) (s : LeastErasure Z) : RH Z :=
the_closure.2.2.2.2.2.2.2 ⟨Z, hZ, s⟩
/-- At W1 the field holds a closed term, and the closure gives the hypothesis there with nothing assumed. -/
theorem closure_at_a_term : RH W1 :=
closure_takes_a_term W1 W1_closed ((least_erasure_is_the_value W1).mpr W1_rh)
/-- Every premise either forces the line or holds at a fold-closed configuration where the value fails. Classical. -/
theorem forces_or_has_a_twin (A : World → Prop) : Forces A ∨ ∃ Z, FoldClosed Z ∧ A Z ∧ ¬ RH Z :=
Classical.byCases (p := ∃ Z, FoldClosed Z ∧ A Z ∧ ¬ RH Z) Or.inr
(fun h => Or.inl (fun Z hZ ha => Classical.byContradiction (fun hn => h ⟨Z, hZ, ha, hn⟩)))
/-- A configuration with one more pair, at real parts 0 and 1 and at the height `t`. -/
def withPair (Z : World) (t : Nat) : World := fun w => Z w ∨ w = ⟨0, t⟩ ∨ w = ⟨2, t⟩
theorem withPair_closed (Z : World) (hZ : FoldClosed Z) (t : Nat) : FoldClosed (withPair Z t) := by
intro w hw
rcases hw with h | h | h
· exact Or.inl (hZ w h)
· subst h
exact Or.inr (Or.inr rfl)
· subst h
exact Or.inr (Or.inl rfl)
/-- The pair added at the height of a zero leaves the record unchanged: both new points have the registration of that zero. -/
theorem withPair_same_record (Z : World) (z : Pt) (hz : Z z) : SameRecord Z (withPair Z z.t) := by
intro r
constructor
· intro ⟨s, hs, hsr⟩
exact ⟨s, Or.inl hs, hsr⟩
· intro ⟨s, hs, hsr⟩
rcases hs with h | h | h
· exact ⟨s, h, hsr⟩
· subst h
exact ⟨z, hz, hsr⟩
· subst h
exact ⟨z, hz, hsr⟩
theorem withPair_not_rh (Z : World) (t : Nat) : ¬ RH (withPair Z t) := by
intro h
have e : (0 : Int) = 1 := h ⟨0, t⟩ (Or.inr (Or.inl rfl))
omega
/-- A premise that respects the record and forces the line fails at every nonempty fold-closed configuration: the
configuration and its copy with one more pair share a record, and the copy fails the hypothesis. -/
theorem record_forcing_fails_everywhere (A : World → Prop) (hr : RespectsRecord A) (hf : Forces A) (Z : World)
(hZ : FoldClosed Z) (hne : ∃ z, Z z) : ¬ A Z := by
intro ha
obtain ⟨z, hz⟩ := hne
exact withPair_not_rh Z z.t (hf (withPair Z z.t) (withPair_closed Z hZ z.t)
((hr Z (withPair Z z.t) (withPair_same_record Z z hz)).mp ha))
/-- A premise that forces the line either is the value on every fold-closed configuration or fails at a fold-closed
configuration that satisfies the hypothesis. Classical. -/
theorem forcing_is_the_value_or_stronger (A : World → Prop) (hf : Forces A) :
(∀ Z, FoldClosed Z → (A Z ↔ RH Z)) ∨ ∃ Z, FoldClosed Z ∧ RH Z ∧ ¬ A Z :=
Classical.byCases (p := ∃ Z, FoldClosed Z ∧ RH Z ∧ ¬ A Z) Or.inr
(fun h => Or.inl (fun Z hZ => ⟨hf Z hZ, fun hrh => Classical.byContradiction (fun hna => h ⟨Z, hZ, hrh, hna⟩)⟩))
/-- A premise that forces the line and holds at a fold-closed configuration fills the field there. -/
theorem forcing_fills_the_socket (A : World → Prop) (hf : Forces A) (Z : World) (hZ : FoldClosed Z) (ha : A Z) :
∃ S : ActualZeros, S.zeros = Z :=
(socket_is_the_value Z hZ).1.mpr (hf Z hZ ha)
/-- A sentence carried to a configuration by a cited equivalence with the hypothesis. -/
structure SocketFace where
zeros : World
sentence : Prop
cited : RH zeros ↔ sentence
/-- Whatever the sentence, it holds exactly when the field can be filled at its configuration. -/
theorem face_is_the_socket (F : SocketFace) (hF : FoldClosed F.zeros) :
F.sentence ↔ ∃ S : ActualZeros, S.zeros = F.zeros :=
F.cited.symm.trans (socket_is_the_value F.zeros hF).1.symm
def SocketFace.ofWeil (E : ExplicitFormula) : SocketFace := ⟨E.zeros, WeilPositive E, (spend_is_the_line E).symm⟩
def SocketFace.ofLi (L : LiStream) : SocketFace := ⟨L.zeros, ∀ n, 1 ≤ n → L.nonneg n, L.li⟩
def SocketFace.ofSign {V : Type} [LE V] (D : DBN V) : SocketFace := ⟨D.zeros, D.lam ≤ D.zero, rh_iff_the_sign D⟩
def SocketFace.ofLiouville (F : LiouvilleFacePinned) : SocketFace := ⟨F.zeros, FaithfulLambda, F.landau⟩
def SocketFace.ofPosit (Z : World) : SocketFace := ⟨Z, LeastErasure Z, (least_erasure_is_the_value Z).symm⟩
/-- Weil positivity, the Li stream, the sign of Λ, the Liouville sentence and least erasure itself each fill the field
exactly when they hold. -/
theorem named_faces_are_the_socket :
(∀ E : ExplicitFormula, FoldClosed E.zeros → (WeilPositive E ↔ ∃ S : ActualZeros, S.zeros = E.zeros)) ∧
(∀ L : LiStream, FoldClosed L.zeros → ((∀ n, 1 ≤ n → L.nonneg n) ↔ ∃ S : ActualZeros, S.zeros = L.zeros)) ∧
(∀ (V : Type) [LE V] (D : DBN V), FoldClosed D.zeros → (D.lam ≤ D.zero ↔ ∃ S : ActualZeros, S.zeros = D.zeros)) ∧
(∀ F : LiouvilleFacePinned, FoldClosed F.zeros → (FaithfulLambda ↔ ∃ S : ActualZeros, S.zeros = F.zeros)) ∧
(∀ Z : World, FoldClosed Z → (LeastErasure Z ↔ ∃ S : ActualZeros, S.zeros = Z)) :=
⟨fun E hE => face_is_the_socket (SocketFace.ofWeil E) hE,
fun L hL => face_is_the_socket (SocketFace.ofLi L) hL,
fun _ _ D hD => face_is_the_socket (SocketFace.ofSign D) hD,
fun F hF => face_is_the_socket (SocketFace.ofLiouville F) hF,
fun Z hZ => face_is_the_socket (SocketFace.ofPosit Z) hZ⟩
/-- The sign arrow of an assignment at the primes: `(−1)^{f(n)}` for the completely additive `f` with the value `a(p)`
at every prime. The assignment that sends every prime to one gives `λ`. -/
def arrowOf (a : Nat → Int) (n : Nat) : Int := if extendAssignment a n % 2 = 0 then 1 else -1
/-- The walk of an assignment: the sum of its arrow over `1 ≤ n ≤ x`. -/
def walkOf (a : Nat → Int) : Nat → Int
| 0 => 0
| n + 1 => walkOf a n + arrowOf a (n + 1)
/-- The Liouville sentence for an assignment at the primes. -/
def FaithfulOf (a : Nat → Int) : Prop :=
∀ k m : Nat, 0 < k → 0 < m → ∃ C : Nat, ∀ x : Nat,
(walkOf a x).natAbs ^ (2 * m) ≤ C ^ (2 * m) * x ^ (m + 2 * k)
theorem walk_is_the_walk_of_one (x : Nat) : liouvilleWalk x = walkOf (fun _ => 1) x := by
induction x with
| zero => rfl
| succ n ih =>
show liouvilleWalk n + liouvilleAll (n + 1) = walkOf (fun _ => 1) n + arrowOf (fun _ => 1) (n + 1)
rw [ih]
rfl
/-- The Liouville sentence is the sentence of the assignment that sends every prime to one. -/
theorem faithful_is_the_sentence_of_one : FaithfulLambda ↔ FaithfulOf (fun _ => 1) := by
unfold FaithfulLambda FaithfulOf
simp only [walk_is_the_walk_of_one]
/-- The assignment that sends every prime to zero extends to zero everywhere. -/
theorem blind_assignment_vanishes (n : Nat) : extendAssignment (fun _ => 0) n = 0 := by
unfold extendAssignment
exact sumBelow_zero _ _ (fun i _ => by unfold extendTerm; split <;> simp)
/-- At that assignment the arrow is one everywhere and the walk is the identity. -/
theorem blind_walk (x : Nat) : walkOf (fun _ => 0) x = (x : Int) := by
induction x with
| zero => rfl
| succ n ih =>
show walkOf (fun _ => 0) n + arrowOf (fun _ => 0) (n + 1) = ((n + 1 : Nat) : Int)
rw [ih]
unfold arrowOf
rw [blind_assignment_vanishes, if_pos (by decide)]
omega
/-- The Liouville sentence fails at the assignment that sends every prime to zero: at `k = 1, m = 3` the walk `x` would
need `x^6 ≤ C^6 x^5`, which fails at `x = C^6 + 1`. -/
theorem blind_is_unfaithful : ¬ FaithfulOf (fun _ => 0) := by
intro h
obtain ⟨C, hC⟩ := h 1 3 (by decide) (by decide)
have hx := hC (C ^ 6 + 1)
rw [blind_walk] at hx
change (C ^ 6 + 1) ^ 6 ≤ C ^ 6 * (C ^ 6 + 1) ^ 5 at hx
have hpos : 0 < (C ^ 6 + 1) ^ 5 := Nat.pow_pos (Nat.succ_pos _)
have e : (C ^ 6 + 1) ^ 6 = (C ^ 6 + 1) ^ 5 * (C ^ 6 + 1) := Nat.pow_succ (C ^ 6 + 1) 5
rw [e] at hx
generalize (C ^ 6 + 1) ^ 5 = y at hx hpos
generalize C ^ 6 = c at hx
rw [Nat.mul_succ, Nat.mul_comm c y] at hx
omega
/-- The Liouville sentence reads the primes: it is the sentence of one assignment, it fails at another, and so no proof
of it holds for every assignment. -/
theorem faithful_reads_the_primes :
(FaithfulLambda ↔ FaithfulOf (fun _ => 1)) ∧ ¬ FaithfulOf (fun _ => 0) ∧ ¬ ∀ a : Nat → Int, FaithfulOf a :=
⟨faithful_is_the_sentence_of_one, blind_is_unfaithful, fun h => blind_is_unfaithful (h _)⟩
/-- **The socket, whole.** The field of the act is the one socket: it can be filled at a fold-closed configuration
exactly when the hypothesis holds, and the closure takes any term in it with no other change. Every premise on
configurations forces the line or holds at a fold-closed configuration where the value fails; a keyless premise
forces nothing; a premise that respects the record and forces the line fails at every nonempty fold-closed
configuration; a forcing premise is the value or fails at a configuration that satisfies the hypothesis, and fills
the field wherever it holds. Every sentence carried to the zeros by a cited equivalence fills the field exactly when
it holds. The named sentences depend on their configurations, and the one refutation is one point. -/
theorem the_socket :
(∀ Z : World, FoldClosed Z → ((∃ S : ActualZeros, S.zeros = Z) ↔ RH Z)) ∧
(∀ Z : World, FoldClosed Z → LeastErasure Z → RH Z) ∧
(∀ A : World → Prop, Forces A ∨ ∃ Z, FoldClosed Z ∧ A Z ∧ ¬ RH Z) ∧
(∀ A : World → Prop, Keyless A → ¬ Forces A) ∧
(∀ A : World → Prop, RespectsRecord A → Forces A → ∀ Z, FoldClosed Z → (∃ z, Z z) → ¬ A Z) ∧
(∀ A : World → Prop, Forces A → (∀ Z, FoldClosed Z → (A Z ↔ RH Z)) ∨ ∃ Z, FoldClosed Z ∧ RH Z ∧ ¬ A Z) ∧
(∀ A : World → Prop, Forces A → ∀ Z, FoldClosed Z → A Z → ∃ S : ActualZeros, S.zeros = Z) ∧
(∀ F : SocketFace, FoldClosed F.zeros → (F.sentence ↔ ∃ S : ActualZeros, S.zeros = F.zeros)) ∧
(WeilPositive positiveInstance ∧ ¬ WeilPositive negativeInstance) ∧
(∀ N : Nat, ∃ L : LiStream, (∀ n, n < N → L.nonneg n) ∧ ¬ RH L.zeros) ∧
((FaithfulLambda ↔ FaithfulOf (fun _ => 1)) ∧ ¬ FaithfulOf (fun _ => 0)) ∧
(∀ Z : World, ¬ LeastErasure Z ↔ OffLine Z) :=
⟨fun Z hZ => (socket_is_the_value Z hZ).1, closure_takes_a_term, forces_or_has_a_twin, keyless_forces_nothing,
record_forcing_fails_everywhere, forcing_is_the_value_or_stronger, forcing_fills_the_socket, face_is_the_socket,
positivity_is_keyed, li_prefix_never_forces, ⟨faithful_is_the_sentence_of_one, blind_is_unfaithful⟩,
rejection_is_a_witness⟩
/-! ### XXII.b · At resolution two the open strip holds a pair off the line
At resolution one the chart's open strip `0 < x < 2` holds only the line, so a premise that places every zero inside
the open strip forces the line there: a fact of the coarse chart, not of the zeros. On the chart at resolution two, with
`x = 4 Re s`, the line `x = 2`, the fold `x ↦ 4 − x` and registration `(x, t) ↦ (2, t)`, the open strip `0 < x < 4`
holds the pair `x = 1, 3`, real parts one quarter and three quarters. There the open-strip premise forces nothing, no
reading of the record decides the value, and the refusals of the socket hold for premises that range over strip
configurations only. -/
def fold₂ (z : Pt) : Pt := ⟨4 - z.x, z.t⟩
def reg₂ (z : Pt) : Pt := ⟨2, z.t⟩
def onLine₂ (z : Pt) : Prop := z.x = 2
def InStrip₂ (z : Pt) : Prop := 0 < z.x ∧ z.x < 4
/-- A strip configuration at resolution two: fold-closed, and every zero inside the open strip. -/
def StripWorld₂ (Z : World) : Prop := (∀ z, Z z → Z (fold₂ z)) ∧ ∀ z, Z z → InStrip₂ z
def RH₂ (Z : World) : Prop := ∀ z, Z z → onLine₂ z
def SameRecord₂ (Z Z' : World) : Prop := ∀ r, (∃ s, Z s ∧ reg₂ s = r) ↔ (∃ s, Z' s ∧ reg₂ s = r)
/-- A premise respects the record when it reads alike on two strip configurations of one record. -/
def RespectsRecord₂ (A : World → Prop) : Prop :=
∀ Z Z', StripWorld₂ Z → StripWorld₂ Z' → SameRecord₂ Z Z' → (A Z ↔ A Z')
/-- A premise forces the line when every strip configuration it holds on satisfies the hypothesis. -/
def Forces₂ (A : World → Prop) : Prop := ∀ Z, StripWorld₂ Z → A Z → RH₂ Z
/-- The seat at resolution two: the fixed set of the fold is the line. -/
theorem fold₂_fixed_iff (z : Pt) : fold₂ z = z ↔ onLine₂ z := by
cases z with
| mk x t =>
show Pt.mk (4 - x) t = Pt.mk x t ↔ x = 2
constructor
· intro h
have hx := congrArg Pt.x h
change 4 - x = x at hx
omega
· intro h
subst h
rfl
/-- At resolution one the open strip is the line: the premise that places every zero inside it forces the line. -/
theorem open_strip_forces_at_resolution_one : Forces (fun Z => ∀ z, Z z → 0 < z.x ∧ z.x < 2) := by
intro Z _ h z hz
have := h z hz
show z.x = 1
omega
/-- The pair at real parts one quarter and three quarters, at the height `t`. -/
def innerPair₂ (t : Nat) : World := fun w => w = ⟨1, t⟩ ∨ w = ⟨3, t⟩
theorem innerPair₂_strip (t : Nat) : StripWorld₂ (innerPair₂ t) := by
refine ⟨fun w hw => ?_, fun w hw => ?_⟩
· rcases hw with h | h
· subst h
exact Or.inr rfl
· subst h
exact Or.inl rfl
· rcases hw with h | h
· subst h
exact ⟨show (0 : Int) < 1 by decide, show (1 : Int) < 4 by decide⟩
· subst h
exact ⟨show (0 : Int) < 3 by decide, show (3 : Int) < 4 by decide⟩
theorem innerPair₂_not_rh (t : Nat) : ¬ RH₂ (innerPair₂ t) := by
intro h
have e : (1 : Int) = 2 := h ⟨1, t⟩ (Or.inl rfl)
omega
/-- At resolution two the open-strip premise forces nothing: the inner pair satisfies it and fails the hypothesis. -/
theorem open_strip_forces_nothing_at_resolution_two : ¬ Forces₂ (fun Z => ∀ z, Z z → InStrip₂ z) :=
fun h => innerPair₂_not_rh 0 (h (innerPair₂ 0) (innerPair₂_strip 0) (innerPair₂_strip 0).2)
/-- A premise true on every configuration forces nothing on strip configurations. -/
theorem keyless_forces_nothing₂ (A : World → Prop) (hA : ∀ Z, A Z) : ¬ Forces₂ A :=
fun h => innerPair₂_not_rh 0 (h _ (innerPair₂_strip 0) (hA _))
/-- A strip configuration with the inner pair added at the height `t`. -/
def withPair₂ (Z : World) (t : Nat) : World := fun w => Z w ∨ w = ⟨1, t⟩ ∨ w = ⟨3, t⟩
theorem withPair₂_strip (Z : World) (hZ : StripWorld₂ Z) (t : Nat) : StripWorld₂ (withPair₂ Z t) := by
refine ⟨fun w hw => ?_, fun w hw => ?_⟩
· rcases hw with h | h | h
· exact Or.inl (hZ.1 w h)
· subst h
exact Or.inr (Or.inr rfl)
· subst h
exact Or.inr (Or.inl rfl)
· rcases hw with h | h | h
· exact hZ.2 w h
· subst h
exact ⟨show (0 : Int) < 1 by decide, show (1 : Int) < 4 by decide⟩
· subst h
exact ⟨show (0 : Int) < 3 by decide, show (3 : Int) < 4 by decide⟩
theorem withPair₂_same_record (Z : World) (z : Pt) (hz : Z z) : SameRecord₂ Z (withPair₂ Z z.t) := by
intro r
constructor
· intro ⟨s, hs, hsr⟩
exact ⟨s, Or.inl hs, hsr⟩
· intro ⟨s, hs, hsr⟩
rcases hs with h | h | h
· exact ⟨s, h, hsr⟩
· subst h
exact ⟨z, hz, hsr⟩
· subst h
exact ⟨z, hz, hsr⟩
theorem withPair₂_not_rh (Z : World) (t : Nat) : ¬ RH₂ (withPair₂ Z t) := by
intro h
have e : (1 : Int) = 2 := h ⟨1, t⟩ (Or.inr (Or.inl rfl))
omega
/-- A premise that respects the record and forces the line on strip configurations fails at every nonempty strip
configuration: its copy with the inner pair at the height of one of its zeros shares its record and fails the
hypothesis. -/
theorem record_forcing_fails_in_the_strip (A : World → Prop) (hr : RespectsRecord₂ A) (hf : Forces₂ A) (Z : World)
(hZ : StripWorld₂ Z) (hne : ∃ z, Z z) : ¬ A Z := by
intro ha
obtain ⟨z, hz⟩ := hne
have hs := withPair₂_strip Z hZ z.t
exact withPair₂_not_rh Z z.t (hf _ hs ((hr Z _ hZ hs (withPair₂_same_record Z z hz)).mp ha))
/-- No reading that respects the record decides the hypothesis on strip configurations. -/
theorem no_reading_decides_in_the_strip (g : World → Prop) (hg : RespectsRecord₂ g) :
¬ ∀ Z, StripWorld₂ Z → (g Z ↔ RH₂ Z) := by
intro h
have hL : StripWorld₂ (fun w => w = ⟨2, 14⟩) :=
⟨fun w hw => by rw [hw]; rfl, fun w hw => by rw [hw]; exact ⟨by decide, by decide⟩⟩
have hLrh : RH₂ (fun w => w = ⟨2, 14⟩) := fun w hw => by rw [hw]; rfl
have hs := withPair₂_strip _ hL 14
have hsame : SameRecord₂ (fun w => w = ⟨2, 14⟩) (withPair₂ (fun w => w = ⟨2, 14⟩) 14) :=
withPair₂_same_record _ ⟨2, 14⟩ rfl
exact withPair₂_not_rh _ 14 ((h _ hs).mp ((hg _ _ hL hs hsame).mp ((h _ hL).mpr hLrh)))
/-- Every premise either forces the line on strip configurations or holds at a strip configuration where the value
fails. Classical. -/
theorem forces_or_has_a_twin₂ (A : World → Prop) : Forces₂ A ∨ ∃ Z, StripWorld₂ Z ∧ A Z ∧ ¬ RH₂ Z :=
Classical.byCases (p := ∃ Z, StripWorld₂ Z ∧ A Z ∧ ¬ RH₂ Z) Or.inr
(fun h => Or.inl (fun Z hZ ha => Classical.byContradiction (fun hn => h ⟨Z, hZ, ha, hn⟩)))
/-- **The socket in the strip.** At resolution one the open strip is the line; at resolution two the fold fixes the
line, the open strip holds a pair off the line at every height, the open-strip premise and every keyless premise
force nothing, no reading of the record decides, a record-respecting forcing premise fails at every nonempty strip
configuration, and every premise forces or holds where the value fails. -/
theorem the_socket_in_the_strip :
Forces (fun Z => ∀ z, Z z → 0 < z.x ∧ z.x < 2) ∧
(∀ z : Pt, fold₂ z = z ↔ onLine₂ z) ∧
(∀ t : Nat, StripWorld₂ (innerPair₂ t) ∧ ¬ RH₂ (innerPair₂ t)) ∧
¬ Forces₂ (fun Z => ∀ z, Z z → InStrip₂ z) ∧
(∀ A : World → Prop, (∀ Z, A Z) → ¬ Forces₂ A) ∧
(∀ g : World → Prop, RespectsRecord₂ g → ¬ ∀ Z, StripWorld₂ Z → (g Z ↔ RH₂ Z)) ∧
(∀ A : World → Prop, RespectsRecord₂ A → Forces₂ A → ∀ Z, StripWorld₂ Z → (∃ z, Z z) → ¬ A Z) ∧
(∀ A : World → Prop, Forces₂ A ∨ ∃ Z, StripWorld₂ Z ∧ A Z ∧ ¬ RH₂ Z) :=
⟨open_strip_forces_at_resolution_one, fold₂_fixed_iff, fun t => ⟨innerPair₂_strip t, innerPair₂_not_rh t⟩,
open_strip_forces_nothing_at_resolution_two, keyless_forces_nothing₂, no_reading_decides_in_the_strip,
record_forcing_fails_in_the_strip, forces_or_has_a_twin₂⟩
/-! ## XXII.c · Two denials, and the witness the act forces
A denial has two parts: the act of making it, and the sentence it asserts. Two denials are read side by side, over
every self-grounding root. The denial of the root asserts that the root fails; the act of making it instances the
root, so its sentence is refuted by its own act and only the root remains. The denial of the hypothesis asserts that
a zero lies off the line; the act of making it instances the root, which the twin carries too, and its sentence denies
the self-grounding assertion of the line at the zero set, which the twin does not carry: in time the twin is timeless
and unseeded. The assertion stands at the actual zero set by the act of section XI, and there the denial is refuted.
On the act every computation that reads the zero set reports points on the line, and a computation that reports a
point off the line reads no act. -/
/-- A seeded timeless witness of the line, for a world in time: one locus at every instant, the same truth value of
the hypothesis at every instant, and the hypothesis at instant 0, the seed. -/
structure SeededWitness (W : TWorld) : Prop where
same_locus : SameLocus W
timeless : TimelessT W
seed : RH (W 0)
/-- A world in time carries a seeded timeless witness exactly when the hypothesis holds at every instant. -/
theorem seeded_witness_iff_bound (W : TWorld) : SeededWitness W ↔ BoundT W :=
⟨fun w => (template_binds_iff_seed W w.timeless).mpr w.seed,
fun h => ⟨fold_face_keyless W, fun t s => ⟨fun _ => h s, fun _ => h t⟩, h 0⟩⟩
/-- The constant twin, timeless and fold-closed at every instant, carries no seeded witness. -/
theorem twin_has_no_seeded_witness : ¬ SeededWitness WTwin :=
fun w => W2f_not_rh w.seed
/-- The constant on-line world carries one. -/
theorem line_world_has_a_seeded_witness : SeededWitness WOn :=
(seeded_witness_iff_bound WOn).mpr closure_face_on_line
/-- Every denial, whatever its sentence, is an act, and every act instances the root. -/
theorem every_denial_is_an_act {root C : Prop} (G : SelfGrounding root) (a : G.Act) (_c : C) : root :=
G.instances a
/-- A denial of a self-grounding root is refuted by its own act: its sentence denies what its act instances. -/
theorem root_denial_refutes_itself {root : Prop} (G : SelfGrounding root) (a : G.Act) (n : ¬ root) : False :=
n (G.instances a)
/-- A denial of the hypothesis at a world denies the self-grounding assertion of the line there. -/
theorem line_denial_denies_the_assertion (Z : World) (h : ¬ RH Z) :
¬ ∃ G : SelfGrounding (RH Z), Nonempty G.Act :=
fun e => h ((supply_iff (RH Z)).mp e)
/-- In time, a denial of the hypothesis at instant 0 denies every seeded witness. -/
theorem line_denial_denies_every_seed (W : TWorld) (h : ¬ RH (W 0)) : ¬ SeededWitness W :=
fun w => h w.seed
/-- The twin carries the root, fold-closure, the record of W1 and the timeless form; it carries neither a
self-grounding assertion of the line nor a seeded witness. -/
theorem twin_carries_the_root_and_no_seed {root : Prop} (G : SelfGrounding root) :
root ∧ FoldClosed W2f ∧ SameRecord W1 W2f ∧ TimelessT WTwin ∧ ¬ RH W2f ∧
(¬ ∃ G' : SelfGrounding (RH W2f), Nonempty G'.Act) ∧ ¬ SeededWitness WTwin :=
⟨G.instances G.anAct, W2f_closed, same_record_f, fun _ _ => Iff.rfl, W2f_not_rh, line_not_self_grounding,
twin_has_no_seeded_witness⟩
/-- The root alone forces nothing: it holds on every world, the twin written out included. -/
theorem the_root_alone_forces_nothing {root : Prop} (G : SelfGrounding root) : ¬ Forces (fun _ => root) :=
keyless_forces_nothing_free (fun _ => root) (fun _ => G.instances G.anAct)
/-- At every instance of the actual zero set the self-grounding assertion of the line exists. -/
theorem the_act_asserts_the_line (A : ActualZeros) : ∃ G : SelfGrounding (RH A.zeros), Nonempty G.Act :=
(supply_iff (RH A.zeros)).mpr (rh_from_the_act A)
/-- The constant family of the actual zero set carries a seeded witness. -/
theorem the_act_seeds_its_constant_world (A : ActualZeros) : SeededWitness (fun _ => A.zeros) :=
(seeded_witness_iff_bound _).mpr (fun _ => rh_from_the_act A)
/-- On the act the denial of the hypothesis is refuted. -/
theorem line_denial_refuted_on_the_act (A : ActualZeros) (h : ¬ RH A.zeros) : False :=
h (rh_from_the_act A)
/-- TWO DENIALS, ONE FORM. For every self-grounding root: every denial is an act and instances the root; the denial
of the root is refuted by its own act; the denial of the hypothesis denies the self-grounding assertion of the line
and, in time, the seed; the twin carries the root and neither of these, so the root alone forces nothing, and a
seeded witness exists exactly where the line holds at every instant; on the act the assertion exists, the seed
stands, and the denial is refuted. -/
theorem two_denials {root : Prop} (G : SelfGrounding root) :
(∀ C : Prop, G.Act → C → root) ∧
(G.Act → ¬ root → False) ∧
(∀ Z : World, ¬ RH Z → ¬ ∃ G' : SelfGrounding (RH Z), Nonempty G'.Act) ∧
(∀ W : TWorld, SeededWitness W ↔ BoundT W) ∧
(root ∧ FoldClosed W2f ∧ SameRecord W1 W2f ∧ TimelessT WTwin ∧ ¬ RH W2f ∧
(¬ ∃ G' : SelfGrounding (RH W2f), Nonempty G'.Act) ∧ ¬ SeededWitness WTwin) ∧
SeededWitness WOn ∧
¬ Forces (fun _ => root) ∧
(∀ A : ActualZeros, (∃ G' : SelfGrounding (RH A.zeros), Nonempty G'.Act) ∧
SeededWitness (fun _ => A.zeros) ∧ (¬ RH A.zeros → False)) :=
⟨fun _ a c => every_denial_is_an_act G a c,
fun a n => root_denial_refutes_itself G a n,
line_denial_denies_the_assertion,
seeded_witness_iff_bound,
twin_carries_the_root_and_no_seed G,
line_world_has_a_seeded_witness,
the_root_alone_forces_nothing G,
fun A => ⟨the_act_asserts_the_line A, the_act_seeds_its_constant_world A, line_denial_refuted_on_the_act A⟩⟩
/-- At the root proposition 0 < 1, with the unit act. -/
theorem two_denials_at_the_root :
(∀ C : Prop, rootSelfGrounding.Act → C → RootAct) ∧
(rootSelfGrounding.Act → ¬ RootAct → False) ∧
(∀ Z : World, ¬ RH Z → ¬ ∃ G' : SelfGrounding (RH Z), Nonempty G'.Act) ∧
(∀ W : TWorld, SeededWitness W ↔ BoundT W) ∧
(RootAct ∧ FoldClosed W2f ∧ SameRecord W1 W2f ∧ TimelessT WTwin ∧ ¬ RH W2f ∧
(¬ ∃ G' : SelfGrounding (RH W2f), Nonempty G'.Act) ∧ ¬ SeededWitness WTwin) ∧
SeededWitness WOn ∧
¬ Forces (fun _ => RootAct) ∧
(∀ A : ActualZeros, (∃ G' : SelfGrounding (RH A.zeros), Nonempty G'.Act) ∧
SeededWitness (fun _ => A.zeros) ∧ (¬ RH A.zeros → False)) :=
two_denials rootSelfGrounding
/-- A computation that ends: the finite list of points it reports as zeros. -/
structure Computation where
reports : List Pt
/-- A computation reads an act when every point it reports is a zero of the act's zero set. -/
def Computation.Reads (c : Computation) (A : ActualZeros) : Prop := ∀ z, z ∈ c.reports → A.zeros z
/-- On the act nothing is left open: the hypothesis, least erasure, no point off the line, the zero set its own
record, and every consequence of the hypothesis at the zero set. -/
theorem nothing_left_open_on_the_act (A : ActualZeros) :
RH A.zeros ∧ LeastErasure A.zeros ∧ ¬ OffLine A.zeros ∧ (∀ z, A.zeros z ↔ recordOf A.zeros z) ∧
(∀ Q : World → Prop, (∀ Z, RH Z → Q Z) → Q A.zeros) :=
⟨rh_from_the_act A, A.supply, fun ⟨z, hz, h⟩ => h (rh_from_the_act A z hz),
(rh_iff_own_record A.zeros).mp (rh_from_the_act A), fun _ hQ => hQ A.zeros (rh_from_the_act A)⟩
/-- Every computation that reads an act reports only points on the line. -/
theorem computation_reading_the_act_lands_on_the_line (A : ActualZeros) (c : Computation) (h : c.Reads A) :
∀ z, z ∈ c.reports → onLine z :=
fun z hz => rh_from_the_act A z (h z hz)
/-- A computation that reports a point off the line reads no act. -/
theorem off_line_report_reads_no_act (c : Computation) (z : Pt) (hz : z ∈ c.reports) (h : ¬ onLine z) :
¬ ∃ A : ActualZeros, c.Reads A :=
fun ⟨A, hA⟩ => h (rh_from_the_act A z (hA z hz))
/-- The computation that reports the zero of the twin at real part 0. -/
def twinReport : Computation := ⟨[⟨0, 14⟩]⟩
/-- A computation that reads no act is not forced: the twin's report stands off the line and reads no act. -/
theorem a_computation_reading_no_act_is_not_forced :
¬ (∀ c : Computation, ∀ z, z ∈ c.reports → onLine z) ∧ ¬ ∃ A : ActualZeros, twinReport.Reads A :=
⟨fun h => absurd (h twinReport ⟨0, 14⟩ (List.Mem.head _)) (by decide : ¬ ((0 : Int) = 1)),
off_line_report_reads_no_act twinReport ⟨0, 14⟩ (List.Mem.head _) (by decide : ¬ ((0 : Int) = 1))⟩
/-- THE WITNESS FORCED BY THE ACT. On every act nothing is left open; every computation that reads the act reports
only points on the line; a computation that reports a point off the line reads no act; and the forcing reaches
exactly the computations that read an act. -/
theorem the_witness_forced_by_the_act :
(∀ A : ActualZeros, RH A.zeros ∧ LeastErasure A.zeros ∧ ¬ OffLine A.zeros ∧
(∀ z, A.zeros z ↔ recordOf A.zeros z) ∧ (∀ Q : World → Prop, (∀ Z, RH Z → Q Z) → Q A.zeros)) ∧
(∀ (A : ActualZeros) (c : Computation), c.Reads A → ∀ z, z ∈ c.reports → onLine z) ∧
(∀ (c : Computation) (z : Pt), z ∈ c.reports → ¬ onLine z → ¬ ∃ A : ActualZeros, c.Reads A) ∧
¬ (∀ c : Computation, ∀ z, z ∈ c.reports → onLine z) :=
⟨nothing_left_open_on_the_act, computation_reading_the_act_lands_on_the_line, off_line_report_reads_no_act,
a_computation_reading_no_act_is_not_forced.1⟩
/-- Section XXII.c, whole, over every self-grounding root. -/
theorem the_denials_and_the_witness {root : Prop} (G : SelfGrounding root) :
((∀ C : Prop, G.Act → C → root) ∧
(G.Act → ¬ root → False) ∧
(∀ Z : World, ¬ RH Z → ¬ ∃ G' : SelfGrounding (RH Z), Nonempty G'.Act) ∧
(∀ W : TWorld, SeededWitness W ↔ BoundT W) ∧
(root ∧ FoldClosed W2f ∧ SameRecord W1 W2f ∧ TimelessT WTwin ∧ ¬ RH W2f ∧
(¬ ∃ G' : SelfGrounding (RH W2f), Nonempty G'.Act) ∧ ¬ SeededWitness WTwin) ∧
SeededWitness WOn ∧
¬ Forces (fun _ => root) ∧
(∀ A : ActualZeros, (∃ G' : SelfGrounding (RH A.zeros), Nonempty G'.Act) ∧
SeededWitness (fun _ => A.zeros) ∧ (¬ RH A.zeros → False))) ∧
((∀ A : ActualZeros, RH A.zeros ∧ LeastErasure A.zeros ∧ ¬ OffLine A.zeros ∧
(∀ z, A.zeros z ↔ recordOf A.zeros z) ∧ (∀ Q : World → Prop, (∀ Z, RH Z → Q Z) → Q A.zeros)) ∧
(∀ (A : ActualZeros) (c : Computation), c.Reads A → ∀ z, z ∈ c.reports → onLine z) ∧
(∀ (c : Computation) (z : Pt), z ∈ c.reports → ¬ onLine z → ¬ ∃ A : ActualZeros, c.Reads A) ∧
¬ (∀ c : Computation, ∀ z, z ∈ c.reports → onLine z)) :=
⟨two_denials G, the_witness_forced_by_the_act⟩
/-! ## XXIII · Double security: the two channels of the line
The formal gate: nothing passes for the hypothesis but least erasure, and the act passes it with an empty cone. The
actuation gate: nothing passes against it but a point off the line; the root, which every act re-enacts, crosses
neither way; a registration costs nothing exactly at least erasure, one floor per erased bit. Between the gates the
bit stays keyed. Every conjunct is a theorem above; this section adds their conjunction and no content. -/
/-- DOUBLE SECURITY. The formal gate, the actuation gate, and the keyed bit between them. -/
theorem double_security :
(∀ A : ActualZeros, RH A.zeros) ∧
(∀ Z : World, LeastErasure Z ↔ RH Z) ∧
(∀ Z : World, ¬ LeastErasure Z ↔ OffLine Z) ∧
(∀ Act : Type, Act → RootAct) ∧
(¬ ∀ Z : World, RootAct → RH Z) ∧
(¬ ∀ Z : World, RootAct → ¬ RH Z) ∧
(¬ ∃ G : SelfGrounding (RH W2f), Nonempty G.Act) ∧
(∀ C : FinCfg, C.price true = 0 ↔ LeastErasure C.world) ∧
landauerFloor = 2870978885078723755499100 ∧
¬ RespectsRecord LeastErasure ∧
(∃ Z : World, FoldClosed Z ∧ ¬ LeastErasure Z) :=
⟨rh_from_the_act, least_erasure_is_the_value, rejection_is_a_witness,
fun _ a => act_reenacts_root a, root_does_not_cross_the_line, root_does_not_cross_the_denial,
line_not_self_grounding, price_zero_iff_least_erasure, landauer_floor_exact,
least_erasure_reads_past_the_record,
⟨W2, W2_closed, fun h => W2_not_rh ((least_erasure_is_the_value W2).mp h)⟩⟩
/-! ## XXIV · the root, undeniable in act, and the lock -/
/-- THE ROOT IS UNDENIABLE IN ACT: a denial of a self-grounding root is an act, and instances it. -/
theorem denial_reenacts_root {R : Prop} (G : SelfGrounding R) (denial : G.Act) : R :=
G.instances denial
/-- The root is held by the act itself. -/
theorem seated_undeniable {R : Prop} (G : SelfGrounding R) : R := G.instances G.anAct
/-- No outside proof adds anything to a self-grounding root. -/
theorem external_proof_adds_nothing {R : Prop} (G : SelfGrounding R) (Q : Prop) : (Q → R) ↔ R :=
⟨fun _ => G.instances G.anAct, fun r _ => r⟩
/-- THE UNDENIABLE ROOT HOLDS IN BOTH WORLDS: it holds by its act; the two fold-closed worlds share one
record, the hypothesis holds on the first and fails on the second; so read uniformly on the worlds the
root forces no value. -/
theorem undeniable_root_forces_no_value {R : Prop} (G : SelfGrounding R) :
R ∧ (FoldClosed W1 ∧ RH W1) ∧ (FoldClosed W2 ∧ ¬ RH W2) ∧ SameRecord W1 W2 ∧ ¬ Forces (fun _ => R) :=
⟨G.instances G.anAct, ⟨W1_closed, W1_rh⟩, ⟨W2_closed, W2_not_rh⟩, same_record_12,
keyless_forces_nothing (fun _ => R) (fun _ => G.instances G.anAct)⟩
/-- The root's form: every existent of a domain actuates, its actuation positive. -/
def Root (U : Type) (ΔE : U → Int) : Prop := ∀ x : U, 0 < ΔE x
/-- The indicator of a decided proposition: one where it holds, zero where it fails. -/
def indicator {p : Prop} : Decidable p → Int
| isTrue _ => 1
| isFalse _ => 0
/-- The indicator is positive exactly where its proposition holds. -/
theorem indicator_pos {p : Prop} (h : Decidable p) : 0 < indicator h ↔ p :=
match h with
| isTrue hp => ⟨fun _ => hp, fun _ => show (0 : Int) < 1 by decide⟩
| isFalse hn => ⟨fun h0 => absurd h0 (show ¬ (0 : Int) < 0 by decide), fun hp => absurd hp hn⟩
/-- THE CONSTRUCTED ROOT, in the words of Appendix R: one existent, whose actuation is one. A theorem
with no hypothesis and no axiom. -/
theorem constructed_root_holds : Root Unit (fun _ => 1) := fun _ => show (0 : Int) < 1 by decide
/-- THE ROOT READ AT THE ZEROS: to exist is to actuate, `Root` itself, with the existents the points of
the world and the actuation of a point one where it stands on the line and zero where it does not. -/
def RootAtZeros (Z : World) : Prop :=
Root { z : Pt // Z z } (fun z => indicator (inferInstanceAs (Decidable (onLine z.1))))
/-- THE ROOT READ AT THE ZEROS IS THE HYPOTHESIS. -/
theorem root_at_zeros_is_the_hypothesis (Z : World) : RootAtZeros Z ↔ RH Z :=
⟨fun h z hz => (indicator_pos _).mp (h ⟨z, hz⟩), fun h z => (indicator_pos _).mpr (h z.1 z.2)⟩
/-- THE ROOT READ AT THE ZEROS IS LEAST ERASURE. -/
theorem root_at_zeros_is_least_erasure (Z : World) : RootAtZeros Z ↔ LeastErasure Z :=
⟨fun h => (least_erasure_is_the_value Z).mpr ((root_at_zeros_is_the_hypothesis Z).mp h),
fun h => (root_at_zeros_is_the_hypothesis Z).mpr ((least_erasure_is_the_value Z).mp h)⟩
/-- THE ROOT READ AT THE ZEROS IS KEYED: it holds on the fold-closed world on the line and fails on its
fold-closed twin of one record. -/
theorem root_at_zeros_is_keyed :
(FoldClosed W1 ∧ RootAtZeros W1) ∧ (FoldClosed W2 ∧ ¬ RootAtZeros W2) :=
⟨⟨W1_closed, (root_at_zeros_is_the_hypothesis W1).mpr W1_rh⟩,
⟨W2_closed, fun h => W2_not_rh ((root_at_zeros_is_the_hypothesis W2).mp h)⟩⟩
/-- THE ROOT READ ON THE ROW IS KEYED: the root holds, and read uniformly on the worlds it forces
nothing; read at the zeros it is least erasure, keyed, which decides where the root alone does not. -/
theorem root_read_on_row_is_keyed {R : Prop} (G : SelfGrounding R) :
R ∧ ¬ Forces (fun _ => R) ∧ (∀ Z : World, RootAtZeros Z ↔ LeastErasure Z) ∧
((FoldClosed W1 ∧ RootAtZeros W1) ∧ (FoldClosed W2 ∧ ¬ RootAtZeros W2)) :=
⟨G.instances G.anAct, keyless_forces_nothing (fun _ => R) (fun _ => G.instances G.anAct),
root_at_zeros_is_least_erasure,
root_at_zeros_is_keyed⟩
/-- LEAST ERASURE, UNCONDITIONAL: on every world, with no hypothesis and no premise, least erasure of
the world is the hypothesis of the line on it. -/
theorem least_erasure_unconditional : ∀ Z : World, LeastErasure Z ↔ RH Z :=
least_erasure_is_the_value
/-- THE LOCK, one theorem: the constructed root holds with no hypothesis; the root holds by the act and
holds on both worlds of one record; read uniformly it forces nothing; read at the zeros it is least
erasure, keyed; least erasure is the hypothesis on every world, unconditionally; the closing theorem gives
the hypothesis on the actual zeros by one act; and no record-respecting reading decides the value on the
fold-closed worlds. -/
theorem the_lock {R : Prop} (G : SelfGrounding R) :
Root Unit (fun _ => 1) ∧
R ∧
(RH W1 ∧ FoldClosed W2 ∧ ¬ RH W2) ∧
¬ Forces (fun _ => R) ∧
(∀ Z : World, RootAtZeros Z ↔ LeastErasure Z) ∧
((FoldClosed W1 ∧ RootAtZeros W1) ∧ (FoldClosed W2 ∧ ¬ RootAtZeros W2)) ∧
(∀ Z : World, LeastErasure Z ↔ RH Z) ∧
(∀ A : ActualZeros, RH A.zeros) ∧
(∀ g : World → Prop, RespectsRecord g → ¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z)) :=
⟨constructed_root_holds, G.instances G.anAct, ⟨W1_rh, W2_closed, W2_not_rh⟩, (root_read_on_row_is_keyed G).2.1,
root_at_zeros_is_least_erasure, root_at_zeros_is_keyed, least_erasure_unconditional, rh_from_the_act,
record_decides_nothing⟩
/-! ## XXV · Admissible forcing is vacuous; the closure at every resolution; the readings of the root joined
An admissible premise that forces the line holds at no nonempty fold-closed configuration, and the constant false
premise is admissible and forces, so the class is not empty. At resolution `n` the line is `x = n`, the fold is
`x ↦ 2n − x` and registration is `(x, t) ↦ (n, t)`; the chart is resolution one and Section XXII.b is resolution two.
The closure of Section XXI holds there with least erasure as the one field, and from `n = 2` on the open strip
`0 < x < 2n` holds the pair `x = n − 1, n + 1` off the line, so the strip does not supply the bit; at resolution one
the pair at offset `k ≥ 2` lies outside the closed strip. The readings of the root are joined in one theorem, and the
lock is stated at the constructed root. On a finite configuration a search through its pairs, which terminates, finds a
point off the line exactly when least erasure fails. The posit is an act; no reading of the record returns any of the
five chart readings; the primes are a free basis; least erasure is the self-verification of the hypothesis; the
certified world is fold-closed; every route of the ledger carries the theorem its status names; and the tenth falsifier,
a point off the line, is exactly the failure of the line and is barred on the zero set the act supplies. -/
/-! ### XXV.a · Admissible forcing is vacuous -/
/-- ADMISSIBLE FORCING IS VACUOUS: an admissible premise that forces the line fails at every nonempty fold-closed
configuration. -/
theorem admissible_forcing_is_vacuous (A : World → Prop) (hA : Admissible A) (hf : Forces A) (Z : World)
(hZ : FoldClosed Z) (hne : ∃ z, Z z) : ¬ A Z :=
Or.elim hA (fun k _ => keyless_forces_nothing_free A k hf)
(fun r ha => match hne with
| ⟨z, hz⟩ =>
absurd (hf (withPair Z z.t) (withPair_closed Z hZ z.t)
((r Z (withPair Z z.t) (withPair_same_record Z z hz)).mp ha) ⟨0, z.t⟩ (Or.inr (Or.inl rfl)))
(by decide : ¬ ((0 : Int) = 1)))
/-- COALITION FORCING IS VACUOUS: a coalition of admissible atoms that forces the line fails at every nonempty
fold-closed configuration. -/
theorem coalition_forcing_is_vacuous {ι : Type} (at_ : ι → World → Prop) (h : ∀ i, Admissible (at_ i))
(c : Coalition ι) (hf : Forces (Coalition.eval at_ c)) (Z : World) (hZ : FoldClosed Z) (hne : ∃ z, Z z) :
¬ Coalition.eval at_ c Z :=
admissible_forcing_is_vacuous _ (coalition_admissible at_ h c) hf Z hZ hne
/-- AN ADMISSIBLE PREMISE FORCES: the constant false premise is admissible and forces the line, holding nowhere. -/
theorem an_admissible_premise_forces : Admissible (fun _ => False) ∧ Forces (fun _ => False) :=
⟨admissible_const False, fun _ _ h => h.elim⟩
/-! ### XXV.b · The closure at resolution n -/
/-- TWICE IS A SUM: twice an integer is the integer added to itself. -/
theorem int_two_mul (a : Int) : 2 * a = a + a := by
rw [show (2 : Int) = 1 + 1 from rfl, Int.add_mul, Int.one_mul]
/-- TWICE LESS ONCE: twice an integer less the integer is the integer. -/
theorem int_two_mul_sub (n : Int) : 2 * n - n = n :=
(congrArg (· - n) (int_two_mul n)).trans (Int.add_sub_cancel n n)
/-- The fold at resolution `n`: the line is `x = n`. -/
def foldAt (n : Int) (z : Pt) : Pt := ⟨2 * n - z.x, z.t⟩
/-- Registration at resolution `n`: it lands on the line `x = n` and keeps the height. -/
def regAt (n : Int) (z : Pt) : Pt := ⟨n, z.t⟩
/-- THE FOLD AT RESOLUTION N IS AN INVOLUTION: folding twice returns the point. -/
theorem foldAt_invol (n : Int) (z : Pt) : foldAt n (foldAt n z) = z :=
congrArg (fun y => Pt.mk y z.t) (Int.sub_sub_self (2 * n) z.x)
/-- THE SEAT AT RESOLUTION N: the fold fixes a point exactly when the point lies on the line `x = n`. -/
theorem foldAt_fixed_iff (n : Int) (z : Pt) : foldAt n z = z ↔ z.x = n :=
⟨fun h => (Int.eq_of_mul_eq_mul_left (by decide : (2 : Int) ≠ 0)
(((Int.sub_add_cancel (2 * n) z.x).symm.trans (congrArg (· + z.x) (congrArg Pt.x h))).trans
(int_two_mul z.x).symm)).symm,
fun h => congrArg (fun y => Pt.mk y z.t)
(((congrArg (fun y => 2 * n - y) h).trans (int_two_mul_sub n)).trans h.symm)⟩
/-- THE CHART AND THE STRIP ARE TWO RESOLUTIONS: the fold at resolution one is the chart's fold, and at resolution two
it is the fold of Section XXII.b. -/
theorem foldAt_specializes : (∀ z, foldAt 1 z = fold z) ∧ (∀ z, foldAt 2 z = fold₂ z) :=
⟨fun _ => rfl, fun _ => rfl⟩
/-- THE FOLD KEEPS THE OPEN STRIP: at resolution `n` a point with `0 < x < 2n` folds to a point with the same bounds. -/
theorem foldAt_strip (n : Int) (z : Pt) (h : 0 < z.x ∧ z.x < 2 * n) :
0 < (foldAt n z).x ∧ (foldAt n z).x < 2 * n :=
⟨Int.sub_pos_of_lt h.2, Int.sub_lt_self (2 * n) h.1⟩
/-- THE PAIR ABOUT THE LINE: at resolution `n` the fold exchanges the points at `x = n − 1` and `x = n + 1`. -/
theorem foldAt_pair (n : Int) (t : Nat) :
foldAt n ⟨n - 1, t⟩ = ⟨n + 1, t⟩ ∧ foldAt n ⟨n + 1, t⟩ = ⟨n - 1, t⟩ :=
have e : foldAt n ⟨n - 1, t⟩ = ⟨n + 1, t⟩ := congrArg (fun y => Pt.mk y t)
(((congrArg (· - (n - 1)) (int_two_mul n)).trans (Int.add_sub_assoc n n (n - 1))).trans
(congrArg (n + ·) (Int.sub_sub_self n 1)))
⟨e, (congrArg (foldAt n) e.symm).trans (foldAt_invol n _)⟩
/-- The fold at resolution `n`, as a carrier fold. -/
def chartAt (n : Int) : Carrier.Fold Pt := ⟨foldAt n, foldAt_invol n⟩
/-- Registration at resolution `n`, as a carrier registration: it lands on the line, fixes it, and forgets the side. -/
def regChartAt (n : Int) : Carrier.Registration (chartAt n) :=
⟨regAt n, fun z => (foldAt_fixed_iff n (regAt n z)).mpr rfl,
fun z h => congrArg (fun y => Pt.mk y z.t) ((foldAt_fixed_iff n z).mp h).symm, fun _ => rfl⟩
/-- A zero set at resolution `n` with its fold-closure, its open strip, and the one posit, least erasure. -/
structure ActualZerosAt (n : Int) where
/-- The zero set, as a world on the chart. -/
zeros : World
/-- The zero set is closed under the fold at resolution `n`. -/
closed : ∀ z, zeros z → zeros (foldAt n z)
/-- Every zero lies inside the open strip `0 < x < 2n`. -/
strip : ∀ z, zeros z → 0 < z.x ∧ z.x < 2 * n
/-- The posit: least erasure of the zero set under registration at resolution `n`. -/
supply : Carrier.LeastErasureC (regChartAt n) zeros
/-- THE CLOSURE AT RESOLUTION N: from the posit, every zero is fixed by the fold at resolution `n`. -/
theorem rh_from_the_act_at (n : Int) (A : ActualZerosAt n) : Carrier.RHc (chartAt n) A.zeros :=
(Carrier.least_erasure_is_the_value_C (regChartAt n)
(fun x => match decEq ((chartAt n).σ x) x with
| isTrue h => Or.inl h
| isFalse h => Or.inr h) A.zeros).mp A.supply
/-- THE STRIP DOES NOT SUPPLY THE BIT: from resolution two on, the pair at `x = n − 1` and `x = n + 1` at height zero
is fold-closed, lies inside the open strip, and is not fixed by the fold. -/
theorem strip_does_not_supply_at (n : Int) (hn : 2 ≤ n) :
∃ Z : World, (∀ z, Z z → Z (foldAt n z)) ∧ (∀ z, Z z → 0 < z.x ∧ z.x < 2 * n) ∧
¬ Carrier.RHc (chartAt n) Z :=
have h0 : (0 : Int) ≤ n := Int.le_trans (by decide : (0 : Int) ≤ 2) hn
have hlo : n - 1 < n := Int.sub_lt_self n (by decide : (0 : Int) < 1)
have hle : n ≤ 2 * n :=
Eq.subst (motive := fun y => n ≤ y) (int_two_mul n).symm (Int.le_add_of_nonneg_right h0)
have hs : 0 < (⟨n - 1, 0⟩ : Pt).x ∧ (⟨n - 1, 0⟩ : Pt).x < 2 * n :=
⟨Int.sub_pos_of_lt (Int.lt_of_lt_of_le (by decide : (1 : Int) < 2) hn), Int.lt_of_lt_of_le hlo hle⟩
have hs' : 0 < (⟨n + 1, 0⟩ : Pt).x ∧ (⟨n + 1, 0⟩ : Pt).x < 2 * n :=
Eq.subst (motive := fun w : Pt => 0 < w.x ∧ w.x < 2 * n) (foldAt_pair n 0).1 (foldAt_strip n _ hs)
⟨fun w => w = ⟨n - 1, 0⟩ ∨ w = ⟨n + 1, 0⟩,
fun w hw => Or.elim hw
(fun e => Or.inr ((congrArg (foldAt n) e).trans (foldAt_pair n 0).1))
(fun e => Or.inl ((congrArg (foldAt n) e).trans (foldAt_pair n 0).2)),
fun w hw => Or.elim hw
(fun e => Eq.subst (motive := fun v : Pt => 0 < v.x ∧ v.x < 2 * n) e.symm hs)
(fun e => Eq.subst (motive := fun v : Pt => 0 < v.x ∧ v.x < 2 * n) e.symm hs'),
fun h => Int.lt_irrefl n (Eq.subst (motive := fun y => y < n)
((foldAt_fixed_iff n ⟨n - 1, 0⟩).mp (h ⟨n - 1, 0⟩ (Or.inl rfl))) hlo)⟩
/-- THE PAIR OUTSIDE THE CLOSED STRIP: at resolution one an offset of at least two places the pair outside
`0 ≤ x ≤ 2`. -/
theorem pair_outside_the_closed_strip (k : Int) (hk : 2 ≤ k) : 1 - k < 0 ∧ 2 < 1 + k :=
⟨Int.sub_neg_of_lt (Int.lt_of_lt_of_le (by decide : (1 : Int) < 2) hk),
Int.lt_of_lt_of_le (by decide : (2 : Int) < 1 + 2) (Int.add_le_add_left hk 1)⟩
/-! ### XXV.c · The readings of the root, joined -/
/-- THE READINGS OF THE ROOT, JOINED: the constructed root is the proposition `0 < 1`; it has a self-grounding supply
with an act; read uniformly on the worlds it forces nothing; read at the zeros it is the hypothesis; and it does not
hold of every domain, since a domain whose actuation is zero refutes it. -/
theorem root_readings_joined :
(Root Unit (fun _ => 1) ↔ RootAct) ∧ Nonempty (SelfGrounding (Root Unit (fun _ => 1))) ∧
¬ Forces (fun _ => Root Unit (fun _ => 1)) ∧ (∀ Z : World, RootAtZeros Z ↔ RH Z) ∧
¬ ∀ (U : Type) (ΔE : U → Int), Root U ΔE :=
⟨⟨fun h => h (), fun h _ => h⟩, ⟨⟨Unit, (), fun _ => constructed_root_holds⟩⟩,
keyless_forces_nothing_free _ (fun _ => constructed_root_holds), root_at_zeros_is_the_hypothesis,
fun h => absurd (h Unit (fun _ => 0) ()) (by decide : ¬ ((0 : Int) < 0))⟩
/-- THE LOCK ON THE CONSTRUCTED ROOT: the lock, with the root taken to be the constructed root and its supply the unit
act. -/
theorem the_lock_on_the_constructed_root :
Root Unit (fun _ => 1) ∧
Root Unit (fun _ => 1) ∧
(RH W1 ∧ FoldClosed W2 ∧ ¬ RH W2) ∧
¬ Forces (fun _ => Root Unit (fun _ => 1)) ∧
(∀ Z : World, RootAtZeros Z ↔ LeastErasure Z) ∧
((FoldClosed W1 ∧ RootAtZeros W1) ∧ (FoldClosed W2 ∧ ¬ RootAtZeros W2)) ∧
(∀ Z : World, LeastErasure Z ↔ RH Z) ∧
(∀ A : ActualZeros, RH A.zeros) ∧
(∀ g : World → Prop, RespectsRecord g → ¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z)) :=
the_lock ⟨Unit, (), fun _ => constructed_root_holds⟩
/-! ### XXV.d · The rejection, computed -/
/-- The first off-line pair of a list of pairs, found by a search from the front. -/
def firstOff : List (Int × Nat) → Option (Int × Nat)
| [] => none
| p :: ps => if p.1 = 0 then firstOff ps else some p
/-- THE SEARCH IS TOTAL: it returns nothing and every pair has offset zero, or it returns a pair of the list with a
nonzero offset. -/
theorem firstOff_spec (ps : List (Int × Nat)) :
(firstOff ps = none ∧ ∀ p ∈ ps, p.1 = 0) ∨ ∃ p, firstOff ps = some p ∧ p ∈ ps ∧ p.1 ≠ 0 :=
match ps with
| [] => Or.inl ⟨rfl, fun _ h => nomatch h⟩
| p :: qs =>
if e : p.1 = 0 then
have hc : firstOff (p :: qs) = firstOff qs := if_pos e
match firstOff_spec qs with
| Or.inl ⟨hn, hz⟩ => Or.inl ⟨hc.trans hn, fun q hq => match q, hq with
| _, List.Mem.head _ => e
| _, List.Mem.tail _ hq' => hz _ hq'⟩
| Or.inr ⟨q, hq, hm, hne⟩ => Or.inr ⟨q, hc.trans hq, List.Mem.tail p hm, hne⟩
else
Or.inr ⟨p, if_neg e, List.Mem.head qs, e⟩
/-- AN OFFSET IS READ OFF ITS POINT: the point at `x = 1 − a` lies on the line only when `a = 0`. -/
theorem offset_off_line (a : Int) (t : Nat) (h : a ≠ 0) : ¬ onLine ⟨1 - a, t⟩ :=
fun e => h (((Int.sub_sub_self 1 a).symm.trans (congrArg (fun y => 1 - y) e)).trans (by decide))
/-- THE REJECTION, COMPUTED: if least erasure fails on a finite configuration, the search returns a pair `(k, t)` of
the configuration with `k ≠ 0` whose point `(1 − k, t)` lies in the world and off the line. -/
theorem rejection_is_computed (C : FinCfg) (h : ¬ LeastErasure C.world) :
∃ p, firstOff C.pairs = some p ∧ p ∈ C.pairs ∧ p.1 ≠ 0 ∧ C.world ⟨1 - p.1, p.2⟩ ∧
¬ onLine ⟨1 - p.1, p.2⟩ :=
match firstOff_spec C.pairs with
| Or.inl ⟨_, hz⟩ => absurd ((least_erasure_is_the_value C.world).mpr (fun _ hz' =>
Or.elim hz' (fun hx => hx.1) (fun ⟨p, hp, hk, _⟩ => absurd (hz p hp) hk))) h
| Or.inr ⟨p, hf, hm, hk⟩ => ⟨p, hf, hm, hk, Or.inr ⟨p, hm, hk, Or.inl rfl⟩, offset_off_line p.1 p.2 hk⟩
/-- THE SEARCH DECIDES LEAST ERASURE: a finite configuration has least erasure exactly when the search returns
nothing. -/
theorem least_erasure_iff_search_empty (C : FinCfg) : LeastErasure C.world ↔ firstOff C.pairs = none :=
⟨fun hle => match firstOff_spec C.pairs with
| Or.inl ⟨hn, _⟩ => hn
| Or.inr ⟨p, _, hm, hk⟩ =>
absurd ((least_erasure_is_the_value C.world).mp hle _ (Or.inr ⟨p, hm, hk, Or.inl rfl⟩))
(offset_off_line p.1 p.2 hk),
fun hn => match firstOff_spec C.pairs with
| Or.inl ⟨_, hz⟩ => (least_erasure_is_the_value C.world).mpr (fun _ hz' =>
Or.elim hz' (fun hx => hx.1) (fun ⟨p, hp, hk, _⟩ => absurd (hz p hp) hk))
| Or.inr ⟨_, hs, _, _⟩ => Option.noConfusion (hn.symm.trans hs)⟩
/-! ### XXV.e · The posit, the readings, the basis, the recursion, the certified world, the ledger -/
/-- THE POSIT IS AN ACT: at the actual zeros the posit has a self-grounding supply with an act. -/
theorem the_posit_is_a_deed (A : ActualZeros) : ∃ G : SelfGrounding (LeastErasure A.zeros), Nonempty G.Act :=
⟨⟨Unit, (), fun _ => A.supply⟩, ⟨()⟩⟩
/-- A READING KEYED ON THE TWINS IS NOT RETURNED: a reading true on W1 and false on W2f agrees with no reading of the
record on every fold-closed world. -/
theorem keyed_reading_not_returned (P : World → Prop) (h1 : P W1) (h2 : ¬ P W2f) (g : World → Prop)
(hg : RespectsRecord g) : ¬ ∀ Z, FoldClosed Z → (g Z ↔ P Z) :=
fun h => h2 ((h W2f W2f_closed).mp ((hg W1 W2f same_record_f).mp ((h W1 W1_closed).mpr h1)))
/-- NO READING OF THE RECORD RETURNS ANY READING: lossless registration, displacement zero, no left zero, stability
and least erasure each hold on W1 and fail on W2f, so no reading of the record agrees with any of them. -/
theorem no_record_reading_returns_any_reading (g : World → Prop) (hg : RespectsRecord g) :
¬ (∀ Z, FoldClosed Z → (g Z ↔ Lossless Z)) ∧ ¬ (∀ Z, FoldClosed Z → (g Z ↔ DepthZero Z)) ∧
¬ (∀ Z, FoldClosed Z → (g Z ↔ ¬ Left Z)) ∧ ¬ (∀ Z, FoldClosed Z → (g Z ↔ Stable Z)) ∧
¬ (∀ Z, FoldClosed Z → (g Z ↔ LeastErasure Z)) :=
⟨keyed_reading_not_returned Lossless
(fun z hz => Eq.subst (motive := fun w => reg w = w) (Eq.symm hz) rfl)
(fun h => absurd (congrArg Pt.x (h ⟨0, 14⟩ (Or.inl rfl))) (by decide : ¬ ((1 : Int) = 0))) g hg,
keyed_reading_not_returned DepthZero
(fun z hz => Eq.subst (motive := fun w => oddPart w = 0) (Eq.symm hz) rfl)
(fun h => absurd (h ⟨0, 14⟩ (Or.inl rfl)) (by decide : ¬ (oddPart ⟨0, 14⟩ = 0))) g hg,
keyed_reading_not_returned (fun Z => ¬ Left Z)
(fun ⟨z, hz, hx⟩ => Eq.subst (motive := fun w : Pt => ¬ w.x < 1) (Eq.symm hz)
(by decide : ¬ ((⟨1, 14⟩ : Pt).x < 1)) hx)
(fun h => h ⟨⟨0, 14⟩, Or.inl rfl, by decide⟩) g hg,
keyed_reading_not_returned Stable
(fun z hz => Eq.subst (motive := fun w => N1 w ≤ N0 w) (Eq.symm hz) (by decide))
(fun h => absurd (h ⟨0, 14⟩ (Or.inl rfl)) (by decide : ¬ (N1 ⟨0, 14⟩ ≤ N0 ⟨0, 14⟩))) g hg,
keyed_reading_not_returned LeastErasure ((least_erasure_is_the_value W1).mpr W1_rh)
(fun h => W2f_not_rh ((least_erasure_is_the_value W2f).mp h)) g hg⟩
/-- THE PRIMES ARE A FREE BASIS: every assignment of integers to the primes extends to exactly one completely
additive function. -/
theorem primes_are_a_free_basis (a : Nat → Int) :
∃ f, CompletelyAdditive f ∧ (∀ p, isPrime p → f p = a p) ∧
∀ g, CompletelyAdditive g → (∀ p, isPrime p → g p = a p) → ∀ n, 0 < n → g n = f n :=
⟨extendAssignment a, primes_admit_every_assignment a⟩
/-- LEAST ERASURE IS THE RECURSION: on every world least erasure holds exactly when the hypothesis is implied by its
own denial; the line is decided point by point, so no classical step enters. -/
theorem least_erasure_iff_recursion (Z : World) : LeastErasure Z ↔ SelfVerifyingP (RH Z) :=
⟨fun h _ => (least_erasure_is_the_value Z).mp h,
fun h => (least_erasure_is_the_value Z).mpr (fun z hz =>
match Int.decEq z.x 1 with
| isTrue e => e
| isFalse ne => h (fun r => ne (r z hz)) z hz)⟩
/-- THE CERTIFIED WORLD IS FOLD-CLOSED: the world certified to height `T` is closed under the fold, and a fold-closed
world agrees with it to `T` and carries an off-line pair above. -/
theorem certified_height_never_forces_closed (T : Nat) :
FoldClosed (LineBelow T) ∧
(RH (LineBelow T) ∧ FoldClosed (TwinAbove T) ∧ ¬ RH (TwinAbove T) ∧
∀ z, z.t ≤ T → (TwinAbove T z ↔ LineBelow T z)) :=
⟨fun z hz => ⟨(congrArg (fun y => 2 - y) hz.1).trans (by decide), hz.2⟩,
fun _ hz => hz.1,
fun z hz => match hz with
| Or.inl hl => Or.inl ⟨(congrArg (fun y => 2 - y) hl.1).trans (by decide), hl.2⟩
| Or.inr (Or.inl e) => Or.inr (Or.inr ((congrArg fold e).trans rfl))
| Or.inr (Or.inr e) => Or.inr (Or.inl ((congrArg fold e).trans rfl)),
fun h => absurd (h ⟨0, T + 1⟩ (Or.inr (Or.inl rfl))) (by decide : ¬ ((0 : Int) = 1)),
fun z hz => ⟨fun h => match h with
| Or.inl hl => hl
| Or.inr (Or.inl e) =>
absurd (Eq.subst (motive := fun w : Pt => w.t ≤ T) e hz) (Nat.not_succ_le_self T)
| Or.inr (Or.inr e) =>
absurd (Eq.subst (motive := fun w : Pt => w.t ≤ T) e hz) (Nat.not_succ_le_self T),
fun h => Or.inl h⟩⟩
/-- The statement each route of the ledger carries: the theorem its status names. -/
def routeClaim : Route → Prop
| .ladderFromRecord => ∀ g : World → Prop, RespectsRecord g → ¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z)
| .foundationAsSystem => Sound lineTheory ∧ lineTheory.Prov () ∧ LeastErasure (lineTheoryReads.world ())
| .placement => ∀ T : Theory, RungOnLadder T → Sound T →
(∀ s, T.Comp s → T.Prov s) ∧ (∀ s, T.Prov s → T.True_ s) ∧ (∀ s, T.Comp s → T.True_ s)
| .groundByAct => ∀ A : ActualZeros, RH A.zeros
| .independence => ∀ S : Setting, ¬ S.Prov S.hyp → ¬ S.Prov (¬ S.hyp) → S.hyp
| .realPartCertified => ∀ T : Nat, RH (LineBelow T) ∧ FoldClosed (TwinAbove T) ∧ ¬ RH (TwinAbove T) ∧
∀ z, z.t ≤ T → (TwinAbove T z ↔ LineBelow T z)
/-- EVERY ROUTE CARRIES ITS THEOREM: each of the six routes is backed by the theorem its ledger entry names. -/
theorem every_route_carries_its_theorem : ∀ r : Route, routeClaim r := fun r =>
match r with
| .ladderFromRecord => unicorn_block
| .foundationAsSystem => a_sound_theory_may_prove_the_line
| .placement => placement
| .groundByAct => rh_from_the_act
| .independence => independence_forces_truth
| .realPartCertified => certified_height_never_forces
/-! ### XXV.f · The tenth falsifier, barred by the act -/
/-- THE TENTH IS THE REFUTER: on every configuration a computed point off the line is exactly the failure of the line. -/
theorem the_tenth_is_the_refuter (Z : World) : OffLine Z ↔ ¬ RH Z :=
⟨fun ⟨z, hz, hn⟩ h => hn (h z hz), not_rh_has_offline_witness Z⟩
/-- THE TENTH IS BARRED BY THE ACT: on the zero set the act supplies, no point lies off the line; the one refuter of the
value does not exist there. -/
theorem the_tenth_is_barred_by_the_act (A : ActualZeros) : ¬ OffLine A.zeros :=
fun ⟨z, hz, hn⟩ => hn (rh_from_the_act A z hz)
/-- THE KINETIC BAR: a reading supplied on the actual zero set gives the line there, and with it the refuter's absence;
the formal side leaves the search open, and the field the act supplies closes it. -/
theorem the_kinetic_bar (A : ActualZeros) : RH A.zeros ∧ ¬ OffLine A.zeros :=
⟨rh_from_the_act A, the_tenth_is_barred_by_the_act A⟩
/-! ## XXVI · The closure, bound whole
One theorem binds the closure, for every self-grounding root: the two-part reading of section XIX.f, the lock of
section XXIV, the socket of section XXII, the irreducible cut of section XIX.c, the two denials and the witness of
section XXII.c, and the bar of section XXV.f. Every conjunct is a theorem above; this section adds their conjunction
and no content. -/
/-- THE CLOSURE, BOUND IN ONE THEOREM. For every self-grounding root: from the posit the hypothesis follows, no reading
of the record supplies it, the posit is the hypothesis, and nothing weaker forces the line; the lock; the field of the
act can be filled at a fold-closed configuration exactly where the hypothesis holds; no admissible premise decides and
least erasure is not admissible; the two denials; the witness forced by the act; and on the zero set the act supplies
the hypothesis holds and no point lies off the line. -/
theorem the_capstone {root : Prop} (G : SelfGrounding root) :
((∀ A : ActualZeros, RH A.zeros) ∧
(∀ g : World → Prop, RespectsRecord g → ¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z)) ∧
(∀ Z : World, LeastErasure Z ↔ RH Z) ∧
(Forces RH ∧ ∀ A : World → Prop, Forces A → ∀ Z, FoldClosed Z → A Z → RH Z)) ∧
(Root Unit (fun _ => 1) ∧
root ∧
(RH W1 ∧ FoldClosed W2 ∧ ¬ RH W2) ∧
¬ Forces (fun _ => root) ∧
(∀ Z : World, RootAtZeros Z ↔ LeastErasure Z) ∧
((FoldClosed W1 ∧ RootAtZeros W1) ∧ (FoldClosed W2 ∧ ¬ RootAtZeros W2)) ∧
(∀ Z : World, LeastErasure Z ↔ RH Z) ∧
(∀ A : ActualZeros, RH A.zeros) ∧
(∀ g : World → Prop, RespectsRecord g → ¬ ∀ Z, FoldClosed Z → (g Z ↔ RH Z))) ∧
(∀ Z : World, FoldClosed Z → ((∃ S : ActualZeros, S.zeros = Z) ↔ RH Z)) ∧
((∀ A : World → Prop, Admissible A → ¬ ∀ Z, FoldClosed Z → (A Z ↔ RH Z)) ∧ ¬ Admissible LeastErasure) ∧
((∀ C : Prop, G.Act → C → root) ∧
(G.Act → ¬ root → False) ∧
(∀ Z : World, ¬ RH Z → ¬ ∃ G' : SelfGrounding (RH Z), Nonempty G'.Act) ∧
(∀ W : TWorld, SeededWitness W ↔ BoundT W) ∧
(root ∧ FoldClosed W2f ∧ SameRecord W1 W2f ∧ TimelessT WTwin ∧ ¬ RH W2f ∧
(¬ ∃ G' : SelfGrounding (RH W2f), Nonempty G'.Act) ∧ ¬ SeededWitness WTwin) ∧
SeededWitness WOn ∧
¬ Forces (fun _ => root) ∧
(∀ A : ActualZeros, (∃ G' : SelfGrounding (RH A.zeros), Nonempty G'.Act) ∧
SeededWitness (fun _ => A.zeros) ∧ (¬ RH A.zeros → False))) ∧
((∀ A : ActualZeros, RH A.zeros ∧ LeastErasure A.zeros ∧ ¬ OffLine A.zeros ∧
(∀ z, A.zeros z ↔ recordOf A.zeros z) ∧ (∀ Q : World → Prop, (∀ Z, RH Z → Q Z) → Q A.zeros)) ∧
(∀ (A : ActualZeros) (c : Computation), c.Reads A → ∀ z, z ∈ c.reports → onLine z) ∧
(∀ (c : Computation) (z : Pt), z ∈ c.reports → ¬ onLine z → ¬ ∃ A : ActualZeros, c.Reads A) ∧
¬ (∀ c : Computation, ∀ z, z ∈ c.reports → onLine z)) ∧
(∀ A : ActualZeros, RH A.zeros ∧ ¬ OffLine A.zeros) :=
⟨reader_frame, the_lock G, fun Z hZ => (socket_is_the_value Z hZ).1,
⟨triaxial_cut_irreducible.2.2.2.1, triaxial_cut_irreducible.2.2.2.2.2.2.1⟩,
two_denials G, the_witness_forced_by_the_act, the_kinetic_bar⟩
end PrimeFreedom
/-! ## Cones, printed: sections I to XVI -/
#print axioms PrimeFreedom.arrow_exists
#print axioms PrimeFreedom.aperture_one_bit_wide
#print axioms PrimeFreedom.prime_fibre
#print axioms PrimeFreedom.prime_off_seat
#print axioms PrimeFreedom.freedom_is_exactly_two
#print axioms PrimeFreedom.seat_is_zero
#print axioms PrimeFreedom.exists_prime_dvd
#print axioms PrimeFreedom.leastDivisor_prime
#print axioms PrimeFreedom.determined_by_primes
#print axioms PrimeFreedom.fold_preserves_offline
#print axioms PrimeFreedom.offline_zero_quadruple
#print axioms PrimeFreedom.not_rh_has_offline_witness
#print axioms PrimeFreedom.denial_posits_the_orbit
#print axioms PrimeFreedom.record_blind_at_every_scale
#print axioms PrimeFreedom.euclid_lemma
#print axioms PrimeFreedom.pExp_mul
#print axioms PrimeFreedom.padicMeasure_additive
#print axioms PrimeFreedom.prime_freedom_independent
#print axioms PrimeFreedom.primes_base_of_freedom
#print axioms PrimeFreedom.arrow_multiplicative
#print axioms PrimeFreedom.arrow_at_prime
#print axioms PrimeFreedom.finite_never_forces
#print axioms PrimeFreedom.limit_not_forced
#print axioms PrimeFreedom.nothing_escapes_one_cut
#print axioms PrimeFreedom.sides_together
#print axioms PrimeFreedom.rh_iff_no_left
#print axioms PrimeFreedom.record_decides_nothing
#print axioms PrimeFreedom.unicorn_block
#print axioms PrimeFreedom.keyless_forces_nothing
#print axioms PrimeFreedom.least_erasure_is_the_value
#print axioms PrimeFreedom.supply_iff
#print axioms PrimeFreedom.faces_are_one
#print axioms PrimeFreedom.rh_from_the_act_generic
#print axioms PrimeFreedom.rh_from_the_act
#print axioms PrimeFreedom.rh_ground_closure_complete
#print axioms PrimeFreedom.primes_exist
#print axioms PrimeFreedom.primes_exist_forces_nothing
#print axioms PrimeFreedom.prime_freedom_forces_nothing
#print axioms PrimeFreedom.arrow_forces_nothing
#print axioms PrimeFreedom.free_basis_coexists_with_offline_world
#print axioms PrimeFreedom.fold_off_line_stays_off
#print axioms PrimeFreedom.positivity_on_zero_side
#print axioms PrimeFreedom.least_erasure_is_positivity
#print axioms PrimeFreedom.prime_witness_iff
#print axioms PrimeFreedom.rh_from_prime_witness
#print axioms PrimeFreedom.positivity_is_keyed
#print axioms PrimeFreedom.freedom_does_not_pick_the_sign
#print axioms PrimeFreedom.prime_witness_ledger
#print axioms PrimeFreedom.posit_is_the_conclusion
#print axioms PrimeFreedom.rh_from_prime_act
#print axioms PrimeFreedom.acts_are_one
#print axioms PrimeFreedom.record_decides_nothing_free
#print axioms PrimeFreedom.unicorn_block_free
#print axioms PrimeFreedom.keyless_forces_nothing_free
#print axioms PrimeFreedom.arrow_forces_nothing_free
#print axioms PrimeFreedom.least_erasure_reads_past_the_record_free
#print axioms PrimeFreedom.positivity_is_keyed_free
/-! ## Cones, pinned: sections VII to XIII (a compile in which any pinned cone changes fails) -/
/-- info: 'PrimeFreedom.least_erasure_is_the_value' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.least_erasure_is_the_value
/-- info: 'PrimeFreedom.least_erasure_is_positivity' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.least_erasure_is_positivity
/-- info: 'PrimeFreedom.spend_is_the_line' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.spend_is_the_line
/-- info: 'PrimeFreedom.record_decides_nothing_free' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.record_decides_nothing_free
/-- info: 'PrimeFreedom.keyless_forces_nothing_free' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.keyless_forces_nothing_free
/-- info: 'PrimeFreedom.rh_from_the_act' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.rh_from_the_act
/-- info: 'PrimeFreedom.rh_from_prime_act' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.rh_from_prime_act
/-- info: 'PrimeFreedom.acts_are_one' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.acts_are_one
/-- info: 'PrimeFreedom.primes_base_of_freedom' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.primes_base_of_freedom
/-- info: 'PrimeFreedom.spend_is_not_the_free_basis' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.spend_is_not_the_free_basis
/-- info: 'PrimeFreedom.rh_on_the_spent_bit' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.rh_on_the_spent_bit
/-- info: 'PrimeFreedom.prime_arc_sealed' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.prime_arc_sealed
/-- info: 'PrimeFreedom.rh_is_the_weakest_forcing_premise' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.rh_is_the_weakest_forcing_premise
/-- info: 'PrimeFreedom.li_prefix_never_forces' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.li_prefix_never_forces
/-- info: 'PrimeFreedom.rh_from_the_sign' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.rh_from_the_sign
/-- info: 'PrimeFreedom.rh_iff_the_sign' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.rh_iff_the_sign
/-- info: 'PrimeFreedom.spends_are_one' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.spends_are_one
/-- info: 'PrimeFreedom.line_not_self_grounding' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.line_not_self_grounding
/-- info: 'PrimeFreedom.sign_realized_both_ways' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.sign_realized_both_ways
/-- info: 'PrimeFreedom.the_vestigial_posit' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.the_vestigial_posit
/-- info: 'PrimeFreedom.exactly_one_face_is_keyed' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.exactly_one_face_is_keyed
/-- info: 'PrimeFreedom.arrow_is_not_the_line' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.arrow_is_not_the_line
/-- info: 'PrimeFreedom.template_binds_iff_seed' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.template_binds_iff_seed
/-- info: 'PrimeFreedom.the_seed_is_the_spend' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.the_seed_is_the_spend
/-- info: 'PrimeFreedom.the_template_plugged_in' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_template_plugged_in
/-! ## Cones, pinned: section XVI -/
/-- info: 'PrimeFreedom.fold_negates_odd' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.fold_negates_odd
/-- info: 'PrimeFreedom.rh_iff_even_eigenspace' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.rh_iff_even_eigenspace
/-- info: 'PrimeFreedom.record_blind_to_odd' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.record_blind_to_odd
/-- info: 'PrimeFreedom.side_odd_off_line' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.side_odd_off_line
/-- info: 'PrimeFreedom.record_never_reads_the_side' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.record_never_reads_the_side
/-- info: 'PrimeFreedom.colocation_is_a_calibration' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.colocation_is_a_calibration
/-- info: 'PrimeFreedom.calibration_realized_both_ways' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.calibration_realized_both_ways
/-- info: 'PrimeFreedom.recursion_fails_on_the_twin' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.recursion_fails_on_the_twin
/-- info: 'PrimeFreedom.least_erasure_is_the_recursion' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.least_erasure_is_the_recursion
/-- info: 'PrimeFreedom.the_mirror_at_minus_one' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.the_mirror_at_minus_one
/-! ## Cones, printed: section XVII -/
#print axioms PrimeFreedom.admissible_transfers
#print axioms PrimeFreedom.no_admissible_triad_forces
#print axioms PrimeFreedom.no_admissible_coalition_forces
#print axioms PrimeFreedom.spend_is_not_admissible
#print axioms PrimeFreedom.three_axis_lock
#print axioms PrimeFreedom.freedom_alone_open
#print axioms PrimeFreedom.certified_height_never_forces
#print axioms PrimeFreedom.certified_worlds_share_the_record_below
#print axioms PrimeFreedom.HeatFlow.disc_flow
#print axioms PrimeFreedom.HeatFlow.forward_preserves
#print axioms PrimeFreedom.HeatFlow.erasure_finite
#print axioms PrimeFreedom.HeatFlow.lam_nonneg
#print axioms PrimeFreedom.HeatFlow.real_at_lam
#print axioms PrimeFreedom.HeatFlow.lam_least
#print axioms PrimeFreedom.HeatFlow.lam_zero_iff_real
#print axioms PrimeFreedom.HeatFlow.de_bruijn_tight
#print axioms PrimeFreedom.HeatFlow.collision
#print axioms PrimeFreedom.HeatFlow.disc3_step
#print axioms PrimeFreedom.HeatFlow.disc3_strict
#print axioms PrimeFreedom.HeatFlow.disc3_monotone
#print axioms PrimeFreedom.HeatFlow.cubic_forward_preserves
#print axioms PrimeFreedom.HeatFlow.flow_injective
#print axioms PrimeFreedom.HeatFlow.certificate_two_worlds
#print axioms PrimeFreedom.HeatFlow.certificate_decides_nothing
#print axioms PrimeFreedom.HeatFlow.certification_never_forces
#print axioms PrimeFreedom.HeatFlow.zero_slack
#print axioms PrimeFreedom.HeatFlow.backward_not_forced
#print axioms PrimeFreedom.HeatFlow.family_least_erasure
#print axioms PrimeFreedom.heat_bit_is_one_inequality
#print axioms PrimeFreedom.family_bit_is_one_inequality
#print axioms PrimeFreedom.heat_model_reads_as_the_carrier
#print axioms PrimeFreedom.Liouville.lam_mult
#print axioms PrimeFreedom.Liouville.lam_flips_at_primes
#print axioms PrimeFreedom.Liouville.polya_holds_to_200
#print axioms PrimeFreedom.liouville_is_the_sign_arrow
#print axioms PrimeFreedom.rh_from_faithful
#print axioms PrimeFreedom.faithful_is_the_bit
#print axioms PrimeFreedom.the_posit_in_every_coordinate
#print axioms PrimeFreedom.modes
#print axioms PrimeFreedom.lossless_iff_rh
#print axioms PrimeFreedom.stable_iff_rh
#print axioms PrimeFreedom.five_readings_agree
#print axioms PrimeFreedom.no_record_reading_returns_any_face
#print axioms PrimeFreedom.same_for_every_reader
#print axioms PrimeFreedom.no_private_bit
#print axioms PrimeFreedom.spend_has_no_reader
#print axioms PrimeFreedom.the_harvest
/-! ## Cones, pinned: section XVII -/
/-- info: 'PrimeFreedom.no_admissible_coalition_forces' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.no_admissible_coalition_forces
/-- info: 'PrimeFreedom.spend_is_not_admissible' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.spend_is_not_admissible
/-- info: 'PrimeFreedom.certified_height_never_forces' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.certified_height_never_forces
/-- info: 'PrimeFreedom.HeatFlow.lam_nonneg' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.HeatFlow.lam_nonneg
/-- info: 'PrimeFreedom.HeatFlow.lam_zero_iff_real' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.HeatFlow.lam_zero_iff_real
/-- info: 'PrimeFreedom.HeatFlow.certificate_decides_nothing' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.HeatFlow.certificate_decides_nothing
/-- info: 'PrimeFreedom.HeatFlow.zero_slack' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.HeatFlow.zero_slack
/-- info: 'PrimeFreedom.heat_bit_is_one_inequality' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.heat_bit_is_one_inequality
/-- info: 'PrimeFreedom.liouville_is_the_sign_arrow' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.liouville_is_the_sign_arrow
/-- info: 'PrimeFreedom.Liouville.polya_holds_to_200' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.Liouville.polya_holds_to_200
/-- info: 'PrimeFreedom.the_posit_in_every_coordinate' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.the_posit_in_every_coordinate
/-- info: 'PrimeFreedom.five_readings_agree' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.five_readings_agree
/-- info: 'PrimeFreedom.spend_has_no_reader' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.spend_has_no_reader
/-- info: 'PrimeFreedom.the_harvest' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_harvest
/-! ## Cones, printed: section XVIII -/
#print axioms PrimeFreedom.placement
#print axioms PrimeFreedom.soundness_is_load_bearing
#print axioms PrimeFreedom.ground_exceeds_ladder
#print axioms PrimeFreedom.independent_axioms_are_separate_bits
#print axioms PrimeFreedom.root_is_keyless
#print axioms PrimeFreedom.keyless_crosses
#print axioms PrimeFreedom.root_decides_no_keyed
#print axioms PrimeFreedom.choice_is_keyed
#print axioms PrimeFreedom.root_does_not_cross_choice
#print axioms PrimeFreedom.line_is_keyed_over_worlds
#print axioms PrimeFreedom.root_does_not_cross_the_line
#print axioms PrimeFreedom.refutation_is_one_point
#print axioms PrimeFreedom.cant_refute_seals
#print axioms PrimeFreedom.cant_refute_seals_dec
#print axioms PrimeFreedom.rh_iff_cant_refute
#print axioms PrimeFreedom.independence_forces_truth
#print axioms PrimeFreedom.cant_prove_does_not_seal_false
#print axioms PrimeFreedom.cant_asymmetry
#print axioms PrimeFreedom.round_trip_identity
#print axioms PrimeFreedom.absolute_returns_unchanged
#print axioms PrimeFreedom.trip_adds_presence_only
#print axioms PrimeFreedom.massless_arrow
#print axioms PrimeFreedom.any_true_premise_serves
#print axioms PrimeFreedom.the_line_round_trips
#print axioms PrimeFreedom.ladder_blocked
#print axioms PrimeFreedom.the_road
/-! ## Cones, pinned: section XVIII -/
/-- info: 'PrimeFreedom.placement' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.placement
/-- info: 'PrimeFreedom.soundness_is_load_bearing' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.soundness_is_load_bearing
/-- info: 'PrimeFreedom.ground_exceeds_ladder' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.ground_exceeds_ladder
/-- info: 'PrimeFreedom.root_decides_no_keyed' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.root_decides_no_keyed
/-- info: 'PrimeFreedom.root_does_not_cross_the_line' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.root_does_not_cross_the_line
/-- info: 'PrimeFreedom.cant_refute_seals' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.cant_refute_seals
/-- info: 'PrimeFreedom.rh_iff_cant_refute' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.rh_iff_cant_refute
/-- info: 'PrimeFreedom.independence_forces_truth' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.independence_forces_truth
/-- info: 'PrimeFreedom.cant_prove_does_not_seal_false' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.cant_prove_does_not_seal_false
/-- info: 'PrimeFreedom.round_trip_identity' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.round_trip_identity
/-- info: 'PrimeFreedom.massless_arrow' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.massless_arrow
/-- info: 'PrimeFreedom.ladder_blocked' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.ladder_blocked
/-- info: 'PrimeFreedom.the_road' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_road
/-! ## Cones, printed: section XIX -/
#print axioms PrimeFreedom.vocabulary_law
#print axioms PrimeFreedom.every_face_proves_every_face
#print axioms PrimeFreedom.chart_faces_prove_each_other
#print axioms PrimeFreedom.fold_fold
#print axioms PrimeFreedom.fold_law_admissible
#print axioms PrimeFreedom.same_record_eq
#print axioms PrimeFreedom.record_reading_admissible
#print axioms PrimeFreedom.admissible_const
#print axioms PrimeFreedom.keyless_denial_respects
#print axioms PrimeFreedom.admissible_not
#print axioms PrimeFreedom.admissible_and
#print axioms PrimeFreedom.admissible_or
#print axioms PrimeFreedom.admissible_never_decides
#print axioms PrimeFreedom.coalition_admissible
#print axioms PrimeFreedom.no_coalition_decides
#print axioms PrimeFreedom.triaxial_cut_irreducible
#print axioms PrimeFreedom.ladder_proof_lands_on_least_erasure
#print axioms PrimeFreedom.ladder_proof_iff_least_erasure
#print axioms PrimeFreedom.lineTheory_sound
#print axioms PrimeFreedom.a_sound_theory_may_prove_the_line
#print axioms PrimeFreedom.route_ledger_is_computed
#print axioms PrimeFreedom.route_ledger_counts
#print axioms PrimeFreedom.route_status_total
#print axioms PrimeFreedom.blocked_iff_theorem
#print axioms PrimeFreedom.reader_frame
#print axioms PrimeFreedom.the_front
/-! ## Cones, pinned: section XIX -/
/-- info: 'PrimeFreedom.vocabulary_law' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.vocabulary_law
/-- info: 'PrimeFreedom.every_face_proves_every_face' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.every_face_proves_every_face
/-- info: 'PrimeFreedom.chart_faces_prove_each_other' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.chart_faces_prove_each_other
/-- info: 'PrimeFreedom.record_reading_admissible' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.record_reading_admissible
/-- info: 'PrimeFreedom.admissible_not' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.admissible_not
/-- info: 'PrimeFreedom.admissible_and' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.admissible_and
/-- info: 'PrimeFreedom.admissible_or' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.admissible_or
/-- info: 'PrimeFreedom.admissible_never_decides' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.admissible_never_decides
/-- info: 'PrimeFreedom.coalition_admissible' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.coalition_admissible
/-- info: 'PrimeFreedom.no_coalition_decides' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.no_coalition_decides
/-- info: 'PrimeFreedom.triaxial_cut_irreducible' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.triaxial_cut_irreducible
/-- info: 'PrimeFreedom.ladder_proof_lands_on_least_erasure' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.ladder_proof_lands_on_least_erasure
/-- info: 'PrimeFreedom.ladder_proof_iff_least_erasure' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.ladder_proof_iff_least_erasure
/-- info: 'PrimeFreedom.a_sound_theory_may_prove_the_line' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.a_sound_theory_may_prove_the_line
/-- info: 'PrimeFreedom.route_ledger_is_computed' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.route_ledger_is_computed
/-- info: 'PrimeFreedom.blocked_iff_theorem' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.blocked_iff_theorem
/-- info: 'PrimeFreedom.reader_frame' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.reader_frame
/-- info: 'PrimeFreedom.the_front' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.the_front
/-! ## Cones, pinned: section XX -/
/-- info: 'PrimeFreedom.reg_on_line' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.reg_on_line
/-- info: 'PrimeFreedom.record_rh' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.record_rh
/-- info: 'PrimeFreedom.record_has_least_erasure' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.record_has_least_erasure
/-- info: 'PrimeFreedom.record_closed' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.record_closed
/-- info: 'PrimeFreedom.record_carried_by_least_erasure' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.record_carried_by_least_erasure
/-- info: 'PrimeFreedom.admissible_holds_on_the_lossless_world' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.admissible_holds_on_the_lossless_world
/-- info: 'PrimeFreedom.every_reading_holds_on_the_lossless_world' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.every_reading_holds_on_the_lossless_world
/-- info: 'PrimeFreedom.every_coalition_holds_on_the_lossless_world' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.every_coalition_holds_on_the_lossless_world
/-- info: 'PrimeFreedom.record_never_testifies_against' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.record_never_testifies_against
/-- info: 'PrimeFreedom.pair_two_points_one_record' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.pair_two_points_one_record
/-- info: 'PrimeFreedom.offCount_zero_iff' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.offCount_zero_iff
/-- info: 'PrimeFreedom.fincfg_closed' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.fincfg_closed
/-- info: 'PrimeFreedom.least_erasure_iff_zero_erased' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.least_erasure_iff_zero_erased
/-- info: 'PrimeFreedom.landauer_floor_exact' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.landauer_floor_exact
/-- info: 'PrimeFreedom.price_zero_iff_least_erasure' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.price_zero_iff_least_erasure
/-- info: 'PrimeFreedom.denial_price_linear' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.denial_price_linear
/-- info: 'PrimeFreedom.reversible_commits_nothing' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.reversible_commits_nothing
/-- info: 'PrimeFreedom.least_erasure_iff_no_point_off' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.least_erasure_iff_no_point_off
/-- info: 'PrimeFreedom.rejection_is_a_witness' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.rejection_is_a_witness
/-- info: 'PrimeFreedom.falsifier_form_constant' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.falsifier_form_constant
/-- info: 'PrimeFreedom.act_reenacts_root' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.act_reenacts_root
/-- info: 'PrimeFreedom.root_does_not_cross_the_denial' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.root_does_not_cross_the_denial
/-- info: 'PrimeFreedom.assent_is_the_value' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.assent_is_the_value
/-- info: 'PrimeFreedom.one_shape_two_registers' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.one_shape_two_registers
/-- info: 'PrimeFreedom.freedom_is_given_the_sign_is_spent' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.freedom_is_given_the_sign_is_spent
/-- info: 'PrimeFreedom.least_erasure_affirmed' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.least_erasure_affirmed
/-! ## Cones, printed: every theorem of sections I to XX whose cone is not printed above -/
#print axioms PrimeFreedom.orientation_two_valued
#print axioms PrimeFreedom.orientations_distinct
#print axioms PrimeFreedom.seat_is_one
#print axioms PrimeFreedom.findLeastFrom_correct
#print axioms PrimeFreedom.leastDivisor_spec
#print axioms PrimeFreedom.dvd_remainder_mul
#print axioms PrimeFreedom.leastMulDvd_spec
#print axioms PrimeFreedom.findGt_spec
#print axioms PrimeFreedom.findGt_max
#print axioms PrimeFreedom.pExp_dvd
#print axioms PrimeFreedom.two_pow_ge
#print axioms PrimeFreedom.pow_dvd_bound
#print axioms PrimeFreedom.pExp_le_of_dvd
#print axioms PrimeFreedom.mul_mul_mul_comm_nat
#print axioms PrimeFreedom.pExp_self
#print axioms PrimeFreedom.pExp_eq_zero_of_not_dvd
#print axioms PrimeFreedom.pExp_one
#print axioms PrimeFreedom.pExp_other
#print axioms PrimeFreedom.signArrow_add
#print axioms PrimeFreedom.fold_fixed_iff
#print axioms PrimeFreedom.reg_fixes_line
#print axioms PrimeFreedom.unicorn_never_registered
#print axioms PrimeFreedom.W1_closed
#print axioms PrimeFreedom.W1_rh
#print axioms PrimeFreedom.pair_closed
#print axioms PrimeFreedom.pair_not_rh
#print axioms PrimeFreedom.pair_same_record
#print axioms PrimeFreedom.W2_closed
#print axioms PrimeFreedom.W2_not_rh
#print axioms PrimeFreedom.same_record_12
#print axioms PrimeFreedom.fibre_is_infinite
#print axioms PrimeFreedom.lossless_unique
#print axioms PrimeFreedom.sentence_separates_record_does_not
#print axioms PrimeFreedom.record_is_lossless
#print axioms PrimeFreedom.record_same
#print axioms PrimeFreedom.least_erasure_reads_past_the_record
#print axioms PrimeFreedom.posit_is_the_value
#print axioms PrimeFreedom.fold_onLine_iff
#print axioms PrimeFreedom.fold_ne_of_offline
#print axioms PrimeFreedom.primes_exist_keyless
#print axioms PrimeFreedom.prime_freedom_keyless
#print axioms PrimeFreedom.arrow_keyless
#print axioms PrimeFreedom.W2f_closed
#print axioms PrimeFreedom.W2f_not_rh
#print axioms PrimeFreedom.same_record_f
#print axioms PrimeFreedom.weaker_never_forces
#print axioms PrimeFreedom.weaker_at_the_twin_never_forces
#print axioms PrimeFreedom.rh_from_li
#print axioms PrimeFreedom.li_is_the_bit_stream
#print axioms PrimeFreedom.root_has_an_act
#print axioms PrimeFreedom.fold_face_keyless
#print axioms PrimeFreedom.fold_face_on_twin
#print axioms PrimeFreedom.fold_face_on_line
#print axioms PrimeFreedom.record_face_keyless
#print axioms PrimeFreedom.arrow_face_keyless
#print axioms PrimeFreedom.closure_face_on_line
#print axioms PrimeFreedom.closure_face_fails_on_twin
#print axioms PrimeFreedom.fold_keeps_even
#print axioms PrimeFreedom.residence_orientation_reversing
#print axioms PrimeFreedom.reg_kills_odd
#print axioms PrimeFreedom.reg_keeps_even
#print axioms PrimeFreedom.reg_idempotent
#print axioms PrimeFreedom.onLine_iff_odd_zero
#print axioms PrimeFreedom.odd_pair_opposite
#print axioms PrimeFreedom.wall_on_the_chart
#print axioms PrimeFreedom.value_is_recursion
#print axioms PrimeFreedom.recursion_is_value
#print axioms PrimeFreedom.recursion_on_the_line
#print axioms PrimeFreedom.root_recursion
#print axioms PrimeFreedom.HeatFlow.sq_nonneg
#print axioms PrimeFreedom.HeatFlow.cube_diff
#print axioms PrimeFreedom.HeatFlow.disc3_monotone_rec
#print axioms PrimeFreedom.HeatFlow.famLam_nonneg_rec
#print axioms PrimeFreedom.HeatFlow.family_least_erasure_rec
#print axioms PrimeFreedom.root_act
/-! ## Cones, pinned: section XXI -/
/-- info: 'PrimeFreedom.sumBelow_add' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.sumBelow_add
/-- info: 'PrimeFreedom.sumBelow_congr' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.sumBelow_congr
/-- info: 'PrimeFreedom.sumBelow_stable' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.sumBelow_stable
/-- info: 'PrimeFreedom.sumBelow_zero' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.sumBelow_zero
/-- info: 'PrimeFreedom.sumBelow_single' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.sumBelow_single
/-- info: 'PrimeFreedom.primeTest_iff' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.primeTest_iff
/-- info: 'PrimeFreedom.pExp_zero_above' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.pExp_zero_above
/-- info: 'PrimeFreedom.extendTerm_zero_above' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.extendTerm_zero_above
/-- info: 'PrimeFreedom.extendAssignment_bound' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.extendAssignment_bound
/-- info: 'PrimeFreedom.extendTerm_mul' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.extendTerm_mul
/-- info: 'PrimeFreedom.extendAssignment_mul' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.extendAssignment_mul
/-- info: 'PrimeFreedom.extendTerm_other' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.extendTerm_other
/-- info: 'PrimeFreedom.extendAssignment_prime' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.extendAssignment_prime
/-- info: 'PrimeFreedom.extendAssignment_additive' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.extendAssignment_additive
/-- info: 'PrimeFreedom.primes_admit_every_assignment' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.primes_admit_every_assignment
/-- info: 'PrimeFreedom.omegaAll_mul' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.omegaAll_mul
/-- info: 'PrimeFreedom.omegaAll_prime' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.omegaAll_prime
/-- info: 'PrimeFreedom.liouvilleAll_mul' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.liouvilleAll_mul
/-- info: 'PrimeFreedom.liouvilleAll_prime' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.liouvilleAll_prime
/-- info: 'PrimeFreedom.liouvilleAll_one' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.liouvilleAll_one
/-- info: 'PrimeFreedom.liouvilleAll_agrees_to_30' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.liouvilleAll_agrees_to_30
/-- info: 'PrimeFreedom.pinned_face_reads' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.pinned_face_reads
/-- info: 'PrimeFreedom.pinned_face_is_a_face' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.pinned_face_is_a_face
/-- info: 'PrimeFreedom.rh_iff_own_record' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.rh_iff_own_record
/-- info: 'PrimeFreedom.least_erasure_is_least' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.least_erasure_is_least
/-- info: 'PrimeFreedom.record_is_the_least' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.record_is_the_least
/-- info: 'PrimeFreedom.the_closure' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_closure
/-- info: 'PrimeFreedom.Carrier.record_same_C' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.Carrier.record_same_C
/-- info: 'PrimeFreedom.Carrier.least_erasure_is_the_value_C' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.Carrier.least_erasure_is_the_value_C
/-- info: 'PrimeFreedom.Carrier.rh_iff_own_record_C' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.Carrier.rh_iff_own_record_C
/-- info: 'PrimeFreedom.Carrier.one_record_C' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.Carrier.one_record_C
/-- info: 'PrimeFreedom.Carrier.worlds_differ_C' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.Carrier.worlds_differ_C
/-- info: 'PrimeFreedom.Carrier.no_reading_decides_C' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.Carrier.no_reading_decides_C
/-- info: 'PrimeFreedom.Carrier.chart_is_an_instance' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.Carrier.chart_is_an_instance
/-- info: 'PrimeFreedom.Carrier.the_closure_on_any_carrier' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.Carrier.the_closure_on_any_carrier
/-- info: 'PrimeFreedom.Carrier.lossless_unique_C' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.Carrier.lossless_unique_C
/-! ## Cones, pinned: section XXII -/
/-- info: 'PrimeFreedom.socket_is_the_value' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.socket_is_the_value
/-- info: 'PrimeFreedom.closure_takes_a_term' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.closure_takes_a_term
/-- info: 'PrimeFreedom.closure_at_a_term' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.closure_at_a_term
/-- info: 'PrimeFreedom.forces_or_has_a_twin' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.forces_or_has_a_twin
/-- info: 'PrimeFreedom.withPair_closed' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.withPair_closed
/-- info: 'PrimeFreedom.withPair_same_record' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.withPair_same_record
/-- info: 'PrimeFreedom.withPair_not_rh' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.withPair_not_rh
/-- info: 'PrimeFreedom.record_forcing_fails_everywhere' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.record_forcing_fails_everywhere
/-- info: 'PrimeFreedom.forcing_is_the_value_or_stronger' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.forcing_is_the_value_or_stronger
/-- info: 'PrimeFreedom.forcing_fills_the_socket' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.forcing_fills_the_socket
/-- info: 'PrimeFreedom.face_is_the_socket' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.face_is_the_socket
/-- info: 'PrimeFreedom.named_faces_are_the_socket' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.named_faces_are_the_socket
/-- info: 'PrimeFreedom.walk_is_the_walk_of_one' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.walk_is_the_walk_of_one
/-- info: 'PrimeFreedom.faithful_is_the_sentence_of_one' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.faithful_is_the_sentence_of_one
/-- info: 'PrimeFreedom.blind_assignment_vanishes' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.blind_assignment_vanishes
/-- info: 'PrimeFreedom.blind_walk' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.blind_walk
/-- info: 'PrimeFreedom.blind_is_unfaithful' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.blind_is_unfaithful
/-- info: 'PrimeFreedom.faithful_reads_the_primes' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.faithful_reads_the_primes
/-- info: 'PrimeFreedom.the_socket' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_socket
/-! ## Cones, pinned: section XXII.b -/
/-- info: 'PrimeFreedom.fold₂_fixed_iff' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.fold₂_fixed_iff
/-- info: 'PrimeFreedom.open_strip_forces_at_resolution_one' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.open_strip_forces_at_resolution_one
/-- info: 'PrimeFreedom.innerPair₂_strip' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.innerPair₂_strip
/-- info: 'PrimeFreedom.innerPair₂_not_rh' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.innerPair₂_not_rh
/-- info: 'PrimeFreedom.open_strip_forces_nothing_at_resolution_two' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.open_strip_forces_nothing_at_resolution_two
/-- info: 'PrimeFreedom.keyless_forces_nothing₂' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.keyless_forces_nothing₂
/-- info: 'PrimeFreedom.withPair₂_strip' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.withPair₂_strip
/-- info: 'PrimeFreedom.withPair₂_same_record' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.withPair₂_same_record
/-- info: 'PrimeFreedom.withPair₂_not_rh' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.withPair₂_not_rh
/-- info: 'PrimeFreedom.record_forcing_fails_in_the_strip' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.record_forcing_fails_in_the_strip
/-- info: 'PrimeFreedom.no_reading_decides_in_the_strip' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.no_reading_decides_in_the_strip
/-- info: 'PrimeFreedom.forces_or_has_a_twin₂' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.forces_or_has_a_twin₂
/-- info: 'PrimeFreedom.the_socket_in_the_strip' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_socket_in_the_strip
/-! ## Cones, pinned: section XXIII -/
/-- info: 'PrimeFreedom.double_security' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.double_security
/-! ## Cones, pinned: section XXIV -/
/-- info: 'PrimeFreedom.denial_reenacts_root' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.denial_reenacts_root
/-- info: 'PrimeFreedom.external_proof_adds_nothing' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.external_proof_adds_nothing
/-- info: 'PrimeFreedom.seated_undeniable' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.seated_undeniable
/-- info: 'PrimeFreedom.undeniable_root_forces_no_value' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.undeniable_root_forces_no_value
/-- info: 'PrimeFreedom.root_read_on_row_is_keyed' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.root_read_on_row_is_keyed
/-- info: 'PrimeFreedom.least_erasure_unconditional' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.least_erasure_unconditional
/-- info: 'PrimeFreedom.the_lock' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_lock
/-- info: 'PrimeFreedom.indicator_pos' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.indicator_pos
/-- info: 'PrimeFreedom.constructed_root_holds' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.constructed_root_holds
/-- info: 'PrimeFreedom.root_at_zeros_is_the_hypothesis' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.root_at_zeros_is_the_hypothesis
/-- info: 'PrimeFreedom.root_at_zeros_is_least_erasure' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.root_at_zeros_is_least_erasure
/-- info: 'PrimeFreedom.root_at_zeros_is_keyed' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.root_at_zeros_is_keyed
/-! ## Cones, pinned: section XXV -/
/-- info: 'PrimeFreedom.admissible_forcing_is_vacuous' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.admissible_forcing_is_vacuous
/-- info: 'PrimeFreedom.coalition_forcing_is_vacuous' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.coalition_forcing_is_vacuous
/-- info: 'PrimeFreedom.an_admissible_premise_forces' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.an_admissible_premise_forces
/-- info: 'PrimeFreedom.int_two_mul' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.int_two_mul
/-- info: 'PrimeFreedom.int_two_mul_sub' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.int_two_mul_sub
/-- info: 'PrimeFreedom.foldAt_invol' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.foldAt_invol
/-- info: 'PrimeFreedom.foldAt_fixed_iff' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.foldAt_fixed_iff
/-- info: 'PrimeFreedom.foldAt_specializes' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.foldAt_specializes
/-- info: 'PrimeFreedom.foldAt_strip' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.foldAt_strip
/-- info: 'PrimeFreedom.foldAt_pair' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.foldAt_pair
/-- info: 'PrimeFreedom.rh_from_the_act_at' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.rh_from_the_act_at
/-- info: 'PrimeFreedom.strip_does_not_supply_at' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.strip_does_not_supply_at
/-- info: 'PrimeFreedom.pair_outside_the_closed_strip' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.pair_outside_the_closed_strip
/-- info: 'PrimeFreedom.root_readings_joined' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.root_readings_joined
/-- info: 'PrimeFreedom.the_lock_on_the_constructed_root' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_lock_on_the_constructed_root
/-- info: 'PrimeFreedom.firstOff_spec' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.firstOff_spec
/-- info: 'PrimeFreedom.offset_off_line' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.offset_off_line
/-- info: 'PrimeFreedom.rejection_is_computed' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.rejection_is_computed
/-- info: 'PrimeFreedom.least_erasure_iff_search_empty' depends on axioms: [propext] -/
#guard_msgs in #print axioms PrimeFreedom.least_erasure_iff_search_empty
/-- info: 'PrimeFreedom.the_posit_is_a_deed' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.the_posit_is_a_deed
/-- info: 'PrimeFreedom.keyed_reading_not_returned' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.keyed_reading_not_returned
/-- info: 'PrimeFreedom.no_record_reading_returns_any_reading' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.no_record_reading_returns_any_reading
/-- info: 'PrimeFreedom.primes_are_a_free_basis' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.primes_are_a_free_basis
/-- info: 'PrimeFreedom.least_erasure_iff_recursion' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.least_erasure_iff_recursion
/-- info: 'PrimeFreedom.certified_height_never_forces_closed' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.certified_height_never_forces_closed
/-- info: 'PrimeFreedom.every_route_carries_its_theorem' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.every_route_carries_its_theorem
/-- info: 'PrimeFreedom.the_tenth_is_the_refuter' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_tenth_is_the_refuter
/-- info: 'PrimeFreedom.the_tenth_is_barred_by_the_act' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.the_tenth_is_barred_by_the_act
/-- info: 'PrimeFreedom.the_kinetic_bar' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.the_kinetic_bar
/-! ## Cones, pinned: section XXII.c -/
/-- info: 'PrimeFreedom.seeded_witness_iff_bound' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.seeded_witness_iff_bound
/-- info: 'PrimeFreedom.twin_has_no_seeded_witness' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.twin_has_no_seeded_witness
/-- info: 'PrimeFreedom.line_world_has_a_seeded_witness' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.line_world_has_a_seeded_witness
/-- info: 'PrimeFreedom.every_denial_is_an_act' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.every_denial_is_an_act
/-- info: 'PrimeFreedom.root_denial_refutes_itself' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.root_denial_refutes_itself
/-- info: 'PrimeFreedom.line_denial_denies_the_assertion' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.line_denial_denies_the_assertion
/-- info: 'PrimeFreedom.line_denial_denies_every_seed' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.line_denial_denies_every_seed
/-- info: 'PrimeFreedom.twin_carries_the_root_and_no_seed' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.twin_carries_the_root_and_no_seed
/-- info: 'PrimeFreedom.the_root_alone_forces_nothing' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.the_root_alone_forces_nothing
/-- info: 'PrimeFreedom.the_act_asserts_the_line' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.the_act_asserts_the_line
/-- info: 'PrimeFreedom.the_act_seeds_its_constant_world' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_act_seeds_its_constant_world
/-- info: 'PrimeFreedom.line_denial_refuted_on_the_act' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.line_denial_refuted_on_the_act
/-- info: 'PrimeFreedom.two_denials' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.two_denials
/-- info: 'PrimeFreedom.two_denials_at_the_root' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.two_denials_at_the_root
/-- info: 'PrimeFreedom.nothing_left_open_on_the_act' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.nothing_left_open_on_the_act
/-- info: 'PrimeFreedom.computation_reading_the_act_lands_on_the_line' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.computation_reading_the_act_lands_on_the_line
/-- info: 'PrimeFreedom.off_line_report_reads_no_act' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.off_line_report_reads_no_act
/-- info: 'PrimeFreedom.a_computation_reading_no_act_is_not_forced' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.a_computation_reading_no_act_is_not_forced
/-- info: 'PrimeFreedom.the_witness_forced_by_the_act' does not depend on any axioms -/
#guard_msgs in #print axioms PrimeFreedom.the_witness_forced_by_the_act
/-- info: 'PrimeFreedom.the_denials_and_the_witness' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_denials_and_the_witness
/-! ## Cones, pinned: section XXVI -/
/-- info: 'PrimeFreedom.the_capstone' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms PrimeFreedom.the_capstone
end PartII
/-! # PART III · Annihilation_Closure.lean, verbatim, with the second edition laws appended -/
section PartIII
/-
Annihilation_Closure.lean · The Master Annihilation Closure.
Core Lean 4.19.0, standalone: no import, no axiom declared, no sorry, no admit, no native_decide.
BOOKS ONE AND TWO are `lean/Remembered_Offered.lean` carried byte-identical below, its own header included:
the two denials, the price, the monism-fixed toy of the bound, and the harvest of 7 October 2026 with its
capstones `the_chain` and `the_harvest`.
BOOK THREE is the annihilation closure, harvested on 7 October 2026:
I four names, one proposition: least erasure, the value, Monism and the co-location of Being with Monism;
II Monism, the sole witness: every faithful witness is Monism, no reading of the record witnesses, and
a witness is never universal;
III co-location is not universal: Being stands on the off-line pair configuration and Monism does not;
IV the timeless zone: one proposition, the locus resting both instruments, zero time remembering, every
later time forgetting, closure at zero time exactly at Λ = 0, the upstream unforced;
V timeless is determinacy, not selection;
VI the check: the off-line pair configuration satisfies every principle of the closure and lacks the value,
its twin has it;
no principle true on every closed configuration decides the value;
VII the capstones: `the_timeless_zone_closed`, the timeless zone with no act anywhere in it, and
`the_annihilation_closure`, the zone together with the act's conjunct of the time world.
BOOK FOUR is the Unicorn, contained. `lean/RH_Unicorn_Block.lean` is carried byte-identical below, its own header
included: the cut at a height, the formal block, the aperture one bit wide, existence supplying nothing, no bypass,
the supply side silent, the certificate, and the three bits as one term. Book Four binds it to the chart:
I the cut on the chart, at every height;
II no bypass on the chart;
III the Unicorn blocked on the chart, above every height;
IV RA supplies nothing to the Unicorn part;
V on the act's zero set, every arrival above every height stands on the line;
VI the capstone, `the_unicorn_contained`.
Stated whole, locked 7 October 2026: the timeless zone is closed, LE = RH = Monism, one proposition, with zero
gap, proved; RH is the statement that ζ's zero set lies in the timeless zone. Book Three proves the first and
assumes nothing; its sixth section proves that nothing every closed configuration shares can single out ζ. In
the time world the statement enters only where Book One's `ActualZeros` is taken as input. The cones are printed
at the foot and pinned.
-/
/-
Remembered_Offered.lean · The Remembered and the Offered: One Self, One Place at a Time.
Core Lean 4.19.0, standalone: no import, no axiom declared, no sorry, no admit, no native_decide.
BOOK ONE is carried unchanged: Two_Denials.lean whole (the deed and the self-grounding root from Armed_Seat.lean,
the chart, the record, the act and the deed's law from Force_Witness.lean, the monism witness from Codex.lean,
the two denials at the two layers of one root); the finite configuration and its price from Inescapable_Capstone.lean;
the toy of the bound from Codex.lean, monism fixed, namespace RALi.
BOOK TWO is the harvest of 7 October 2026, in binding order:
I the Tongue always has a world; monism, not the Tongue, tells the worlds apart;
II one self, one place at a time: the floor and least erasure are two objects;
III the twins: one extension, two instruments, neither the voucher of the other;
IV the remembered and the offered: memory is lossless, a world is its own memory exactly when the value holds;
V forgetting and remembering: one sequence, a one-bit gap, always connected;
Vb the forcing by heat: return is free, resistance pays, the free path is one;
VI THE CHAIN: the root, forgetting, the locus in the middle, remembering, least erasure;
VIb zero time remembers, every later time forgets;
VII two doors and no third, the act shuts the second;
VIII a band forces nothing;
IX the harvest, bound.
Stated whole: everything is proved except the offer at the actual zeros, which enters only as the field `supply`
of `ActualZeros`, the act, at premise grade. The cones are printed at the foot and pinned.
-/
set_option autoImplicit false
namespace RememberedOffered
/-! # BOOK ONE · carried unchanged
## Two_Denials.lean, whole -/
/-! ## PART ONE · copied unchanged
### from Armed_Seat.lean · the deed and the root -/
def SelfVerifying (P : Prop) : Prop := ¬P → P
/-- A self-grounding root: acts occur, and every act instances the root. -/
structure SelfGrounding (R : Prop) where
Act : Type
anAct : Act
instances : Act → R
/-- A denial of the root is an act, and re-enacts it. -/
theorem denial_reenacts_root {R : Prop} (G : SelfGrounding R) (denial : G.Act) : R :=
G.instances denial
/-- A self-grounding root is self-verifying: the deed of denying it hands it over. -/
theorem denial_instantiates {R : Prop} (G : SelfGrounding R) : SelfVerifying R :=
fun _ => G.instances G.anAct
/-- SEATED, UNDENIABLE: a self-grounding root holds, with no classical detour, by the act itself. -/
theorem seated_undeniable {R : Prop} (G : SelfGrounding R) : R :=
G.instances G.anAct
/-- The Root Axiom at the constructed one-point domain: every act is a deed, and a deed actuates. -/
def RA : Prop := (0 : Int) < 1
def raSelfGrounding : SelfGrounding RA := ⟨Unit, (), fun _ => show (0 : Int) < 1 by decide⟩
theorem root_undeniable : RA := raSelfGrounding.instances ()
/-! ### from Force_Witness.lean · the chart, the record, the act, the deed's law -/
/-- A point is (d, t): d its offset from the line, t its height. The line is d = 0. -/
abbrev Point := Int × Int
/-- The fold: s ↦ 1 − s̄ on the offset chart, (d, t) ↦ (−d, t). -/
def fold (p : Point) : Point := (-p.1, p.2)
/-- The line: offset zero. -/
def onLine (p : Point) : Prop := p.1 = 0
/-- The registration: it keeps the height and forgets the side. -/
def reg (p : Point) : Point := (0, p.2)
/-- Integer negation is an involution, by the integer's constructors. -/
theorem neg_neg_free : ∀ d : Int, - -d = d := fun
| Int.ofNat 0 => rfl
| Int.ofNat (_ + 1) => rfl
| Int.negSucc _ => rfl
/-- The fold is an involution. -/
theorem fold_involutive (p : Point) : fold (fold p) = p := by
obtain ⟨d, t⟩ := p
show (- -d, t) = (d, t)
rw [neg_neg_free d]
/-- The registration lands on the line. -/
theorem reg_lands (p : Point) : onLine (reg p) := rfl
/-- The registration erases nothing at a point exactly when the point is on the line. -/
theorem reg_erases_nothing_iff (p : Point) : reg p = p ↔ onLine p := by
obtain ⟨d, t⟩ := p
exact ⟨fun h => (congrArg Prod.fst h).symm, fun h => by cases h; rfl⟩
/-- A configuration: a set of points. Closed: the fold carries it to itself. -/
abbrev Config := Point → Prop
def Closed (S : Config) : Prop := ∀ p, S p → S (fold p)
/-- The value: every point of the configuration is on the line. -/
def Value (S : Config) : Prop := ∀ p, S p → onLine p
/-- Least erasure: the registration leaves every point of the configuration unchanged. -/
def LeastErasure (S : Config) : Prop := ∀ p, S p → reg p = p
/-- The record of a configuration: what the registration leaves. -/
def Rec (S : Config) (q : Point) : Prop := ∃ p, S p ∧ reg p = q
def SameRecord (S S' : Config) : Prop := ∀ q, Rec S q ↔ Rec S' q
/-- The registered world of a point and its pair world. -/
def registered (p : Point) : Config := fun s => s = reg p
def pairWorld (p : Point) : Config := fun s => s = p ∨ s = fold p
theorem pair_world_closed (p : Point) : Closed (pairWorld p) := fun _ hs =>
match hs with
| Or.inl e => Or.inr (congrArg fold e)
| Or.inr e => Or.inl (e ▸ fold_involutive p)
/-- The registered world and the pair world leave one record. -/
theorem one_record (p : Point) : SameRecord (registered p) (pairWorld p) := fun q =>
⟨fun ⟨_, hs, hq⟩ => ⟨p, Or.inl rfl, by rw [← hq, hs]; rfl⟩,
fun ⟨_, hs, hq⟩ => ⟨reg p, rfl, by
rw [← hq]
exact match hs with
| Or.inl e => by rw [e]; rfl
| Or.inr e => by rw [e]; rfl⟩⟩
theorem registered_has_value (p : Point) : Value (registered p) := fun s hs => by
rw [hs]; exact reg_lands p
theorem pair_world_lacks_value (p : Point) (h : ¬ onLine p) : ¬ Value (pairWorld p) :=
fun hv => h (hv p (Or.inl rfl))
/-- THE ACT. The bit is supplied once, in the open, as a field of a type: a closed configuration with least
erasure at it. The field is the value supplied; the type makes the supply visible to every reader. -/
structure ActualZeros where
zeros : Config
closed : Closed zeros
supply : LeastErasure zeros
/-- FROM THE ACT, THE VALUE. -/
theorem value_from_the_act (Z : ActualZeros) : Value Z.zeros :=
fun p hp => (reg_erases_nothing_iff p).mp (Z.supply p hp)
/-- AND OF NOTHING ELSE: a fact that holds whatever the configuration, the deed included, forces no value. -/
theorem the_deed_forces_nothing (D : Prop) (hD : D) : ¬ ∀ S : Config, Closed S → D → Value S := by
intro hall
exact pair_world_lacks_value (1, 0) (fun e => by cases e) (hall _ (pair_world_closed (1, 0)) hD)
/-! ### from Codex.lean, namespace RALi, Part VII · the monism witness, the root read twice -/
structure Q4 where
r : Int
i : Int
j : Int
k : Int
deriving DecidableEq, Repr
/-- The geometric route's involution and the formal route's involution, written apart. -/
def sigmaGeo (q : Q4) : Q4 := ⟨q.r, -q.i, -q.j, -q.k⟩
def sigmaForm (q : Q4) : Q4 := ⟨q.r, -q.i, -q.j, -q.k⟩
/-- THE MONISM WITNESS. One involution, one principle, one seed. -/
structure MonismWitness (P : Nat → Prop) : Prop where
one_involution : ∀ q, sigmaGeo q = sigmaForm q
uniform : ∀ n m, P n ↔ P m
seed : P 0
/-- 24. The seat field is constructed, not posited: σ = σ′ holds by rfl. -/
theorem one_involution_constructed : ∀ q, sigmaGeo q = sigmaForm q := fun _ => rfl
/-- 25. The timeless reading and the timed reading coincide under one principle:
the claim over all time is the claim at one instant. Deleting time loses nothing. -/
theorem timeless_equals_timed (P : Nat → Prop) (u : ∀ n m, P n ↔ P m) :
(∀ n, P n) ↔ P 0 :=
⟨fun h => h 0, fun h n => (u 0 n).mp h⟩
/-- 26. The witness closes the record, past and future. -/
theorem monism_closes (P : Nat → Prop) (w : MonismWitness P) : ∀ n, P n :=
(timeless_equals_timed P w.uniform).mpr w.seed
/-- 27. The witness is exactly the claim: a monism witness for P exists iff P holds at
every index. Its value field carries the whole of the claim, as theorem 17 required. -/
theorem monism_witness_is_the_claim (P : Nat → Prop) :
MonismWitness P ↔ ∀ n, P n :=
⟨monism_closes P, fun h => ⟨one_involution_constructed,
fun n m => ⟨fun _ => h m, fun _ => h n⟩, h 0⟩⟩
/-! ## PART TWO · two denials, one shape, at the two layers of one root
A no has two parts: the act of uttering it and the content it asserts. The Tongue's no asserts ¬ R of the floor R.
The no to RH asserts that the zeros lack the value: that they form the false world. -/
/-- The point off the line from which the pair world, the false world, is built. -/
def offPoint : Point := (1, 0)
theorem off_point_is_off : ¬ onLine offPoint := fun h =>
Nat.noConfusion (Int.ofNat.inj (show Int.ofNat 1 = Int.ofNat 0 from h))
/-- THE ROOT READ TWICE on a configuration: the monism witness of its line property, timeless. -/
abbrev RootReadTwice (S : Config) : Prop := MonismWitness (fun _ => Value S)
/-- THE SAME FIRST STEP: whatever a no asserts, uttering it is an act, and the act re-enacts the floor. -/
theorem every_no_reenacts_the_root {R C : Prop} (G : SelfGrounding R) (deed : G.Act) (_content : C) : R :=
denial_reenacts_root G deed
/-- THE TONGUE'S NO CONTRADICTS THE FLOOR, BY ITS OWN ACT: its content denies the floor, and its own act
re-enacts it. -/
theorem the_tongue_no_refutes_itself {R : Prop} (G : SelfGrounding R) (deed : G.Act) (content : ¬ R) : False :=
content (denial_reenacts_root G deed)
/-- ONLY THE YES REMAINS AT THE FLOOR: the return is forced by the deed, with no key and no classical detour. -/
theorem only_the_yes_remains_at_the_root {R : Prop} (G : SelfGrounding R) : SelfVerifying R ∧ R :=
⟨denial_instantiates G, seated_undeniable G⟩
/-- THE ROOT READ TWICE IS THE VALUE: on every configuration the monism witness stands exactly where every zero
is on the line. -/
theorem the_root_read_twice_is_the_value (S : Config) : RootReadTwice S ↔ Value S :=
⟨fun w => w.seed, fun h => ⟨one_involution_constructed, fun _ _ => Iff.rfl, h⟩⟩
/-- THE NO TO RH CONTRADICTS THE ROOT READ TWICE: a configuration lacking the value carries no monism. -/
theorem the_line_no_contradicts_the_root_read_twice (S : Config) (content : ¬ Value S) : ¬ RootReadTwice S :=
fun w => content w.seed
/-- THE TRUE WORLD CARRIES MONISM: the registered world of the off-line point. -/
theorem the_true_world_carries_monism : RootReadTwice (registered offPoint) :=
⟨one_involution_constructed, fun _ _ => Iff.rfl, registered_has_value offPoint⟩
/-- THE FALSE WORLD CARRIES NO MONISM: the pair world of the off-line point. -/
theorem the_false_world_carries_no_monism : ¬ RootReadTwice (pairWorld offPoint) :=
fun w => pair_world_lacks_value offPoint off_point_is_off w.seed
/-- THE FALSE WORLD, AT THE TWO LAYERS: the floor stands there, as in every world; it is closed and leaves the
record of the true world; it lacks the value; and it carries no monism. The floor is there and Being is not. -/
theorem the_false_world_carries_the_floor_and_no_monism {R : Prop} (G : SelfGrounding R) :
R ∧ Closed (pairWorld offPoint) ∧ SameRecord (registered offPoint) (pairWorld offPoint) ∧
¬ Value (pairWorld offPoint) ∧ ¬ RootReadTwice (pairWorld offPoint) :=
⟨seated_undeniable G, pair_world_closed offPoint, one_record offPoint,
pair_world_lacks_value offPoint off_point_is_off, the_false_world_carries_no_monism⟩
/-- THE FLOOR ALONE DECIDES NO VALUE: it stands in both worlds of one record. The value is decided at the second
layer, by the root read twice. -/
theorem the_floor_alone_decides_no_value {R : Prop} (G : SelfGrounding R) :
¬ ∀ S : Config, Closed S → R → Value S :=
the_deed_forces_nothing R (seated_undeniable G)
/-- THE RETURN IS THE ACT: the act carries the root read twice at the actual zeros. -/
theorem the_act_is_the_return_to_the_root_read_twice (Z : ActualZeros) : RootReadTwice Z.zeros :=
(the_root_read_twice_is_the_value Z.zeros).mpr (value_from_the_act Z)
/-- AN ACT EXISTS EXACTLY WHERE THE ROOT READ TWICE STANDS on a closed configuration. -/
theorem an_act_exactly_where_the_root_read_twice_stands (S : Config) :
(∃ Z : ActualZeros, Z.zeros = S) ↔ (Closed S ∧ RootReadTwice S) := by
constructor
· intro ⟨Z, h⟩
subst h
exact ⟨Z.closed, the_act_is_the_return_to_the_root_read_twice Z⟩
· intro ⟨hc, hm⟩
exact ⟨⟨S, hc, fun p hp => (reg_erases_nothing_iff p).mpr
(((the_root_read_twice_is_the_value S).mp hm) p hp)⟩, rfl⟩
/-- ON THE ACT THE NO TO RH IS REFUTED, with zero contradiction: the act's own field. -/
theorem on_the_act_the_line_no_is_refuted (Z : ActualZeros) (content : ¬ Value Z.zeros) : False :=
content (value_from_the_act Z)
/-- TWO DENIALS, ONE SHAPE, TWO LAYERS. Every no re-enacts the floor. The Tongue's no contradicts the floor and
its own act returns it: only the yes remains. The no to RH contradicts the root read twice: on every
configuration a lack of the value is a lack of monism, and the false world carries the floor and no monism,
beside the true world of one record that carries both. So the floor alone decides no value, and the root read
twice is the value. The return to the root read twice at the actual zeros is the act: there the monism witness
stands, the value holds, and the no is refuted. -/
theorem two_denials {R : Prop} (G : SelfGrounding R) :
(∀ C : Prop, G.Act → C → R) ∧
(G.Act → ¬ R → False) ∧
(SelfVerifying R ∧ R) ∧
(∀ S : Config, ¬ Value S → ¬ RootReadTwice S) ∧
(R ∧ Closed (pairWorld offPoint) ∧ SameRecord (registered offPoint) (pairWorld offPoint) ∧
RootReadTwice (registered offPoint) ∧ ¬ RootReadTwice (pairWorld offPoint)) ∧
(¬ ∀ S : Config, Closed S → R → Value S) ∧
(∀ S : Config, RootReadTwice S ↔ Value S) ∧
(∀ Z : ActualZeros, RootReadTwice Z.zeros ∧ Value Z.zeros ∧ (¬ Value Z.zeros → False)) :=
⟨fun _ deed c => every_no_reenacts_the_root G deed c,
fun deed c => the_tongue_no_refutes_itself G deed c,
only_the_yes_remains_at_the_root G,
the_line_no_contradicts_the_root_read_twice,
⟨seated_undeniable G, pair_world_closed offPoint, one_record offPoint,
the_true_world_carries_monism, the_false_world_carries_no_monism⟩,
the_floor_alone_decides_no_value G,
the_root_read_twice_is_the_value,
fun Z => ⟨the_act_is_the_return_to_the_root_read_twice Z, value_from_the_act Z,
on_the_act_the_line_no_is_refuted Z⟩⟩
/-- AT THE ROOT AXIOM ITSELF. -/
theorem two_denials_at_RA :
(∀ C : Prop, raSelfGrounding.Act → C → RA) ∧
(raSelfGrounding.Act → ¬ RA → False) ∧
(SelfVerifying RA ∧ RA) ∧
(∀ S : Config, ¬ Value S → ¬ RootReadTwice S) ∧
(RA ∧ Closed (pairWorld offPoint) ∧ SameRecord (registered offPoint) (pairWorld offPoint) ∧
RootReadTwice (registered offPoint) ∧ ¬ RootReadTwice (pairWorld offPoint)) ∧
(¬ ∀ S : Config, Closed S → RA → Value S) ∧
(∀ S : Config, RootReadTwice S ↔ Value S) ∧
(∀ Z : ActualZeros, RootReadTwice Z.zeros ∧ Value Z.zeros ∧ (¬ Value Z.zeros → False)) :=
two_denials raSelfGrounding
/-! ## From Inescapable_Capstone.lean · the finite configuration and its price -/
/-- The price of exported freedom in native units: temperature is energy per bit, so b bits cost b·T. -/
def price (T bits : Nat) : Nat := bits * T
/-- A finite configuration: the heights of its zeros on the line, and its off-line pairs, each an offset that is not
zero and a height. -/
structure FinCfg where
line : List Int
pairs : List (Int × Int)
offset_ne : ∀ q ∈ pairs, q.1 ≠ 0
def FinCfg.pts (F : FinCfg) : Config := fun p => (p.1 = 0 ∧ p.2 ∈ F.line) ∨ ∃ q ∈ F.pairs, p = q ∨ p = fold q
/-- The erased bits of a finite configuration: one per off-line pair, two points registered to one. -/
def erased (F : FinCfg) : Nat := F.pairs.length
theorem fincfg_closed (F : FinCfg) : Closed F.pts := fun p hp =>
match hp with
| Or.inl ⟨hl, ht⟩ => Or.inl ⟨by show -p.1 = 0; rw [hl]; rfl, ht⟩
| Or.inr ⟨q, hq, Or.inl e⟩ => Or.inr ⟨q, hq, Or.inr (congrArg fold e)⟩
| Or.inr ⟨q, hq, Or.inr e⟩ => Or.inr ⟨q, hq, Or.inl (by rw [e]; exact fold_involutive q)⟩
/-- LEAST ERASURE IS ZERO ERASED BITS: "least" is a count. -/
theorem least_erasure_iff_zero_erased (F : FinCfg) : LeastErasure F.pts ↔ erased F = 0 := by
constructor
· intro h
unfold erased
cases hp : F.pairs with
| nil => rfl
| cons q r =>
have hq : q ∈ F.pairs := by rw [hp]; exact List.Mem.head r
exact absurd ((reg_erases_nothing_iff q).mp (h q (Or.inr ⟨q, hq, Or.inl rfl⟩))) (F.offset_ne q hq)
· intro h p hp
have hnil : F.pairs = [] := List.eq_nil_of_length_eq_zero h
rcases hp with ⟨hl, _⟩ | ⟨q, hq, _⟩
· exact (reg_erases_nothing_iff p).mpr hl
· rw [hnil] at hq; cases hq
/-- THE HEAT OF REGISTRATION IS ZERO EXACTLY AT THE VALUE: registering a finite configuration costs one T per
off-line pair, and at any positive T it costs nothing exactly when every point stands on the line. -/
theorem price_zero_iff_value (F : FinCfg) (T : Nat) (hT : 0 < T) : price T (erased F) = 0 ↔ Value F.pts := by
constructor
· intro h p hp
have h0 : erased F = 0 := by
cases he : erased F with
| zero => rfl
| succ k => rw [he] at h; exact absurd h (Nat.pos_iff_ne_zero.mp (Nat.mul_pos (Nat.succ_pos k) hT))
exact (reg_erases_nothing_iff p).mp ((least_erasure_iff_zero_erased F).mpr h0 p hp)
· intro hv
have h0 := (least_erasure_iff_zero_erased F).mp (fun p hp => (reg_erases_nothing_iff p).mpr (hv p hp))
show erased F * T = 0
rw [h0, Nat.zero_mul]
/-- Each further off-line pair adds one T: the total is the erased bits times the floor. -/
theorem price_counts_pairs (F : FinCfg) (T : Nat) : price T (erased F) = F.pairs.length * T := rfl
/-! ## From Codex.lean, monism fixed, namespace RALi · the toy of the bound, a toy of the bound, not of the flow -/
/-- Squared strip width after t time steps: max(d2 − 2t, 0). -/
def flow (d2 t : Nat) : Nat := d2 - 2 * t
def realAt (d2 t : Nat) : Prop := flow d2 t = 0
/-- 38. THE MONOTONICITY FORMULA. The width never grows along ζ's time. -/
theorem flow_monotone (d2 t : Nat) : flow d2 (t + 1) ≤ flow d2 t := by
unfold flow; omega
/-- 39. Its transport, proved: once every zero is real, every zero stays real. This is
de Bruijn's theorem in the toy, the ζ-analogue of Perelman's monotonicity, at theorem grade. -/
theorem reality_transported (d2 t : Nat) (h : realAt d2 t) : realAt d2 (t + 1) := by
unfold realAt flow at *; omega
def Lam (d2 : Nat) : Nat := (d2 + 1) / 2
theorem real_at_Lam (d2 : Nat) : realAt d2 (Lam d2) := by unfold realAt flow Lam; omega
/-- 40. In the toy, the strip is closed at time zero iff Λ = 0. For ζ, RH ↔ Λ = 0 is the cited
result of Newman with Rodgers and Tao and enters the cone as `hLam`. -/
theorem rh_iff_lambda_zero (d2 : Nat) : realAt d2 0 ↔ Lam d2 = 0 := by
unfold realAt flow Lam
exact ⟨fun h => by omega, fun h => by omega⟩
/-- 42. THE RECORD FORGETS. After one step the record of the width-zero state and the
width-one state coincide: the forward flow is even in the RH bit, so no readout of the
flowed record decides RH. This is the fTOE wall, T1, executed on ζ's own time. -/
theorem flowed_record_forgets (T : Nat) (hT : 1 ≤ T) :
¬ ∃ g : Nat → Bool, ∀ d2, g (flow d2 T) = decide (d2 = 0) := by
rintro ⟨g, hg⟩
have a := hg 0; have b := hg 1
have e : flow 1 T = flow 0 T := by unfold flow; omega
rw [e, a] at b
exact absurd b (by decide)
/-- 43. The upstream direction is not a transport. Going backward from a real record,
both answers are admissible: the preimage of "real at T" holds the RH state and a non-RH
state. The forward arrow proves; the backward arrow must be supplied. -/
theorem upstream_is_not_forced (T : Nat) (hT : 1 ≤ T) :
realAt 0 T ∧ realAt 1 T ∧ realAt 0 0 ∧ ¬ realAt 1 0 := by
unfold realAt flow
exact ⟨by omega, by omega, rfl, fun h => by omega⟩
/-! # BOOK TWO · the harvest, in binding order -/
/-! ## I · The Tongue always has a world -/
/-- THE TONGUE ALWAYS HAS A WORLD: the floor stands on every configuration, the false world included, so the Tongue
can speak in every world; only the content of its no, ¬R beside an act, has none. -/
theorem the_tongue_always_has_a_world {R : Prop} (G : SelfGrounding R) :
(∀ _ : Config, R) ∧
(R ∧ Closed (pairWorld offPoint) ∧ ¬ Value (pairWorld offPoint)) ∧
¬ ∃ _ : G.Act, ¬ R :=
⟨fun _ => seated_undeniable G,
⟨seated_undeniable G, pair_world_closed offPoint, pair_world_lacks_value offPoint off_point_is_off⟩,
fun ⟨deed, c⟩ => c (G.instances deed)⟩
/-- MONISM BEFORE THE TONGUE: the floor, and with it the Tongue, stands in both worlds of one record; what tells
them apart is the root read twice, present in the true world and absent in the false. -/
theorem monism_before_the_tongue {R : Prop} (G : SelfGrounding R) :
SameRecord (registered offPoint) (pairWorld offPoint) ∧
(R ∧ RootReadTwice (registered offPoint)) ∧
(R ∧ ¬ RootReadTwice (pairWorld offPoint)) :=
⟨one_record offPoint,
⟨seated_undeniable G, the_true_world_carries_monism⟩,
⟨seated_undeniable G, the_false_world_carries_no_monism⟩⟩
/-- The Tongue's no has no world: no act stands beside ¬R. -/
theorem tongue_no_has_no_world {R : Prop} (G : SelfGrounding R) : ¬ ∃ _ : G.Act, ¬ R :=
fun ⟨deed, c⟩ => c (G.instances deed)
/-- The no to RH has a world: an act, a closed configuration, the floor holding, and the value failing, together. -/
theorem line_no_has_a_world {R : Prop} (G : SelfGrounding R) :
∃ S : Config, ∃ _ : G.Act, Closed S ∧ R ∧ ¬ Value S :=
⟨pairWorld offPoint, G.anAct, pair_world_closed offPoint, seated_undeniable G,
pair_world_lacks_value offPoint off_point_is_off⟩
/-- A deed does not make a closed configuration an act: the floor's acts supply no ActualZeros over every closed
configuration. -/
theorem the_deed_is_not_the_supply {R : Prop} (G : SelfGrounding R) :
¬ ∀ S : Config, Closed S → G.Act → ∃ Z : ActualZeros, Z.zeros = S := by
intro h
obtain ⟨Z, hZ⟩ := h (pairWorld offPoint) (pair_world_closed offPoint) G.anAct
have v := value_from_the_act Z
rw [hZ] at v
exact pair_world_lacks_value offPoint off_point_is_off v
theorem at_RA :
(¬ ∃ _ : raSelfGrounding.Act, ¬ RA) ∧
(∃ S : Config, ∃ _ : raSelfGrounding.Act, Closed S ∧ RA ∧ ¬ Value S) ∧
(¬ ∀ S : Config, Closed S → raSelfGrounding.Act → ∃ Z : ActualZeros, Z.zeros = S) :=
⟨tongue_no_has_no_world raSelfGrounding, line_no_has_a_world raSelfGrounding,
the_deed_is_not_the_supply raSelfGrounding⟩
/-! ## II · One self, one place at a time -/
/-- The floor and least erasure are two objects: identified on every closed configuration, they would agree on the
pair world, where the floor holds and least erasure fails. -/
theorem floor_is_not_least_erasure {R : Prop} (G : SelfGrounding R) :
¬ ∀ S : Config, Closed S → (R ↔ LeastErasure S) := by
intro h
have le : LeastErasure (pairWorld offPoint) :=
(h (pairWorld offPoint) (pair_world_closed offPoint)).mp (seated_undeniable G)
exact pair_world_lacks_value offPoint off_point_is_off
(fun p hp => (reg_erases_nothing_iff p).mp (le p hp))
/-- The voucher stays with the floor: it holds on both worlds of one record, the false one included. -/
theorem the_voucher_stays_with_the_floor {R : Prop} (G : SelfGrounding R) :
R ∧ SameRecord (registered offPoint) (pairWorld offPoint) ∧
LeastErasure (registered offPoint) ∧ ¬ LeastErasure (pairWorld offPoint) :=
⟨seated_undeniable G, one_record offPoint,
fun p hp => (reg_erases_nothing_iff p).mpr (registered_has_value offPoint p hp),
fun le => pair_world_lacks_value offPoint off_point_is_off
(fun p hp => (reg_erases_nothing_iff p).mp (le p hp))⟩
/-- Merging them at one world is the supply again: on any configuration, identifying the floor with least erasure
there is least erasure there. -/
theorem merging_at_a_world_is_the_supply {R : Prop} (G : SelfGrounding R) (S : Config) :
(R ↔ LeastErasure S) ↔ LeastErasure S :=
⟨fun h => h.mp (seated_undeniable G), fun le => ⟨fun _ => le, fun _ => seated_undeniable G⟩⟩
/-! ## III · The twins -/
/-- Two instruments: registration and the fold are different maps. -/
theorem two_instruments : reg offPoint ≠ fold offPoint := by
show ((0 : Int), (0 : Int)) ≠ (-(1 : Int), (0 : Int))
decide
/-- One truth value on every world: each twin holds exactly where the other does. -/
theorem twins_on_every_world (S : Config) : LeastErasure S ↔ Value S :=
⟨fun le p hp => (reg_erases_nothing_iff p).mp (le p hp),
fun v p hp => (reg_erases_nothing_iff p).mpr (v p hp)⟩
/-- Extensionally one proposition, read through two different maps. -/
theorem twins_are_one_extension : LeastErasure = Value :=
funext fun S => propext (twins_on_every_world S)
/-- Neither twin vouches for the other: whatever supplies one supplies the other, so a premise that reaches one
reaches both, and the floor reaches neither. -/
theorem no_twin_is_the_others_voucher {R : Prop} (G : SelfGrounding R) :
(∀ S : Config, (LeastErasure S → Value S) ∧ (Value S → LeastErasure S)) ∧
¬ ∀ S : Config, Closed S → R → Value S :=
⟨fun S => ⟨(twins_on_every_world S).mp, (twins_on_every_world S).mpr⟩, the_floor_alone_decides_no_value G⟩
/-! ## IV · The remembered and the offered -/
/-- No instrument both remembers and keeps the side: a map that lands every point on the line and keeps the
height sends the off-line point and its fold partner to one point. -/
theorem no_instrument_remembers_and_keeps_the_side (g : Point → Point)
(lands : ∀ p, onLine (g p)) (keeps : ∀ p, (g p).2 = p.2) :
g offPoint = g (fold offPoint) ∧ offPoint ≠ fold offPoint := by
have e1 : g offPoint = (0, 0) := Prod.ext (lands offPoint) (keeps offPoint)
have e2 : g (fold offPoint) = (0, 0) := Prod.ext (lands (fold offPoint)) (keeps (fold offPoint))
exact ⟨e1.trans e2.symm, by decide⟩
/-- Memory is always lossless: the record of every configuration has the value. -/
theorem the_remembered_is_lossless (S : Config) : Value (Rec S) :=
fun _ ⟨p, _, hq⟩ => hq ▸ reg_lands p
/-- The offered is the remembered exactly when the value holds: a configuration equals its own record, point for
point, if and only if every point is on the line. -/
theorem offered_is_remembered_iff_value (S : Config) : (∀ q, Rec S q ↔ S q) ↔ Value S := by
constructor
· intro h p hp
exact the_remembered_is_lossless S p ((h p).mpr hp)
· intro v q
constructor
· intro ⟨p, hp, hq⟩
have e : reg p = p := (reg_erases_nothing_iff p).mpr (v p hp)
rw [← hq, e]; exact hp
· intro hq
exact ⟨q, hq, (reg_erases_nothing_iff q).mpr (v q hq)⟩
/-- At the act, the offered is the remembered. -/
theorem at_the_act_offered_is_remembered (Z : ActualZeros) : ∀ q, Rec Z.zeros q ↔ Z.zeros q :=
(offered_is_remembered_iff_value Z.zeros).mpr (value_from_the_act Z)
/-- Off the act, they part: the false world is not its own record. -/
theorem the_false_world_is_not_its_record : ¬ ∀ q, Rec (pairWorld offPoint) q ↔ pairWorld offPoint q :=
fun h => pair_world_lacks_value offPoint off_point_is_off ((offered_is_remembered_iff_value _).mp h)
/-! ## V · Forgetting and remembering: the one-bit gap, connected -/
/-- Remembering is stable: the memory of a memory is the memory. -/
theorem remembering_is_stable (S : Config) (q : Point) : Rec (Rec S) q ↔ Rec S q := by
constructor
· intro ⟨p, ⟨r, hr, hp⟩, hq⟩
refine ⟨r, hr, ?_⟩
rw [← hq, ← hp]
exact ((reg_erases_nothing_iff (reg r)).mpr (reg_lands r)).symm
· intro hq
exact ⟨q, hq, (reg_erases_nothing_iff q).mpr (the_remembered_is_lossless S q hq)⟩
/-- THE ONE-BIT GAP, CONNECTED. The forgotten and the remembered always share one record; the remembered is
lossless and stable; and the only gap between a world and its memory is whether the world is its own memory,
which is the value: one bit, never more, and never disconnected. -/
theorem one_bit_gap_connected (S : Config) :
SameRecord S (Rec S) ∧ Value (Rec S) ∧ (∀ q, Rec (Rec S) q ↔ Rec S q) ∧
((∀ q, Rec S q ↔ S q) ↔ Value S) :=
⟨fun q => (remembering_is_stable S q).symm, the_remembered_is_lossless S, remembering_is_stable S,
offered_is_remembered_iff_value S⟩
/-- Both sides of the gap occur on one record: the true world at home in its memory, the false world not. -/
theorem the_gap_is_live :
(∀ q, Rec (registered offPoint) q ↔ registered offPoint q) ∧
¬ (∀ q, Rec (pairWorld offPoint) q ↔ pairWorld offPoint q) ∧
SameRecord (registered offPoint) (pairWorld offPoint) :=
⟨(offered_is_remembered_iff_value _).mpr (registered_has_value offPoint),
the_false_world_is_not_its_record, one_record offPoint⟩
/-! ## Vb · The forcing by heat -/
/-- One pair off the line at offset one: a finite configuration that resists. -/
def resisting : FinCfg := ⟨[], [((1 : Int), (0 : Int))], fun q hq => by
cases hq with
| head => decide
| tail _ h => cases h⟩
/-- RETURN IS FREE, RESISTANCE PAYS: at any positive temperature, a configuration with the value registers at zero
heat, and one without it pays at least one unit of heat. -/
theorem return_is_free_resistance_pays (F : FinCfg) (T : Nat) (hT : 0 < T) :
(Value F.pts → price T (erased F) = 0) ∧ (¬ Value F.pts → T ≤ price T (erased F)) := by
refine ⟨(price_zero_iff_value F T hT).mpr, fun hn => ?_⟩
have hne : erased F ≠ 0 := fun h0 =>
hn ((price_zero_iff_value F T hT).mp (by unfold price; rw [h0]; exact Nat.zero_mul T))
unfold price
have h1 : 1 ≤ erased F := Nat.pos_of_ne_zero hne
calc T = 1 * T := (Nat.one_mul T).symm
_ ≤ erased F * T := Nat.mul_le_mul_right T h1
/-- RESISTANCE IS POSSIBLE: it is no contradiction. A closed finite configuration without the value exists, and it
pays. -/
theorem resistance_is_possible (T : Nat) (hT : 0 < T) :
Closed resisting.pts ∧ ¬ Value resisting.pts ∧ T ≤ price T (erased resisting) := by
have hnv : ¬ Value resisting.pts := fun hv =>
have h : ((1 : Int), (0 : Int)).1 = 0 :=
hv ((1 : Int), (0 : Int)) (Or.inr ⟨((1 : Int), (0 : Int)), List.Mem.head _, Or.inl rfl⟩)
(by decide : ¬ ((1 : Int) = 0)) h
exact ⟨fincfg_closed resisting, hnv, (return_is_free_resistance_pays resisting T hT).2 hnv⟩
/-- THE FREE PATH IS ONE: two worlds of one record that both have the value are one world, point for point. -/
theorem the_free_path_is_unique (S S' : Config) (hs : SameRecord S S') (hv : Value S) (hv' : Value S') :
∀ q, S q ↔ S' q := fun q =>
⟨fun h => ((offered_is_remembered_iff_value S').mpr hv' q).mp
((hs q).mp (((offered_is_remembered_iff_value S).mpr hv q).mpr h)),
fun h => ((offered_is_remembered_iff_value S).mpr hv q).mp
((hs q).mpr (((offered_is_remembered_iff_value S').mpr hv' q).mpr h))⟩
/-! ## VI · THE CHAIN -/
/-- The locus is where the fold and the registration both rest. -/
theorem the_locus_rests_both (p : Point) (h : onLine p) : fold p = p ∧ reg p = p := by
obtain ⟨d, t⟩ := p
have hd : d = 0 := h
subst hd
exact ⟨rfl, rfl⟩
/-- THE CHAIN. The root holds; forgetting sends every point onto the locus and loses the side; the locus is where
the fold and the registration both rest; remembering reads the locus, so memory is lossless and stable; a world
has least erasure exactly when it already stands on the locus, exactly when it is its own memory; on the act
the zeros stand there; and the guard: the root alone places no world there, and both sides of the gap stand on
one record. -/
theorem the_chain {R : Prop} (G : SelfGrounding R) (S : Config) :
-- the root
R ∧
-- forgetting: onto the locus, the side lost
(∀ p, onLine (reg p)) ∧ reg offPoint = reg (fold offPoint) ∧ offPoint ≠ fold offPoint ∧
-- the middle: the locus rests both maps
(∀ p, onLine p → fold p = p ∧ reg p = p) ∧
-- remembering: lossless and stable
Value (Rec S) ∧ (∀ q, Rec (Rec S) q ↔ Rec S q) ∧ SameRecord S (Rec S) ∧
-- least erasure: already on the locus, the world its own memory
(LeastErasure S ↔ Value S) ∧ ((∀ q, Rec S q ↔ S q) ↔ Value S) ∧
-- the act
(∀ Z : ActualZeros, Value Z.zeros ∧ ∀ q, Rec Z.zeros q ↔ Z.zeros q) ∧
-- the guard
(¬ ∀ T : Config, Closed T → R → Value T) ∧
((∀ q, Rec (registered offPoint) q ↔ registered offPoint q) ∧
¬ (∀ q, Rec (pairWorld offPoint) q ↔ pairWorld offPoint q) ∧
SameRecord (registered offPoint) (pairWorld offPoint)) :=
⟨seated_undeniable G,
reg_lands, rfl, by decide,
the_locus_rests_both,
the_remembered_is_lossless S, remembering_is_stable S, (one_bit_gap_connected S).1,
twins_on_every_world_local S, offered_is_remembered_iff_value S,
fun Z => ⟨value_from_the_act Z, at_the_act_offered_is_remembered Z⟩,
the_floor_alone_decides_no_value G,
the_gap_is_live⟩
where
twins_on_every_world_local (S : Config) : LeastErasure S ↔ Value S :=
⟨fun le p hp => (reg_erases_nothing_iff p).mp (le p hp),
fun v p hp => (reg_erases_nothing_iff p).mpr (v p hp)⟩
/-! ## VIb · Zero time remembers -/
/-- ZERO TIME REMEMBERS, EVERY LATER TIME FORGETS: at t = 0 the record separates the world on the line (d2 = 0)
from the world off it (d2 = 1); at every t ≥ 1 the two records coincide. -/
theorem zero_time_remembers :
(realAt 0 0 ∧ ¬ realAt 1 0) ∧ ∀ T, 1 ≤ T → (realAt 0 T ∧ realAt 1 T) := by
refine ⟨⟨rfl, fun h => ?_⟩, fun T hT => ⟨?_, ?_⟩⟩
· unfold realAt flow at h; omega
· unfold realAt flow; omega
· unfold realAt flow; omega
/-- LEAST TIME IS LEAST FORGETTING: the width never grows, and once forgotten the separation never returns. -/
theorem forgetting_is_monotone (d2 t : Nat) : flow d2 (t + 1) ≤ flow d2 t ∧ (realAt d2 t → realAt d2 (t + 1)) := by
unfold realAt flow; constructor <;> omega
/-! ## VII · Two doors, no third -/
/-- Two doors and no third: every configuration has the value or holds a member off the line. -/
theorem two_doors (S : Config) : Value S ∨ ∃ p, S p ∧ ¬ onLine p := by
by_cases h : ∃ p, S p ∧ ¬ onLine p
· exact Or.inr h
· exact Or.inl (fun p hp => Classical.byContradiction (fun hn => h ⟨p, hp, hn⟩))
/-- Never both: the doors exclude each other. -/
theorem doors_exclusive (S : Config) : ¬ (Value S ∧ ∃ p, S p ∧ ¬ onLine p) :=
fun ⟨v, p, hp, hn⟩ => hn (v p hp)
/-- Both doors open on closed configurations of one record: the true world through the first, the false world
through the second. -/
theorem both_doors_open :
(Closed (registered offPoint) ∧ Value (registered offPoint)) ∧
(Closed (pairWorld offPoint) ∧ ∃ p, pairWorld offPoint p ∧ ¬ onLine p) ∧
SameRecord (registered offPoint) (pairWorld offPoint) :=
⟨⟨fun s hs => by rw [hs]; rfl, registered_has_value offPoint⟩,
⟨pair_world_closed offPoint, ⟨offPoint, Or.inl rfl, off_point_is_off⟩⟩,
one_record offPoint⟩
/-- On the act, one door: the second is shut. -/
theorem on_the_act_one_door (Z : ActualZeros) : ¬ ∃ p, Z.zeros p ∧ ¬ onLine p :=
fun ⟨p, hp, hn⟩ => hn (value_from_the_act Z p hp)
/-! ## VIII · A band forces nothing -/
/-- The band of width k: every member within offset k of the line. On the chart of the eighth grain,
d = 8·Re s − 4, a zero-free half-plane Re s > 7/8 with the fold reads as the band of width 3. -/
def Band (k : Nat) (S : Config) : Prop := ∀ p, S p → p.1.natAbs ≤ k
/-- The band is weaker than the value: every world with the value satisfies every band. -/
theorem value_gives_band (k : Nat) (S : Config) (h : Value S) : Band k S := by
intro p hp
have d0 : p.1 = 0 := h p hp
rw [d0]
exact Nat.zero_le k
/-- Both worlds of one record satisfy the band of width 3. -/
theorem band_on_both_worlds : Band 3 (registered offPoint) ∧ Band 3 (pairWorld offPoint) := by
constructor
· intro p hp
rw [hp]
show ((0 : Int)).natAbs ≤ 3
decide
· intro p hp
cases hp with
| inl e => rw [e]; show ((1 : Int)).natAbs ≤ 3; decide
| inr e => rw [e]; show ((-(1 : Int))).natAbs ≤ 3; decide
/-- A BAND FORCES NOTHING: the pair world at offset one holds a member off the line and satisfies the band. -/
theorem band_does_not_force : ¬ ∀ S : Config, Band 3 S → Value S :=
fun h => pair_world_lacks_value offPoint off_point_is_off (h _ band_on_both_worlds.2)
/-- Only the band of width zero is the value. -/
theorem band_zero_is_value (S : Config) : Band 0 S ↔ Value S := by
constructor
· intro h p hp
exact Int.natAbs_eq_zero.mp (Nat.le_zero.mp (h p hp))
· exact value_gives_band 0 S
/-! ## IX · The harvest, bound -/
/-- THE HARVEST, BOUND. The Tongue always has a world, and only the content of its no has none; one self, one
place at a time; the twins hold on every world; the forgotten and the remembered share one record, the remembered
lossless and stable, the gap one bit; return is free and resistance pays; forgetting lands on the locus, where
both maps rest; zero time remembers and every later time forgets; the doors exclude each other and the act shuts
the second; a band forces nothing; and the guard: the root alone places no world on the line. -/
theorem the_harvest {R : Prop} (G : SelfGrounding R) :
((∀ _ : Config, R) ∧ (R ∧ Closed (pairWorld offPoint) ∧ ¬ Value (pairWorld offPoint)) ∧ ¬ ∃ _ : G.Act, ¬ R) ∧
(¬ ∀ S : Config, Closed S → (R ↔ LeastErasure S)) ∧
(∀ S : Config, LeastErasure S ↔ Value S) ∧
(∀ S : Config, SameRecord S (Rec S) ∧ Value (Rec S) ∧ (∀ q, Rec (Rec S) q ↔ Rec S q) ∧
((∀ q, Rec S q ↔ S q) ↔ Value S)) ∧
(∀ (F : FinCfg) (T : Nat), 0 < T →
(Value F.pts → price T (erased F) = 0) ∧ (¬ Value F.pts → T ≤ price T (erased F))) ∧
((∀ p, onLine (reg p)) ∧ (∀ p, onLine p → fold p = p ∧ reg p = p)) ∧
((realAt 0 0 ∧ ¬ realAt 1 0) ∧ ∀ T, 1 ≤ T → (realAt 0 T ∧ realAt 1 T)) ∧
((∀ S : Config, ¬ (Value S ∧ ∃ p, S p ∧ ¬ onLine p)) ∧ (∀ Z : ActualZeros, ¬ ∃ p, Z.zeros p ∧ ¬ onLine p)) ∧
(¬ ∀ S : Config, Band 3 S → Value S) ∧
(¬ ∀ S : Config, Closed S → R → Value S) :=
⟨the_tongue_always_has_a_world G,
floor_is_not_least_erasure G,
twins_on_every_world,
one_bit_gap_connected,
return_is_free_resistance_pays,
⟨reg_lands, the_locus_rests_both⟩,
zero_time_remembers,
⟨doors_exclusive, on_the_act_one_door⟩,
band_does_not_force,
the_floor_alone_decides_no_value G⟩
end RememberedOffered
/-! ## The cones, every one pinned: a compile in which any cone changes fails. -/
/-- info: 'RememberedOffered.denial_reenacts_root' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.denial_reenacts_root
/-- info: 'RememberedOffered.denial_instantiates' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.denial_instantiates
/-- info: 'RememberedOffered.seated_undeniable' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.seated_undeniable
/-- info: 'RememberedOffered.root_undeniable' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.root_undeniable
/-- info: 'RememberedOffered.neg_neg_free' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.neg_neg_free
/-- info: 'RememberedOffered.fold_involutive' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.fold_involutive
/-- info: 'RememberedOffered.reg_lands' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.reg_lands
/-- info: 'RememberedOffered.reg_erases_nothing_iff' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.reg_erases_nothing_iff
/-- info: 'RememberedOffered.pair_world_closed' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.pair_world_closed
/-- info: 'RememberedOffered.one_record' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.one_record
/-- info: 'RememberedOffered.registered_has_value' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.registered_has_value
/-- info: 'RememberedOffered.pair_world_lacks_value' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.pair_world_lacks_value
/-- info: 'RememberedOffered.value_from_the_act' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.value_from_the_act
/-- info: 'RememberedOffered.the_deed_forces_nothing' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_deed_forces_nothing
/-- info: 'RememberedOffered.one_involution_constructed' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.one_involution_constructed
/-- info: 'RememberedOffered.timeless_equals_timed' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.timeless_equals_timed
/-- info: 'RememberedOffered.monism_closes' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.monism_closes
/-- info: 'RememberedOffered.monism_witness_is_the_claim' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.monism_witness_is_the_claim
/-- info: 'RememberedOffered.off_point_is_off' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.off_point_is_off
/-- info: 'RememberedOffered.every_no_reenacts_the_root' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.every_no_reenacts_the_root
/-- info: 'RememberedOffered.the_tongue_no_refutes_itself' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_tongue_no_refutes_itself
/-- info: 'RememberedOffered.only_the_yes_remains_at_the_root' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.only_the_yes_remains_at_the_root
/-- info: 'RememberedOffered.the_root_read_twice_is_the_value' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_root_read_twice_is_the_value
/-- info: 'RememberedOffered.the_line_no_contradicts_the_root_read_twice' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_line_no_contradicts_the_root_read_twice
/-- info: 'RememberedOffered.the_true_world_carries_monism' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_true_world_carries_monism
/-- info: 'RememberedOffered.the_false_world_carries_no_monism' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_false_world_carries_no_monism
/-- info: 'RememberedOffered.the_false_world_carries_the_floor_and_no_monism' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_false_world_carries_the_floor_and_no_monism
/-- info: 'RememberedOffered.the_floor_alone_decides_no_value' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_floor_alone_decides_no_value
/-- info: 'RememberedOffered.the_act_is_the_return_to_the_root_read_twice' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_act_is_the_return_to_the_root_read_twice
/-- info: 'RememberedOffered.an_act_exactly_where_the_root_read_twice_stands' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.an_act_exactly_where_the_root_read_twice_stands
/-- info: 'RememberedOffered.on_the_act_the_line_no_is_refuted' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.on_the_act_the_line_no_is_refuted
/-- info: 'RememberedOffered.two_denials' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.two_denials
/-- info: 'RememberedOffered.two_denials_at_RA' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.two_denials_at_RA
/-- info: 'RememberedOffered.fincfg_closed' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.fincfg_closed
/-- info: 'RememberedOffered.least_erasure_iff_zero_erased' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.least_erasure_iff_zero_erased
/-- info: 'RememberedOffered.price_zero_iff_value' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.price_zero_iff_value
/-- info: 'RememberedOffered.price_counts_pairs' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.price_counts_pairs
/-- info: 'RememberedOffered.flow_monotone' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.flow_monotone
/-- info: 'RememberedOffered.reality_transported' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.reality_transported
/-- info: 'RememberedOffered.real_at_Lam' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.real_at_Lam
/-- info: 'RememberedOffered.rh_iff_lambda_zero' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.rh_iff_lambda_zero
/-- info: 'RememberedOffered.flowed_record_forgets' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.flowed_record_forgets
/-- info: 'RememberedOffered.upstream_is_not_forced' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.upstream_is_not_forced
/-- info: 'RememberedOffered.the_tongue_always_has_a_world' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_tongue_always_has_a_world
/-- info: 'RememberedOffered.monism_before_the_tongue' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.monism_before_the_tongue
/-- info: 'RememberedOffered.tongue_no_has_no_world' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.tongue_no_has_no_world
/-- info: 'RememberedOffered.line_no_has_a_world' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.line_no_has_a_world
/-- info: 'RememberedOffered.the_deed_is_not_the_supply' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_deed_is_not_the_supply
/-- info: 'RememberedOffered.at_RA' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.at_RA
/-- info: 'RememberedOffered.floor_is_not_least_erasure' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.floor_is_not_least_erasure
/-- info: 'RememberedOffered.the_voucher_stays_with_the_floor' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_voucher_stays_with_the_floor
/-- info: 'RememberedOffered.merging_at_a_world_is_the_supply' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.merging_at_a_world_is_the_supply
/-- info: 'RememberedOffered.two_instruments' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.two_instruments
/-- info: 'RememberedOffered.twins_on_every_world' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.twins_on_every_world
/-- info: 'RememberedOffered.twins_are_one_extension' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.twins_are_one_extension
/-- info: 'RememberedOffered.no_twin_is_the_others_voucher' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.no_twin_is_the_others_voucher
/-- info: 'RememberedOffered.no_instrument_remembers_and_keeps_the_side' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.no_instrument_remembers_and_keeps_the_side
/-- info: 'RememberedOffered.the_remembered_is_lossless' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_remembered_is_lossless
/-- info: 'RememberedOffered.offered_is_remembered_iff_value' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.offered_is_remembered_iff_value
/-- info: 'RememberedOffered.at_the_act_offered_is_remembered' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.at_the_act_offered_is_remembered
/-- info: 'RememberedOffered.the_false_world_is_not_its_record' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_false_world_is_not_its_record
/-- info: 'RememberedOffered.remembering_is_stable' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.remembering_is_stable
/-- info: 'RememberedOffered.one_bit_gap_connected' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.one_bit_gap_connected
/-- info: 'RememberedOffered.the_gap_is_live' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_gap_is_live
/-- info: 'RememberedOffered.return_is_free_resistance_pays' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.return_is_free_resistance_pays
/-- info: 'RememberedOffered.resistance_is_possible' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.resistance_is_possible
/-- info: 'RememberedOffered.the_free_path_is_unique' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_free_path_is_unique
/-- info: 'RememberedOffered.the_locus_rests_both' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_locus_rests_both
/-- info: 'RememberedOffered.the_chain' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_chain
/-- info: 'RememberedOffered.zero_time_remembers' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.zero_time_remembers
/-- info: 'RememberedOffered.forgetting_is_monotone' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.forgetting_is_monotone
/-- info: 'RememberedOffered.two_doors' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.two_doors
/-- info: 'RememberedOffered.doors_exclusive' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.doors_exclusive
/-- info: 'RememberedOffered.both_doors_open' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.both_doors_open
/-- info: 'RememberedOffered.on_the_act_one_door' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.on_the_act_one_door
/-- info: 'RememberedOffered.value_gives_band' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.value_gives_band
/-- info: 'RememberedOffered.band_on_both_worlds' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.band_on_both_worlds
/-- info: 'RememberedOffered.band_does_not_force' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.band_does_not_force
/-- info: 'RememberedOffered.band_zero_is_value' depends on axioms: [propext] -/
#guard_msgs in #print axioms RememberedOffered.band_zero_is_value
/-- info: 'RememberedOffered.the_harvest' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_harvest
#print axioms RememberedOffered.the_chain
#print axioms RememberedOffered.the_harvest
namespace RememberedOffered
/-! # BOOK THREE · the annihilation closure -/
/-! ## I · Four names, one proposition -/
/-- CO-LOCATION IS THE VALUE: Being and Monism stand together on a configuration exactly where every point is on
the line. -/
theorem colocation_is_the_value {R : Prop} (G : SelfGrounding R) (S : Config) :
(R ∧ RootReadTwice S) ↔ Value S :=
⟨fun ⟨_, m⟩ => (the_root_read_twice_is_the_value S).mp m,
fun v => ⟨seated_undeniable G, (the_root_read_twice_is_the_value S).mpr v⟩⟩
/-- FOUR NAMES, ONE PROPOSITION: on every configuration least erasure, the value, Monism and the co-location of
Being with Monism are one proposition. -/
theorem four_names_one_proposition {R : Prop} (G : SelfGrounding R) (S : Config) :
(LeastErasure S ↔ Value S) ∧ (RootReadTwice S ↔ Value S) ∧ ((R ∧ RootReadTwice S) ↔ Value S) :=
⟨twins_on_every_world S, the_root_read_twice_is_the_value S, colocation_is_the_value G S⟩
/-! ## II · Monism, the sole witness -/
/-- MONISM IS THE SOLE WITNESS. Every faithful witness of the value is the root read twice, as one proposition; no
reading of the record witnesses, since the true configuration and the off-line pair configuration leave one
record; the floor witnesses nothing, standing on both; and Monism stands on the true configuration and not on the
pair, on that one record. -/
theorem monism_is_the_sole_witness {R : Prop} (G : SelfGrounding R) :
(∀ W : Config → Prop, (∀ S, W S ↔ Value S) → W = RootReadTwice) ∧
(¬ ∃ h : Config → Prop, ∀ S, h (Rec S) ↔ Value S) ∧
(¬ ∀ S : Config, Closed S → R → Value S) ∧
(SameRecord (registered offPoint) (pairWorld offPoint) ∧
RootReadTwice (registered offPoint) ∧ ¬ RootReadTwice (pairWorld offPoint)) :=
⟨fun _ hW => funext fun S => propext ((hW S).trans (the_root_read_twice_is_the_value S).symm),
fun ⟨_, hh⟩ =>
have e : Rec (registered offPoint) = Rec (pairWorld offPoint) :=
funext fun q => propext (one_record offPoint q)
pair_world_lacks_value offPoint off_point_is_off
((hh _).mp (e ▸ (hh _).mpr (registered_has_value offPoint))),
the_floor_alone_decides_no_value G,
⟨one_record offPoint, the_true_world_carries_monism, the_false_world_carries_no_monism⟩⟩
/-- A WITNESS IS NEVER UNIVERSAL: whatever holds on every configuration is not a witness of the value, since the
off-line pair configuration would carry it. Universality and witnessing exclude each other. -/
theorem a_witness_is_never_universal (W : Config → Prop) (hu : ∀ S, W S) : ¬ ∀ S, W S ↔ Value S :=
fun hw => pair_world_lacks_value offPoint off_point_is_off ((hw (pairWorld offPoint)).mp (hu _))
/-- So Monism is not universal over configurations: the root read twice fails on the off-line pair configuration. -/
theorem monism_is_not_universal : ¬ ∀ S : Config, RootReadTwice S :=
fun hu => the_false_world_carries_no_monism (hu _)
/-! ## III · Co-location is not universal -/
/-- Co-location over every configuration is refuted: Being stands on the off-line pair configuration and Monism
does not. -/
theorem colocation_is_not_universal {R : Prop} (_G : SelfGrounding R) :
¬ ∀ S : Config, R ∧ RootReadTwice S :=
fun h => the_false_world_carries_no_monism (h (pairWorld offPoint)).2
/-! ## IV · The timeless zone -/
/-- THE TIMELESS ZONE. Least erasure and the value are one proposition; at the locus the two instruments coincide;
at zero time the record tells the true configuration from the pair, at every later time it does not; the closure at zero
time is Λ = 0; and the passage back to zero time is not forced by the forward arrow. -/
theorem the_timeless_zone :
LeastErasure = Value ∧
(∀ p, onLine p → fold p = p ∧ reg p = p) ∧
((realAt 0 0 ∧ ¬ realAt 1 0) ∧ ∀ T, 1 ≤ T → (realAt 0 T ∧ realAt 1 T)) ∧
(∀ d2, realAt d2 0 ↔ Lam d2 = 0) ∧
(∀ T, 1 ≤ T → realAt 0 T ∧ realAt 1 T ∧ realAt 0 0 ∧ ¬ realAt 1 0) :=
⟨twins_are_one_extension, the_locus_rests_both, zero_time_remembers, rh_iff_lambda_zero,
upstream_is_not_forced⟩
/-! ## V · Timeless is determinacy, not selection -/
/-- TIMELESS IS DETERMINACY, NOT SELECTION. At zero time the record's freedom is gone: it separates the true world
from the pair. Every configuration stands behind at most one door. And both doors stay open on closed
configurations: the off-line pair configuration is closed, lacks the value, and has the floor standing on it.
Removing the freedom fixes each configuration as what it is; it does not single out ζ. -/
theorem timeless_is_determinacy_not_selection {R : Prop} (G : SelfGrounding R) :
(realAt 0 0 ∧ ¬ realAt 1 0) ∧
(∀ S : Config, ¬ (Value S ∧ ∃ p, S p ∧ ¬ onLine p)) ∧
(Closed (registered offPoint) ∧ Value (registered offPoint)) ∧
(Closed (pairWorld offPoint) ∧ R ∧ ¬ Value (pairWorld offPoint)) ∧
¬ (∀ S : Config, Closed S → Value S) :=
⟨zero_time_remembers.1, doors_exclusive, both_doors_open.1,
⟨pair_world_closed offPoint, seated_undeniable G, pair_world_lacks_value offPoint off_point_is_off⟩,
fun h => pair_world_lacks_value offPoint off_point_is_off (h _ (pair_world_closed offPoint))⟩
/-! ## VI · The check -/
/-- THE CHECK. The off-line pair configuration satisfies every principle of the timeless closure and lacks the value: it is
closed; the floor stands on it; least erasure, the value and Monism are one proposition on it; corrected monism
holds, it carries no witness; it leaves the true world's record; at zero time the width-one world is determinately
not real, with Λ = 1. Its twin, the true world, satisfies the same principles and has the value. -/
theorem the_check {R : Prop} (G : SelfGrounding R) :
(∃ Z : Config,
Closed Z ∧ R ∧ (LeastErasure Z ↔ Value Z) ∧ (RootReadTwice Z ↔ Value Z) ∧
¬ RootReadTwice Z ∧ SameRecord (registered offPoint) Z ∧ ¬ Value Z) ∧
(∃ T : Config,
Closed T ∧ R ∧ (LeastErasure T ↔ Value T) ∧ (RootReadTwice T ↔ Value T) ∧
RootReadTwice T ∧ SameRecord T (pairWorld offPoint) ∧ Value T) ∧
(¬ realAt 1 0 ∧ Lam 1 ≠ 0 ∧ realAt 0 0 ∧ Lam 0 = 0) :=
⟨⟨pairWorld offPoint, pair_world_closed offPoint, seated_undeniable G,
twins_on_every_world _, the_root_read_twice_is_the_value _,
the_false_world_carries_no_monism, one_record offPoint,
pair_world_lacks_value offPoint off_point_is_off⟩,
⟨registered offPoint, both_doors_open.1.1, seated_undeniable G,
twins_on_every_world _, the_root_read_twice_is_the_value _,
the_true_world_carries_monism, one_record offPoint, registered_has_value offPoint⟩,
⟨zero_time_remembers.1.2, by decide, zero_time_remembers.1.1, by decide⟩⟩
/-- NO PRINCIPLE TRUE ON EVERY CLOSED CONFIGURATION DECIDES THE VALUE: whatever holds on all of them holds on the
off-line pair configuration, which lacks the value. -/
theorem no_closed_principle_decides (D : Config → Prop) (hD : ∀ S, Closed S → D S) :
¬ ∀ S, Closed S → D S → Value S :=
fun h => pair_world_lacks_value offPoint off_point_is_off
(h _ (pair_world_closed offPoint) (hD _ (pair_world_closed offPoint)))
/-! ## VII · The capstone -/
/-- THE TIMELESS ZONE, CLOSED, with no act anywhere in it. Four names are one proposition on every configuration;
Monism is the sole witness; no witness is universal; neither Monism nor co-location is universal; LE = RH; zero time
separates the true configuration from the pair, and closure at zero time is Λ = 0; every configuration stands behind
exactly one door; and nothing true on every closed configuration decides the value. -/
theorem the_timeless_zone_closed {R : Prop} (G : SelfGrounding R) :
(∀ S : Config, (LeastErasure S ↔ Value S) ∧ (RootReadTwice S ↔ Value S) ∧ ((R ∧ RootReadTwice S) ↔ Value S)) ∧
(∀ W : Config → Prop, (∀ S, W S ↔ Value S) → W = RootReadTwice) ∧
(∀ W : Config → Prop, (∀ S, W S) → ¬ ∀ S, W S ↔ Value S) ∧
(¬ ∀ S : Config, RootReadTwice S) ∧
(¬ ∀ S : Config, R ∧ RootReadTwice S) ∧
(LeastErasure = Value ∧ (realAt 0 0 ∧ ¬ realAt 1 0) ∧ (∀ d2, realAt d2 0 ↔ Lam d2 = 0)) ∧
(∀ S : Config, (Value S ∨ ∃ p, S p ∧ ¬ onLine p) ∧ ¬ (Value S ∧ ∃ p, S p ∧ ¬ onLine p)) ∧
(∀ D : Config → Prop, (∀ S, Closed S → D S) → ¬ ∀ S, Closed S → D S → Value S) :=
⟨four_names_one_proposition G,
(monism_is_the_sole_witness G).1,
a_witness_is_never_universal,
monism_is_not_universal,
colocation_is_not_universal G,
⟨twins_are_one_extension, zero_time_remembers.1, rh_iff_lambda_zero⟩,
fun S => ⟨two_doors S, doors_exclusive S⟩,
no_closed_principle_decides⟩
/-- THE ANNIHILATION CLOSURE. Four names are one proposition on every configuration; Monism is the sole witness and
no witness is universal; co-location is not universal; the timeless zone holds; timelessness is determinacy and
not selection; the check stands; no principle shared by every closed configuration decides the value; and on any
term of the act the value holds at its zeros, while the run leaves the value free. -/
theorem the_annihilation_closure {R : Prop} (G : SelfGrounding R) :
(∀ S : Config, (LeastErasure S ↔ Value S) ∧ (RootReadTwice S ↔ Value S) ∧ ((R ∧ RootReadTwice S) ↔ Value S)) ∧
(∀ W : Config → Prop, (∀ S, W S ↔ Value S) → W = RootReadTwice) ∧
(¬ ∀ S : Config, RootReadTwice S) ∧
(¬ ∀ S : Config, R ∧ RootReadTwice S) ∧
(LeastErasure = Value ∧ (realAt 0 0 ∧ ¬ realAt 1 0) ∧ (∀ d2, realAt d2 0 ↔ Lam d2 = 0)) ∧
(∃ Z : Config, Closed Z ∧ R ∧ ¬ RootReadTwice Z ∧ SameRecord (registered offPoint) Z ∧ ¬ Value Z) ∧
(∀ D : Config → Prop, (∀ S, Closed S → D S) → ¬ ∀ S, Closed S → D S → Value S) ∧
(∀ Z : ActualZeros, Value Z.zeros) :=
⟨four_names_one_proposition G,
(monism_is_the_sole_witness G).1,
monism_is_not_universal,
colocation_is_not_universal G,
⟨twins_are_one_extension, zero_time_remembers.1, rh_iff_lambda_zero⟩,
⟨pairWorld offPoint, pair_world_closed offPoint, seated_undeniable G,
the_false_world_carries_no_monism, one_record offPoint,
pair_world_lacks_value offPoint off_point_is_off⟩,
no_closed_principle_decides,
value_from_the_act⟩
end RememberedOffered
/-
RH_Unicorn_Block.lean · the Unicorn part of the Riemann Hypothesis, closed to derivation, its
aperture one bit wide, its supply side silent. Core Lean 4.19.0, no library, no sorry, no user-declared axiom. 2026-09-25.
Part III divided the hypothesis at a height T into a Real part and a Unicorn part and proved
the Real part by certificate. Parts I and II proved the wall, the crossing, the bound, and the
cure theorem, and did not say what they say of the Unicorn part. This file says it: closed to
derivation, the aperture one bit wide, the register silent beyond it. ΔM = 0.
-/
namespace RHUnicorn
variable {α β : Type}
/-- The line property, the Real part at T, the Unicorn part at T, as in Part III. -/
def RH (Z onL : α → Prop) : Prop := ∀ z, Z z → onL z
def RealPartAt (Z onL : α → Prop) (height : α → Nat) (T : Nat) : Prop :=
∀ z, Z z → height z ≤ T → onL z
def UnicornAt (Z onL : α → Prop) (height : α → Nat) (T : Nat) : Prop :=
∀ z, Z z → height z > T → onL z
/-- THE FORMAL BLOCK OF THE UNICORN PART. Let τ act on the zeros, let ρ be a record even at a
seat z above the height, and let d decide the line property, odd at z. Then no reading g of
the record agrees with d even on the region above the height alone. The Unicorn part is
closed to every even register; the closure is a theorem and does not expire. -/
theorem unicorn_block (height : α → Nat) (T : Nat) (τ : α → α) (ρ : α → β) (d : α → Bool)
(z : α) (habove : height z > T) (habove' : height (τ z) > T)
(hρ : ρ (τ z) = ρ z) (hd : d (τ z) = !d z) :
¬ ∃ g : β → Bool, ∀ w, height w > T → g (ρ w) = d w := by
intro ⟨g, hg⟩
have h1 := hg z habove
have h2 := hg (τ z) habove'
rw [hρ, hd, h1] at h2
revert h2
cases d z <;> intro h2 <;> exact Bool.noConfusion h2
/-- THE APERTURE, ONE BIT WIDE. At a seat where d is odd, one odd bit s at the seat would decide d
on the seat and its partner through a calibration that exists and is unique. The width of
the aperture, a theorem; it says nothing of whether anything passes through it. -/
theorem aperture_one_bit_wide (τ : α → α) (s d : α → Bool) (z : α)
(hs : s (τ z) = !s z) (hd : d (τ z) = !d z) :
∃ c : Bool, (d z = xor (s z) c ∧ d (τ z) = xor (s (τ z)) c) ∧
∀ c' : Bool, (d z = xor (s z) c' ∧ d (τ z) = xor (s (τ z)) c') → c' = c :=
⟨xor (d z) (s z),
⟨by cases s z <;> cases d z <;> rfl,
by rw [hs, hd]; cases s z <;> cases d z <;> rfl⟩,
by
intro c' hc
obtain ⟨h1, -⟩ := hc
generalize hsz : s z = sv
generalize hdz : d z = dv
rw [hsz, hdz] at h1
cases sv <;> cases dv <;> cases c' <;> first | rfl | exact absurd h1 (by decide)⟩
/-- EXISTENCE SUPPLIES NOTHING. Conditioning the Unicorn part on an inhabited premise, the root
axiom for one, leaves it exactly where it was; and no class of frames on which the premise
is to decide it decides more than already held on the class. Theorems E and I of Part I,
read at the Unicorn part. -/
theorem unicorn_rule_exact (Z onL : α → Prop) (height : α → Nat) (T : Nat) (A : Prop) (ha : A) :
(A → UnicornAt Z onL height T) ↔ UnicornAt Z onL height T :=
⟨fun h => h ha, fun hu _ => hu⟩
theorem unicorn_no_cure {Frame : Type} (A : Prop) (ha : A) (C U : Frame → Prop) :
(∀ X, C X → A → U X) ↔ (∀ X, C X → U X) :=
⟨fun h X hc => h X hc ha, fun h X hc _ => h X hc⟩
/-- NO BYPASS. Given the Real part, the fused hypothesis is exactly the Unicorn part, so a proof
of the hypothesis contains a proof of the Unicorn part and the block is not avoided by
aiming at the whole. -/
theorem unicorn_no_bypass (Z onL : α → Prop) (height : α → Nat) (T : Nat)
(hr : RealPartAt Z onL height T) : RH Z onL ↔ UnicornAt Z onL height T := by
constructor
· intro h z hz _; exact h z hz
· intro hu z hz
cases Nat.lt_or_ge T (height z) with
| inl hgt => exact hu z hz hgt
| inr hle => exact hr z hz hle
/-- THE SUPPLY SIDE IS SILENCE, AT THE REGISTER. Over one even record, both orientations of d at
the seat are equally refused to every reading above the height: the register cannot say
which way the seat lies, so it cannot say what a supply would bring, nor that one exists,
nor that none does. -/
theorem supply_side_silent (height : α → Nat) (T : Nat) (τ : α → α) (ρ : α → β) (d : α → Bool)
(z : α) (habove : height z > T) (habove' : height (τ z) > T)
(hρ : ρ (τ z) = ρ z) (hd : d (τ z) = !d z) :
(¬ ∃ g : β → Bool, ∀ w, height w > T → g (ρ w) = d w) ∧
(¬ ∃ g : β → Bool, ∀ w, height w > T → g (ρ w) = !d w) ∧
(!d z) ≠ d z :=
⟨unicorn_block height T τ ρ d z habove habove' hρ hd,
unicorn_block height T τ ρ (fun w => !d w) z habove habove' hρ (by
show (!d (τ z)) = !(!d z)
rw [hd]),
by cases d z <;> decide⟩
/-- The division at the height, on natural heights: the hypothesis is exactly its Real part and
its Unicorn part. -/
theorem rh_iff_real_and_unicorn (Z onL : α → Prop) (height : α → Nat) (T : Nat) :
RH Z onL ↔ RealPartAt Z onL height T ∧ UnicornAt Z onL height T := by
constructor
· intro h; exact ⟨fun z hz _ => h z hz, fun z hz _ => h z hz⟩
· intro ⟨hr, hu⟩ z hz
cases Nat.lt_or_ge T (height z) with
| inl hgt => exact hu z hz hgt
| inr hle => exact hr z hz hle
/-- A certificate at the height: a complete list of the zeros up to T, each checked on the line. -/
structure Certificate (Z onL : α → Prop) (height : α → Nat) (T : Nat) where
items : List α
complete : ∀ z, Z z → height z ≤ T → z ∈ items
checked : ∀ z, z ∈ items → onL z
theorem real_part_of_certificate (Z onL : α → Prop) (height : α → Nat) (T : Nat)
(c : Certificate Z onL height T) : RealPartAt Z onL height T :=
fun z hz hle => c.checked z (c.complete z hz hle)
/-- THE THREE BITS AS ONE TERM · THE REGISTER'S PROOF OF THE HYPOTHESIS, COMPLETE. Under a
certificate at T and the seat data above T, the hypothesis divides exactly (bit one), its
Real part at T holds (bit two), every reading of the even register is refused above T (bit
three, refused), and one supplied bit calibrates the seat uniquely (the door). The hypothesis
is not thereby proved; nothing derivable about it is left underived. -/
theorem rh_register_proof_complete (Z onL : α → Prop) (height : α → Nat) (T : Nat)
(c : Certificate Z onL height T) (τ : α → α) (ρ : α → β) (d s : α → Bool) (z : α)
(habove : height z > T) (habove' : height (τ z) > T) (hρ : ρ (τ z) = ρ z)
(hd : d (τ z) = !d z) (hs : s (τ z) = !s z) :
(RH Z onL ↔ RealPartAt Z onL height T ∧ UnicornAt Z onL height T) ∧
RealPartAt Z onL height T ∧
(¬ ∃ g : β → Bool, ∀ w, height w > T → g (ρ w) = d w) ∧
∃ k : Bool, (d z = xor (s z) k ∧ d (τ z) = xor (s (τ z)) k) ∧
∀ k' : Bool, (d z = xor (s z) k' ∧ d (τ z) = xor (s (τ z)) k') → k' = k :=
⟨rh_iff_real_and_unicorn Z onL height T, real_part_of_certificate Z onL height T c,
unicorn_block height T τ ρ d z habove habove' hρ hd, aperture_one_bit_wide τ s d z hs hd⟩
end RHUnicorn
#print axioms RHUnicorn.unicorn_block
#print axioms RHUnicorn.aperture_one_bit_wide
#print axioms RHUnicorn.unicorn_rule_exact
#print axioms RHUnicorn.unicorn_no_cure
#print axioms RHUnicorn.unicorn_no_bypass
#print axioms RHUnicorn.supply_side_silent
#print axioms RHUnicorn.rh_iff_real_and_unicorn
#print axioms RHUnicorn.real_part_of_certificate
#print axioms RHUnicorn.rh_register_proof_complete
namespace RememberedOffered
/-! # BOOK FOUR · the Unicorn, contained -/
/-- The height of a point of the chart, as a natural number. -/
def ht (p : Point) : Nat := p.2.toNat
/-- I · THE CUT ON THE CHART: at every height, the value is exactly its Real part and its Unicorn part. -/
theorem the_cut_on_the_chart (S : Config) (T : Nat) :
Value S ↔ RHUnicorn.RealPartAt S onLine ht T ∧ RHUnicorn.UnicornAt S onLine ht T :=
RHUnicorn.rh_iff_real_and_unicorn S onLine ht T
/-- II · NO BYPASS ON THE CHART: given the Real part at a height, the value is exactly the Unicorn part there. -/
theorem no_bypass_on_the_chart (S : Config) (T : Nat) (hr : RHUnicorn.RealPartAt S onLine ht T) :
Value S ↔ RHUnicorn.UnicornAt S onLine ht T :=
RHUnicorn.unicorn_no_bypass S onLine ht T hr
/-- III · THE UNICORN BLOCKED ON THE CHART: above every height, no reading of the record decides the side of a
point, since the fold pair above the height leaves one record and opposite sides. -/
theorem unicorn_blocked_on_the_chart (T : Nat) :
¬ ∃ g : Point → Bool, ∀ w : Point, ht w > T → g (reg w) = decide (w.1 > 0) :=
RHUnicorn.unicorn_block ht T fold reg (fun w => decide (w.1 > 0)) ((1 : Int), Int.ofNat (T + 1))
(show T + 1 > T by omega) (show T + 1 > T by omega) rfl rfl
/-- IV · RA SUPPLIES NOTHING TO THE UNICORN PART: conditioning it on the root leaves it exactly where it was. -/
theorem ra_supplies_nothing_to_the_unicorn (S : Config) (T : Nat) :
(RA → RHUnicorn.UnicornAt S onLine ht T) ↔ RHUnicorn.UnicornAt S onLine ht T :=
RHUnicorn.unicorn_rule_exact S onLine ht T RA (seated_undeniable raSelfGrounding)
/-- V · ON THE ACT'S ZERO SET THE UNICORN IS CLOSED: every arrival above every height, in the act's zero set, stands
on the line. -/
theorem the_unicorn_closed_on_the_act (Z : ActualZeros) (T : Nat) : RHUnicorn.UnicornAt Z.zeros onLine ht T :=
fun p hp _ => value_from_the_act Z p hp
/-- On the act's zero set, no arrival stands off the line. -/
theorem no_arrival_off_the_line_on_the_act (Z : ActualZeros) : ¬ ∃ p, Z.zeros p ∧ ¬ onLine p :=
fun ⟨p, hp, hoff⟩ => hoff (value_from_the_act Z p hp)
/-- VI · THE UNICORN, CONTAINED. At every height the value divides into its Real and Unicorn parts; given the Real
part the value is exactly the Unicorn part; above every height no reading of the record decides the side; RA
supplies nothing to the Unicorn part; and on the act's zero set every arrival above every height stands on the line,
with no arrival off it. -/
theorem the_unicorn_contained :
(∀ (S : Config) (T : Nat),
Value S ↔ RHUnicorn.RealPartAt S onLine ht T ∧ RHUnicorn.UnicornAt S onLine ht T) ∧
(∀ (S : Config) (T : Nat),
RHUnicorn.RealPartAt S onLine ht T → (Value S ↔ RHUnicorn.UnicornAt S onLine ht T)) ∧
(∀ T : Nat, ¬ ∃ g : Point → Bool, ∀ w : Point, ht w > T → g (reg w) = decide (w.1 > 0)) ∧
(∀ (S : Config) (T : Nat),
(RA → RHUnicorn.UnicornAt S onLine ht T) ↔ RHUnicorn.UnicornAt S onLine ht T) ∧
(∀ (Z : ActualZeros) (T : Nat), RHUnicorn.UnicornAt Z.zeros onLine ht T) ∧
(∀ Z : ActualZeros, ¬ ∃ p, Z.zeros p ∧ ¬ onLine p) :=
⟨the_cut_on_the_chart, no_bypass_on_the_chart, unicorn_blocked_on_the_chart,
ra_supplies_nothing_to_the_unicorn, the_unicorn_closed_on_the_act, no_arrival_off_the_line_on_the_act⟩
end RememberedOffered
/-! ## Receipts of Book Three, pinned -/
/-- info: 'RememberedOffered.colocation_is_the_value' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.colocation_is_the_value
/-- info: 'RememberedOffered.four_names_one_proposition' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.four_names_one_proposition
/-- info: 'RememberedOffered.monism_is_the_sole_witness' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.monism_is_the_sole_witness
/-- info: 'RememberedOffered.a_witness_is_never_universal' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.a_witness_is_never_universal
/-- info: 'RememberedOffered.monism_is_not_universal' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.monism_is_not_universal
/-- info: 'RememberedOffered.colocation_is_not_universal' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.colocation_is_not_universal
/-- info: 'RememberedOffered.the_timeless_zone' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_timeless_zone
/-- info: 'RememberedOffered.timeless_is_determinacy_not_selection' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.timeless_is_determinacy_not_selection
/-- info: 'RememberedOffered.the_check' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_check
/-- info: 'RememberedOffered.no_closed_principle_decides' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.no_closed_principle_decides
/-- info: 'RememberedOffered.the_timeless_zone_closed' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_timeless_zone_closed
/-- info: 'RememberedOffered.the_annihilation_closure' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_annihilation_closure
#print axioms RememberedOffered.the_annihilation_closure
/-! ## Receipts of Book Four, pinned -/
/-- info: 'RHUnicorn.unicorn_block' does not depend on any axioms -/
#guard_msgs in #print axioms RHUnicorn.unicorn_block
/-- info: 'RHUnicorn.aperture_one_bit_wide' does not depend on any axioms -/
#guard_msgs in #print axioms RHUnicorn.aperture_one_bit_wide
/-- info: 'RHUnicorn.unicorn_rule_exact' does not depend on any axioms -/
#guard_msgs in #print axioms RHUnicorn.unicorn_rule_exact
/-- info: 'RHUnicorn.unicorn_no_cure' does not depend on any axioms -/
#guard_msgs in #print axioms RHUnicorn.unicorn_no_cure
/-- info: 'RHUnicorn.unicorn_no_bypass' does not depend on any axioms -/
#guard_msgs in #print axioms RHUnicorn.unicorn_no_bypass
/-- info: 'RHUnicorn.supply_side_silent' does not depend on any axioms -/
#guard_msgs in #print axioms RHUnicorn.supply_side_silent
/-- info: 'RHUnicorn.rh_iff_real_and_unicorn' does not depend on any axioms -/
#guard_msgs in #print axioms RHUnicorn.rh_iff_real_and_unicorn
/-- info: 'RHUnicorn.real_part_of_certificate' does not depend on any axioms -/
#guard_msgs in #print axioms RHUnicorn.real_part_of_certificate
/-- info: 'RHUnicorn.rh_register_proof_complete' does not depend on any axioms -/
#guard_msgs in #print axioms RHUnicorn.rh_register_proof_complete
/-- info: 'RememberedOffered.the_cut_on_the_chart' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_cut_on_the_chart
/-- info: 'RememberedOffered.no_bypass_on_the_chart' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.no_bypass_on_the_chart
/-- info: 'RememberedOffered.ra_supplies_nothing_to_the_unicorn' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.ra_supplies_nothing_to_the_unicorn
/-- info: 'RememberedOffered.the_unicorn_closed_on_the_act' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_unicorn_closed_on_the_act
/-- info: 'RememberedOffered.no_arrival_off_the_line_on_the_act' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.no_arrival_off_the_line_on_the_act
/-- info: 'RememberedOffered.unicorn_blocked_on_the_chart' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.unicorn_blocked_on_the_chart
/-- info: 'RememberedOffered.the_unicorn_contained' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_unicorn_contained
#print axioms RememberedOffered.the_unicorn_contained
/-! # THE ONE · appended to Annihilation_Closure.lean (sha256 cb474a41…), nothing above changed.
Every name and every reading the closure carries becomes one object, by equality and not by twin biconditionals;
the act's zero set becomes one notion with the closed configuration that has the value; the floor keeps its own
place; and the one sentence the closure leaves is printed as the closure's own last conjunct. -/
namespace RememberedOffered
theorem the_one {R : Prop} (G : SelfGrounding R) :
(LeastErasure = Value ∧ RootReadTwice = Value ∧ (fun S => R ∧ RootReadTwice S) = Value) ∧
(∀ S : Config, (∃ Z : ActualZeros, Z.zeros = S) ↔ (Closed S ∧ Value S)) ∧
(¬ ∀ S : Config, Closed S → (R ↔ LeastErasure S)) ∧
(∀ S : Config, (R ↔ LeastErasure S) ↔ LeastErasure S) ∧
(∀ Z : ActualZeros, Value Z.zeros) ∧
(∀ D : Config → Prop, (∀ S, Closed S → D S) → ¬ ∀ S, Closed S → D S → Value S) :=
⟨⟨twins_are_one_extension,
funext fun S => propext (the_root_read_twice_is_the_value S),
funext fun S => propext (colocation_is_the_value G S)⟩,
fun S => (an_act_exactly_where_the_root_read_twice_stands S).trans
⟨fun ⟨c, m⟩ => ⟨c, (the_root_read_twice_is_the_value S).mp m⟩,
fun ⟨c, v⟩ => ⟨c, (the_root_read_twice_is_the_value S).mpr v⟩⟩,
floor_is_not_least_erasure G,
merging_at_a_world_is_the_supply G,
value_from_the_act,
no_closed_principle_decides⟩
end RememberedOffered
/-! # THE LAST ACT · appended to The_One.lean, nothing above changed.
A deed is a term of `G.Act`, the act type of a self-grounding root: every decentralized, impersonal, physical
computation, atomic and irreducible, is a deed. The supply is a term of `ActualZeros`. Tested here: every deed being
the supply at one closed zero set S, ζ's in the reading, and at every closed zero set. -/
namespace RememberedOffered
theorem the_last_act {R : Prop} (G : SelfGrounding R) (S : Config) (hS : Closed S) :
-- every deed being the supply at S is exactly the value at S
((G.Act → ∃ Z : ActualZeros, Z.zeros = S) ↔ Value S) ∧
-- every deed being the supply at every closed zero set, as a law, is refuted
(¬ ∀ S' : Config, Closed S' → G.Act → ∃ Z : ActualZeros, Z.zeros = S') ∧
-- the deed stands in the world without the value too
(R ∧ Closed (pairWorld offPoint) ∧ ¬ Value (pairWorld offPoint)) ∧
-- existence supplies nothing to the part above any height
(∀ T : Nat, (RA → RHUnicorn.UnicornAt S onLine ht T) ↔ RHUnicorn.UnicornAt S onLine ht T) :=
⟨⟨fun h => by obtain ⟨Z, hZ⟩ := h G.anAct; rw [← hZ]; exact value_from_the_act Z,
fun v _ => ⟨⟨S, hS, fun p hp => (reg_erases_nothing_iff p).mpr (v p hp)⟩, rfl⟩⟩,
the_deed_is_not_the_supply G,
⟨seated_undeniable G, pair_world_closed offPoint, pair_world_lacks_value offPoint off_point_is_off⟩,
fun T => ra_supplies_nothing_to_the_unicorn S T⟩
end RememberedOffered
/-! # LEAST ERASURE AND LEAST ESCAPE · appended to The_Last_Act.lean, nothing above changed.
The escape of a finite configuration is its number of off-line pairs, the bits registration erases. The pair that
denies RH, a zero at offset one with its mirror, is `resisting`. -/
namespace RememberedOffered
/-- The configuration with no zeros at all: zero escape. -/
def calm : FinCfg := ⟨[], [], fun _ hq => by cases hq⟩
theorem least_erasure_and_least_escape :
-- I · the escaping pair escapes by exactly one bit and pays exactly one floor
(erased resisting = 1 ∧ ∀ T : Nat, price T (erased resisting) = T) ∧
-- II · least escape is zero escape, is least erasure, is the value: the minimiser stands on the line
(∀ F : FinCfg, (∀ F' : FinCfg, erased F ≤ erased F') ↔ Value F.pts) ∧
-- III · the minimum is attained
(∃ F : FinCfg, erased F = 0) ∧
-- IV · the escaping pair is closed and is not a minimiser
(Closed resisting.pts ∧ ¬ ∀ F' : FinCfg, erased resisting ≤ erased F') ∧
-- V · nothing true of every closed configuration makes a configuration a minimiser
(∀ D : Config → Prop, (∀ S, Closed S → D S) →
¬ ∀ F : FinCfg, D F.pts → ∀ F' : FinCfg, erased F ≤ erased F') := by
have least_iff : ∀ F : FinCfg, (∀ F' : FinCfg, erased F ≤ erased F') ↔ Value F.pts := fun F =>
⟨fun h => (twins_on_every_world F.pts).mp
((least_erasure_iff_zero_erased F).mpr (Nat.le_zero.mp (h calm))),
fun v F' => by
have h0 : erased F = 0 := (least_erasure_iff_zero_erased F).mp ((twins_on_every_world F.pts).mpr v)
rw [h0]; exact Nat.zero_le _⟩
have not_value : ¬ Value resisting.pts := (resistance_is_possible 1 (by decide)).2.1
refine ⟨⟨rfl, fun T => Nat.one_mul T⟩, least_iff, ⟨calm, rfl⟩,
⟨fincfg_closed resisting, fun h => not_value ((least_iff resisting).mp h)⟩, ?_⟩
intro D hD h
exact not_value ((least_iff resisting).mp (h resisting (hD _ (fincfg_closed resisting))))
end RememberedOffered
/-! # THE LOOP RA–RAM–ZEROS · appended to Least_Escape.lean, nothing above changed.
RA is the floor R of a self-grounding root. RAM is the root read twice, `RootReadTwice`, the corrected monism witness
with one involution, uniformity and its seed. The loop runs R → RootReadTwice S → Value S → R at a zero set S. -/
namespace RememberedOffered
theorem the_loop {R : Prop} (G : SelfGrounding R) (S : Config) :
-- the corrected monism witness is the claim, seed included
(RootReadTwice S ↔ Value S) ∧
-- the loop's forward leg from RA reaches the zeros exactly when the value already holds
((R → RootReadTwice S) ↔ Value S) ∧
-- the return leg to RA is free: it holds whatever the zeros do
(Value S → R) ∧ (¬ Value S → R) ∧
-- the whole loop closes exactly at the value
((R ↔ RootReadTwice S) ↔ Value S) ∧
-- the loop is sign-blind: it closes for the value and for its denial alike
((SelfVerifying (Value S) ↔ Value S) ∧ (SelfVerifying (¬ Value S) ↔ ¬ Value S)) ∧
-- on one record the loop closes on the true world and stays open on the pair: it cannot select
(SameRecord (registered offPoint) (pairWorld offPoint) ∧ Closed (pairWorld offPoint) ∧
(R ↔ RootReadTwice (registered offPoint)) ∧ ¬ (R ↔ RootReadTwice (pairWorld offPoint))) := by
have r : R := seated_undeniable G
have m := the_root_read_twice_is_the_value S
have sv : ∀ P : Prop, SelfVerifying P ↔ P := fun P =>
⟨fun h => Classical.byContradiction (fun n => n (h n)), fun p _ => p⟩
refine ⟨m, ⟨fun h => m.mp (h r), fun v _ => m.mpr v⟩, fun _ => r, fun _ => r,
⟨fun h => m.mp (h.mp r), fun v => ⟨fun _ => m.mpr v, fun _ => r⟩⟩, ⟨sv _, sv _⟩,
one_record offPoint, pair_world_closed offPoint,
⟨fun _ => the_true_world_carries_monism, fun _ => r⟩,
fun h => the_false_world_carries_no_monism (h.mp r)⟩
end RememberedOffered
/-! # ROW FOUR FROM THE ZERO SIDE · appended to The_Loop.lean, nothing above changed.
A computation that ends is the finite list of points it reports as zeros; it reads a zero set when every point it
reports belongs to it. Row 4 of the RH paper, applied to the hypothetical off-line pair. -/
namespace RememberedOffered
theorem row_four_from_the_zero_side (S : Config) :
-- on any act, every computation reading it reports only zeros on the line
(∀ (Z : ActualZeros) (L : List Point), (∀ p ∈ L, Z.zeros p) → ∀ p ∈ L, onLine p) ∧
-- so a report holding an off-line zero reads no act: on the act, the hypothetical is a phantom
(∀ L : List Point, (∃ p ∈ L, ¬ onLine p) → ¬ ∃ Z : ActualZeros, ∀ p ∈ L, Z.zeros p) ∧
-- yet that report reads a closed configuration, the pair world, which carries the floor
((∀ p ∈ [offPoint, fold offPoint], pairWorld offPoint p) ∧ Closed (pairWorld offPoint)) ∧
-- at a closed zero set: every report of it lands on the line exactly when it has the value
(Closed S → ((∀ L : List Point, (∀ p ∈ L, S p) → ∀ p ∈ L, onLine p) ↔ Value S)) := by
refine ⟨fun Z L hL p hp => value_from_the_act Z p (hL p hp),
fun L ⟨p, hp, hoff⟩ ⟨Z, hZ⟩ => hoff (value_from_the_act Z p (hZ p hp)), ⟨?_, pair_world_closed offPoint⟩, ?_⟩
· intro p hp
cases hp with
| head => exact Or.inl rfl
| tail _ h =>
cases h with
| head => exact Or.inr rfl
| tail _ h' => cases h'
· intro _
constructor
· intro h p hp
exact h [p] (fun q hq => by
cases hq with
| head => exact hp
| tail _ h' => cases h') p (List.Mem.head _)
· intro v L hL p hp
exact v p (hL p hp)
end RememberedOffered
/-! # BIDIRECTIONAL HALTED UNIDUCTION · appended to Row_Four.lean, nothing above changed.
ZERO SIDE: a computation reports finitely many zeros; it reads a zero set when every report belongs to it (Row 4).
PRIME SIDE: through the explicit formula each zero contributes a mode x^(Re ρ) to ψ(x) − x, so the prime error is
bounded by x^(1/2 + ε) exactly when no zero's offset exceeds the line (von Koch 1901; Landau, Ingham) [cited]. On the
offset chart: no point stands to the head's side of the line. -/
namespace RememberedOffered
def ZeroReports (S : Config) : Prop := ∀ L : List Point, (∀ p ∈ L, S p) → ∀ p ∈ L, onLine p
def PrimeBound (S : Config) : Prop := ∀ p, S p → p.1 ≤ 0
theorem prime_side_halts (S : Config) (hS : Closed S) : PrimeBound S ↔ Value S :=
⟨fun hb p hp => by
have h1 : p.1 ≤ 0 := hb p hp
have h2 : -p.1 ≤ 0 := hb (fold p) (hS p hp)
show p.1 = 0; omega,
fun v p hp => by
have h : p.1 = 0 := v p hp
show p.1 ≤ 0; omega⟩
theorem bidirectional_halted_uniduction (S : Config) (hS : Closed S) :
-- the zero side halts at the value of the whole zero set
(ZeroReports S ↔ Value S) ∧
-- the prime side halts at the value of the whole zero set
(PrimeBound S ↔ Value S) ∧
-- so both directions halt at one proposition
(ZeroReports S ↔ PrimeBound S) ∧
-- and neither sweep passes it: on one record, both readings hold on the true world and fail on the pair world
(SameRecord (registered offPoint) (pairWorld offPoint) ∧
(ZeroReports (registered offPoint) ∧ PrimeBound (registered offPoint)) ∧
(¬ ZeroReports (pairWorld offPoint) ∧ ¬ PrimeBound (pairWorld offPoint))) ∧
-- no principle true of every closed configuration supplies either side
(¬ (∀ S' : Config, Closed S' → ZeroReports S') ∧ ¬ (∀ S' : Config, Closed S' → PrimeBound S')) ∧
-- on the act both sides halt at yes
(∀ Z : ActualZeros, ZeroReports Z.zeros ∧ PrimeBound Z.zeros) := by
have zr : ∀ T : Config, Closed T → (ZeroReports T ↔ Value T) := fun T hT => (row_four_from_the_zero_side T).2.2.2 hT
have pv : ¬ Value (pairWorld offPoint) := pair_world_lacks_value offPoint off_point_is_off
have rc : Closed (registered offPoint) := fun s hs => by
rw [hs]; show fold (reg offPoint) = reg offPoint; rfl
refine ⟨zr S hS, prime_side_halts S hS, (zr S hS).trans (prime_side_halts S hS).symm,
⟨one_record offPoint,
⟨(zr _ rc).mpr (registered_has_value offPoint), (prime_side_halts _ rc).mpr (registered_has_value offPoint)⟩,
⟨fun h => pv ((zr _ (pair_world_closed offPoint)).mp h),
fun h => pv ((prime_side_halts _ (pair_world_closed offPoint)).mp h)⟩⟩,
⟨fun h => pv ((zr _ (pair_world_closed offPoint)).mp (h _ (pair_world_closed offPoint))),
fun h => pv ((prime_side_halts _ (pair_world_closed offPoint)).mp (h _ (pair_world_closed offPoint)))⟩,
fun Z => ⟨(zr _ Z.closed).mpr (value_from_the_act Z), (prime_side_halts _ Z.closed).mpr (value_from_the_act Z)⟩⟩
end RememberedOffered
/-! # THE ATOMIC PROOF · appended to Halted_Uniduction.lean, nothing above changed.
One statement: the reduction complete, the bit irreducible by theorem, its form forced by theorem, the bit atomic,
and the closure from it at theorem grade. The bit stands in the statement as the act's field, visible to every
reader. -/
namespace RememberedOffered
theorem the_atomic_proof {R : Prop} (G : SelfGrounding R) (S : Config) (hS : Closed S) :
-- I · REDUCTION, complete: every reading of the hypothesis the seed names is the one proposition
((ZeroReports S ↔ Value S) ∧ (PrimeBound S ↔ Value S) ∧ (LeastErasure S ↔ Value S) ∧
(RootReadTwice S ↔ Value S)) ∧
-- II · IRREDUCIBLE, by theorem: nothing shared by every closed configuration forces it, the deed included
((∀ D : Config → Prop, (∀ S', Closed S' → D S') → ¬ ∀ S', Closed S' → D S' → Value S') ∧
¬ (∀ S' : Config, Closed S' → R → Value S')) ∧
-- III · FORCED IN FORM, by theorem: a premise that forces the value and follows from it is the value
(∀ P : Config → Prop, (∀ S', P S' → Value S') → (∀ S', Value S' → P S') → ∀ S', P S' ↔ Value S') ∧
-- IV · THE BIT, atomic: the act stands at this zero set exactly where the value holds
((∃ Z : ActualZeros, Z.zeros = S) ↔ Value S) ∧
-- V · CLOSURE from the bit, theorem grade: on the act, the value, the zero reports and the prime bound
(∀ Z : ActualZeros, Value Z.zeros ∧ ZeroReports Z.zeros ∧ PrimeBound Z.zeros) :=
⟨⟨(row_four_from_the_zero_side S).2.2.2 hS, prime_side_halts S hS, twins_on_every_world S,
the_root_read_twice_is_the_value S⟩,
⟨no_closed_principle_decides, the_floor_alone_decides_no_value G⟩,
fun _ f w S' => ⟨f S', w S'⟩,
((the_one G).2.1 S).trans ⟨fun ⟨_, v⟩ => v, fun v => ⟨hS, v⟩⟩,
fun Z => ⟨value_from_the_act Z, (bidirectional_halted_uniduction S hS).2.2.2.2.2 Z⟩⟩
end RememberedOffered
/-! # THE ATOMIC NECESSITY · Row 9 · appended to the atomic proof, nothing above changed.
The hypothesis is one dot: one proposition, read the same from every side and in every vocabulary. A dot has no
other dot beside it to be read against, and no room inside it for a second kind of proof. -/
namespace RememberedOffered
theorem the_atomic_necessity (S : Config) (hS : Closed S) :
-- I · every proof of the value at S, from any premise whatever, is a supply of the act's field at S
(∀ Q : Prop, (Q → Value S) → Q → ∃ Z : ActualZeros, Z.zeros = S) ∧
-- II · the dot: any two proofs of the value are one proof
(∀ h₁ h₂ : Value S, h₁ = h₂) ∧
-- III · the supply at S is unique: two supplies with the same zero set are one supply
(∀ Z₁ Z₂ : ActualZeros, Z₁.zeros = S → Z₂.zeros = S → Z₁ = Z₂) ∧
-- IV · every vocabulary and both sides name the same dot
(LeastErasure = Value ∧ RootReadTwice = Value ∧ (ZeroReports S ↔ Value S) ∧ (PrimeBound S ↔ Value S)) ∧
-- V · the supply exists at S exactly where the dot holds
((∃ Z : ActualZeros, Z.zeros = S) ↔ Value S) ∧
-- VI · no room for a proof from what every closed configuration shares
¬ (∀ S' : Config, Closed S' → Value S') := by
refine ⟨fun Q hQ q => ⟨⟨S, hS, (twins_on_every_world S).mpr (hQ q)⟩, rfl⟩,
fun _ _ => rfl, ?_,
⟨twins_are_one_extension, funext fun T => propext (the_root_read_twice_is_the_value T),
(bidirectional_halted_uniduction S hS).1, (bidirectional_halted_uniduction S hS).2.1⟩,
⟨fun ⟨Z, hZ⟩ => hZ ▸ value_from_the_act Z,
fun v => ⟨⟨S, hS, (twins_on_every_world S).mpr v⟩, rfl⟩⟩,
fun h => pair_world_lacks_value offPoint off_point_is_off (h _ (pair_world_closed offPoint))⟩
intro Z₁ Z₂ h₁ h₂
obtain ⟨z₁, c₁, s₁⟩ := Z₁
obtain ⟨z₂, c₂, s₂⟩ := Z₂
change z₁ = S at h₁
change z₂ = S at h₂
subst h₁
subst h₂
rfl
end RememberedOffered
/-! # BOTH VALUES ARE ATOMIC · appended, nothing above changed. The bit has two values and each has the atomic form:
the value's proof is a supply of the one field; the denial's proof is one point off the line. -/
namespace RememberedOffered
theorem both_values_atomic (S : Config) (hS : Closed S) :
((∃ Z : ActualZeros, Z.zeros = S) ↔ Value S) ∧ (¬ Value S ↔ ∃ p, S p ∧ ¬ onLine p) ∧
¬ (Value S ∧ ∃ p, S p ∧ ¬ onLine p) :=
⟨(the_atomic_necessity S hS).2.2.2.2.1,
⟨fun hn => (two_doors S).resolve_left hn, fun ⟨p, hp, hoff⟩ hv => hoff (hv p hp)⟩,
doors_exclusive S⟩
end RememberedOffered
/-! # THE FORM OF A FIELD, EVERY PREMISE SORTED, THE HEIGHT IN ABSOLUTE VALUE · appended, nothing above changed.
Parts I to III of the atomic necessity hold of every proposition carried as the field of a type, the denial included:
they are the form of a field. What makes that form the form of every proof of the hypothesis is part IV: every
reading of the hypothesis from either side and in every vocabulary is this one proposition. Every premise on
configurations is sorted three ways against the value. And the part above a height is read with the height in
absolute value, the form of the cited verification, which covers both half-planes. -/
namespace RememberedOffered
/-- A proposition on configurations, carried as the field of a type at a closed configuration. -/
structure Field (V : Config → Prop) where
zeros : Config
closed : Closed zeros
supply : V zeros
/-- THE FORM OF A FIELD: for every proposition carried as a field, every proof of it at a closed configuration is a
supply of the field there, any two proofs are one, and the supply is unique. -/
theorem the_form_of_a_field (V : Config → Prop) (S : Config) (hS : Closed S) :
(∀ Q : Prop, (Q → V S) → Q → ∃ B : Field V, B.zeros = S) ∧
(∀ h₁ h₂ : V S, h₁ = h₂) ∧
(∀ B₁ B₂ : Field V, B₁.zeros = S → B₂.zeros = S → B₁ = B₂) := by
refine ⟨fun Q hQ q => ⟨⟨S, hS, hQ q⟩, rfl⟩, fun _ _ => rfl, ?_⟩
intro B₁ B₂ h₁ h₂
obtain ⟨z₁, c₁, s₁⟩ := B₁
obtain ⟨z₂, c₂, s₂⟩ := B₂
change z₁ = S at h₁
change z₂ = S at h₂
subst h₁
subst h₂
rfl
/-- THE FORM IS THE HYPOTHESIS'S: the act's type is the field of the value, supply for supply; the form of a field
holds at the value and at its denial alike; and every reading of the hypothesis the seed names is the value, so
the form of the field of the value is the form of every proof of the hypothesis. -/
theorem the_form_is_the_hypothesis (S : Config) (hS : Closed S) :
((∃ Z : ActualZeros, Z.zeros = S) ↔ ∃ B : Field Value, B.zeros = S) ∧
((∀ Q : Prop, (Q → Value S) → Q → ∃ B : Field Value, B.zeros = S) ∧
(∀ Q : Prop, (Q → ¬ Value S) → Q → ∃ B : Field (fun T => ¬ Value T), B.zeros = S)) ∧
(LeastErasure = Value ∧ RootReadTwice = Value ∧ (ZeroReports S ↔ Value S) ∧ (PrimeBound S ↔ Value S)) :=
⟨⟨fun ⟨Z, hZ⟩ => ⟨⟨Z.zeros, Z.closed, value_from_the_act Z⟩, hZ⟩,
fun ⟨B, hB⟩ => ⟨⟨B.zeros, B.closed, (twins_on_every_world B.zeros).mpr B.supply⟩, hB⟩⟩,
⟨(the_form_of_a_field Value S hS).1, (the_form_of_a_field (fun T => ¬ Value T) S hS).1⟩,
(the_atomic_necessity S hS).2.2.2.1⟩
/-- EVERY PREMISE SORTED: a premise on configurations either fails to force the value at some closed configuration,
or forces it and is the value on every closed configuration, or forces it and is strictly stronger, failing at
some closed configuration with the value. -/
theorem premise_trichotomy (P : Config → Prop) :
(∃ S, Closed S ∧ P S ∧ ¬ Value S) ∨
((∀ S, Closed S → P S → Value S) ∧ ∀ S, Closed S → (P S ↔ Value S)) ∨
((∀ S, Closed S → P S → Value S) ∧ ∃ S, Closed S ∧ Value S ∧ ¬ P S) := by
rcases Classical.em (∀ S, Closed S → P S → Value S) with f | f
· rcases Classical.em (∀ S, Closed S → Value S → P S) with e | e
· exact Or.inr (Or.inl ⟨f, fun S hS => ⟨f S hS, e S hS⟩⟩)
· refine Or.inr (Or.inr ⟨f, Classical.byContradiction fun h => e fun S hS v => ?_⟩)
exact Classical.byContradiction fun np => h ⟨S, hS, v, np⟩
· refine Or.inl (Classical.byContradiction fun h => f fun S hS p => ?_)
exact Classical.byContradiction fun nv => h ⟨S, hS, p, nv⟩
/-- The height of a point of the chart in absolute value: the form of the cited verification, both half-planes. -/
def htAbs (p : Point) : Nat := p.2.natAbs
/-- THE UNICORN, CONTAINED, WITH THE HEIGHT IN ABSOLUTE VALUE: at every height the value is its verified part, every
zero with |t| ≤ T, and its part above; given the verified part the value is exactly the part above; above every
height no reading of the record decides the side; the root supplies nothing to the part above; on the act's zero
set every arrival above every height stands on the line. -/
theorem the_unicorn_contained_abs :
(∀ (S : Config) (T : Nat),
Value S ↔ RHUnicorn.RealPartAt S onLine htAbs T ∧ RHUnicorn.UnicornAt S onLine htAbs T) ∧
(∀ (S : Config) (T : Nat),
RHUnicorn.RealPartAt S onLine htAbs T → (Value S ↔ RHUnicorn.UnicornAt S onLine htAbs T)) ∧
(∀ T : Nat, ¬ ∃ g : Point → Bool, ∀ w : Point, htAbs w > T → g (reg w) = decide (w.1 > 0)) ∧
(∀ (S : Config) (T : Nat),
(RA → RHUnicorn.UnicornAt S onLine htAbs T) ↔ RHUnicorn.UnicornAt S onLine htAbs T) ∧
(∀ (Z : ActualZeros) (T : Nat), RHUnicorn.UnicornAt Z.zeros onLine htAbs T) ∧
(∀ Z : ActualZeros, ¬ ∃ p, Z.zeros p ∧ ¬ onLine p) :=
⟨fun S T => RHUnicorn.rh_iff_real_and_unicorn S onLine htAbs T,
fun S T hr => RHUnicorn.unicorn_no_bypass S onLine htAbs T hr,
fun T => RHUnicorn.unicorn_block htAbs T fold reg (fun w => decide (w.1 > 0)) ((1 : Int), Int.ofNat (T + 1))
(show T + 1 > T by omega) (show T + 1 > T by omega) rfl rfl,
fun S T => RHUnicorn.unicorn_rule_exact S onLine htAbs T RA (seated_undeniable raSelfGrounding),
fun Z _ p hp _ => value_from_the_act Z p hp,
no_arrival_off_the_line_on_the_act⟩
end RememberedOffered
/-! # ROWS 10 AND 11 · appended, nothing above changed. Row 10: the unconditional route from shared premises and the
record is blocked. Row 11: accepting the hypothesis, by any proof, an unconditional one included, forces acceptance of
the atomic proof provided in this paper; the only other door is one point off the line. -/
namespace RememberedOffered
/-- ROW 10 · THE UNCONDITIONAL ROUTE FROM SHARED PREMISES AND THE RECORD IS BLOCKED. The value is no law of
reflection-closed configurations; nothing every closed configuration shares forces it, the root included; no
reading of the record decides it; and, by a law of logic true of every proposition, every premise that does force
it is either the value itself or strictly stronger than the value. -/
theorem the_unconditional_route_is_blocked {R : Prop} (G : SelfGrounding R) :
(¬ ∀ S : Config, Closed S → Value S) ∧
(∀ D : Config → Prop, (∀ S, Closed S → D S) → ¬ ∀ S, Closed S → D S → Value S) ∧
(¬ ∀ S : Config, Closed S → R → Value S) ∧
(∀ g : Config → Prop, (∀ S S', SameRecord S S' → (g S ↔ g S')) →
¬ ∀ S, Closed S → (g S ↔ Value S)) ∧
(∀ P : Config → Prop, (∀ S, Closed S → P S → Value S) →
(∀ S, Closed S → (P S ↔ Value S)) ∨ ∃ S, Closed S ∧ Value S ∧ ¬ P S) := by
have pc := pair_world_closed offPoint
have pv := pair_world_lacks_value offPoint off_point_is_off
have rc : Closed (registered offPoint) := fun s hs => by
rw [hs]; show fold (reg offPoint) = reg offPoint; rfl
refine ⟨fun h => pv (h _ pc), no_closed_principle_decides, the_floor_alone_decides_no_value G, ?_, ?_⟩
· intro g hg h
exact pv ((h _ pc).mp ((hg _ _ (one_record offPoint)).mp ((h _ rc).mpr (registered_has_value offPoint))))
· intro P f
rcases premise_trichotomy P with ⟨S, hS, p, nv⟩ | ⟨_, e⟩ | ⟨_, s⟩
· exact absurd (f S hS p) nv
· exact Or.inl e
· exact Or.inr s
/-- ROW 11 · ACCEPTING THE HYPOTHESIS FORCES ACCEPTANCE OF THE ATOMIC PROOF. At every reflection-closed zero set:
every proof of the value, from any premise, an unconditional one included, is a supply of the act's field, by the
definition of the act's type, which carries the value itself as its field; the atomic proof this paper provides is
that form made explicit. Any two proofs are one and the supply is unique; the only other door is one point off the
line; there is no third value; and the structure, the reduction and the forced form, holds with no premise. -/
theorem accepting_rh_forces_the_atomic_proof (S : Config) (hS : Closed S) :
(∀ Q : Prop, (Q → Value S) → Q → ∃ Z : ActualZeros, Z.zeros = S) ∧
(Value S → ∃ Z : ActualZeros, Z.zeros = S) ∧
(∀ h₁ h₂ : Value S, h₁ = h₂) ∧
(∀ Z₁ Z₂ : ActualZeros, Z₁.zeros = S → Z₂.zeros = S → Z₁ = Z₂) ∧
(¬ Value S ↔ ∃ p, S p ∧ ¬ onLine p) ∧
(Value S ∨ ∃ p, S p ∧ ¬ onLine p) ∧ ¬ (Value S ∧ ∃ p, S p ∧ ¬ onLine p) ∧
((ZeroReports S ↔ Value S) ∧ (PrimeBound S ↔ Value S) ∧ (LeastErasure S ↔ Value S) ∧
(RootReadTwice S ↔ Value S)) ∧
(∀ P : Config → Prop, (∀ S', P S' → Value S') → (∀ S', Value S' → P S') → ∀ S', P S' ↔ Value S') := by
have n := the_atomic_necessity S hS
have b := both_values_atomic S hS
refine ⟨n.1, fun v => n.2.2.2.2.1.mpr v, n.2.1, n.2.2.1, b.2.1, two_doors S, b.2.2, ?_, ?_⟩
· exact (the_atomic_proof raSelfGrounding S hS).1
· exact (the_atomic_proof raSelfGrounding S hS).2.2.1
end RememberedOffered
end PartIII
/-! # PART IV · the arrow and the zero side locus -/
section PartIV
/-
ARROW HINGE · the non-trivial-zero locus read directly off the arrow.
Core Lean 4.19.0, no import, no axiom declared, no sorry.
The arrow of the completed zeta runs between its only two poles, s = 0 and s = 1. Chart: x = 4·Re s, height t,
so the poles sit at x = 0 and x = 4 and the open strip is 0 < x < 4. Grain is free among the grains that put the
midpoint on the chart, the even ones; every such grain gives the same hinge, Re s = 1/2, and an odd grain holds no
chart point at the hinge (`hinge_iff_even`). Every chart of this seed has an even grain.
I the arrow alone: reversal swaps its poles, undoes itself, and fixes at most one point, the hinge, and exactly
one when the poles have an even sum in the chart.
II the free bit: flipping the arrow's orientation leaves the reversal and the hinge unchanged.
III the plane: the fold keeps height and moves offset; its fixed set is the line Re s = 1/2.
IV the lean: off the line a point carries the arrow's sign and the fold flips it; the registration merges it.
V the bar: a coherent off-line world sits inside the strip; no premise true of every closed world forces the value.
VI the act: a supplied least-erasure world carries the value.
VII the zero side's own locus: the centre of every nonempty finite reflection-closed family is the line.
VIII the line on every extension: the arrow fixes one value of the real part; on every map of the plane that acts on
the real part by the reversal, the points whose real part it fixes are the line, and the centre balances on it;
a finite family closed under the fold, listed in any order, has its centre on the line.
The height-keeping extension is the fold, s ↦ 1 − s̄, which needs the conjugate symmetry [cited]; the functional
equation alone, s ↦ 1 − s, fixes one point and reads the same line.
-/
set_option autoImplicit false
namespace Hinge
/-! ## I · the arrow alone -/
structure Arrow where
tail : Int
head : Int
def rev (A : Arrow) (x : Int) : Int := A.tail + A.head - x
def flip (A : Arrow) : Arrow := ⟨A.head, A.tail⟩
def off (A : Arrow) (x : Int) : Int := 2 * x - (A.tail + A.head)
theorem rev_swaps (A : Arrow) : rev A A.tail = A.head ∧ rev A A.head = A.tail := by
unfold rev; constructor <;> omega
theorem rev_involutive (A : Arrow) (x : Int) : rev A (rev A x) = x := by unfold rev; omega
/-- THE HINGE: a point is fixed by the arrow's reversal exactly when its offset from the midpoint is zero. -/
theorem hinge (A : Arrow) (x : Int) : rev A x = x ↔ off A x = 0 := by unfold rev off; omega
theorem hinge_unique (A : Arrow) (x y : Int) (hx : rev A x = x) (hy : rev A y = y) : x = y := by
unfold rev at hx hy; omega
/-- THE HINGE EXISTS on every arrow whose poles have an even sum in the chart: then the reversal fixes exactly the
midpoint. With `hinge_unique`, exactly one point. -/
theorem hinge_exists (A : Arrow) (h : (A.tail + A.head) % 2 = 0) : ∃ x, rev A x = x :=
⟨(A.tail + A.head) / 2, by unfold rev; omega⟩
/-- THE HINGE ON THE CHART: the reversal has a fixed point on the integer chart exactly when the poles have an even
sum; at an odd grain the midpoint falls between two chart points and the chart holds no hinge. -/
theorem hinge_iff_even (A : Arrow) : (∃ x, rev A x = x) ↔ (A.tail + A.head) % 2 = 0 := by
constructor
· intro ⟨x, hx⟩
unfold rev at hx
omega
· exact hinge_exists A
/-! ## II · the free bit -/
/-- SIGN-BLIND: the reversal and the offset magnitude ignore which way the arrow points. -/
theorem hinge_sign_blind (A : Arrow) (x : Int) : rev (flip A) x = rev A x ∧ off (flip A) x = off A x := by
show A.head + A.tail - x = A.tail + A.head - x ∧ 2 * x - (A.head + A.tail) = 2 * x - (A.tail + A.head)
constructor <;> omega
/-- The reversal flips every offset. -/
theorem rev_flips_offset (A : Arrow) (x : Int) : off A (rev A x) = - off A x := by unfold off rev; omega
/-- Zeta's arrow: s = 0 to s = 1, at x = 4·Re s. -/
def zeta : Arrow := ⟨0, 4⟩
theorem zeta_hinge (x : Int) : rev zeta x = x ↔ x = 2 := by
show 0 + 4 - x = x ↔ x = 2; omega
/-- THE REVERSAL IS FORCED: the only distance-keeping map of the axis that swaps the poles is the arrow's reversal.
Distance-keeping is stated sign-blind, every difference kept up to its sign, so the Number alone fixes the map. -/
theorem the_only_rigid_reversal (f : Int → Int)
(iso : ∀ x y, f x - f y = x - y ∨ f x - f y = y - x) (h0 : f 0 = 4) (h4 : f 4 = 0) :
∀ x, f x = rev zeta x := by
intro x
have a := iso x 0
have b := iso x 4
rw [h0] at a
rw [h4] at b
show f x = 0 + 4 - x
omega
/-! ## III · the plane -/
abbrev Pt := Int × Int
def fold (p : Pt) : Pt := (rev zeta p.1, p.2)
def onLine (p : Pt) : Prop := p.1 = 2
def reg (p : Pt) : Pt := (2, p.2)
def inStrip (p : Pt) : Prop := 0 < p.1 ∧ p.1 < 4
theorem fold_keeps_height (p : Pt) : (fold p).2 = p.2 := rfl
/-- THE LOCUS: the fold's fixed set is the line x = 2, which is Re s = 1/2. -/
theorem locus (p : Pt) : fold p = p ↔ onLine p := by
obtain ⟨x, t⟩ := p
constructor
· intro e
have h1 : 0 + 4 - x = x := congrArg Prod.fst e
show x = 2; omega
· intro e
have h1 : x = 2 := e
subst h1; rfl
/-! ## IV · the lean -/
/-- OFF THE LINE A POINT LEANS: its offset is nonzero and the fold flips its sign. -/
theorem off_line_leans (p : Pt) (h : ¬ onLine p) : off zeta p.1 ≠ 0 ∧ off zeta (fold p).1 = - off zeta p.1 := by
constructor
· intro e
have e1 : 2 * p.1 - (0 + 4) = 0 := e
exact h (show p.1 = 2 by omega)
· exact rev_flips_offset zeta p.1
theorem reg_keeps_on_line (p : Pt) (h : onLine p) : reg p = p := by
obtain ⟨x, t⟩ := p
have h1 : x = 2 := h
subst h1; rfl
/-- OFF THE LINE THE REGISTRATION MERGES: two distinct points, one record. -/
theorem reg_merges (p : Pt) (h : ¬ onLine p) : fold p ≠ p ∧ reg (fold p) = reg p :=
⟨fun e => h ((locus p).mp e), rfl⟩
/-! ## V · the bar -/
def Closed (Z : Pt → Prop) : Prop := ∀ p, Z p → Z (fold p)
def Value (Z : Pt → Prop) : Prop := ∀ p, Z p → onLine p
def LeastErasure (Z : Pt → Prop) : Prop := ∀ p, Z p → reg p = p
theorem least_erasure_iff_value (Z : Pt → Prop) : LeastErasure Z ↔ Value Z := by
constructor
· intro h p hp
have e : (1 : Int) * 2 = p.1 := by
have e0 : (reg p).1 = p.1 := congrArg Prod.fst (h p hp)
have e2 : (2 : Int) = p.1 := e0
omega
show p.1 = 2; omega
· intro h p hp; exact reg_keeps_on_line p (h p hp)
/-- The off-line pair at Re s = 1/4 and 3/4, height 0. -/
def pairW : Pt → Prop := fun p => p = (1, 0) ∨ p = (3, 0)
theorem pair_closed : Closed pairW := by
intro p hp
rcases hp with e | e
· subst e; exact Or.inr (by decide)
· subst e; exact Or.inl (by decide)
theorem pair_in_strip : ∀ p, pairW p → inStrip p := by
intro p hp
rcases hp with e | e
· subst e; exact ⟨by decide, by decide⟩
· subst e; exact ⟨by decide, by decide⟩
theorem pair_lacks_value : ¬ Value pairW := by
intro h
have h1 : (1 : Int) = 2 := h (1, 0) (Or.inl rfl)
exact absurd h1 (by decide)
/-- THE ARROW FORCES NO ZERO: no premise true of every closed world forces the value. -/
theorem keyless_forces_nothing (Q : (Pt → Prop) → Prop) (hQ : ∀ Z, Closed Z → Q Z) :
¬ ∀ Z, Closed Z → Q Z → Value Z :=
fun hall => pair_lacks_value (hall pairW pair_closed (hQ pairW pair_closed))
/-! ## VI · the act -/
structure ActualZeros where
zeros : Pt → Prop
closed : Closed zeros
supply : LeastErasure zeros
theorem value_from_the_act (Z : ActualZeros) : Value Z.zeros := (least_erasure_iff_value _).mp Z.supply
/-! ## VII · the zero side's own locus -/
/-- The real parts of a configuration, summed. -/
def sumX : List Pt → Int
| [] => 0
| p :: L => p.1 + sumX L
/-- THE ZERO SIDE'S LOCUS IS THE LINE: list any members with their mirrors and the real parts balance on the line,
four per member pair in this chart, so the centre of every reflection-closed configuration sits at Re s = 1/2. -/
theorem centre_is_the_line (L : List Pt) : sumX (L.map fold) + sumX L = 4 * (L.length : Int) := by
induction L with
| nil => rfl
| cons p L ih =>
have hf : (fold p).1 = 0 + 4 - p.1 := rfl
simp only [List.map_cons, sumX, List.length_cons]
push_cast
omega
/-- THE SAME OBJECT, MEMBERS OFF IT: the pair at Re s = 1/4 and 3/4 is reflection-closed, its centre is the line,
it sits in the open strip, and neither member is on the line. -/
theorem centred_yet_off :
Closed pairW ∧ sumX [(1, 0), (3, 0)] = 2 * 2 ∧ (∀ p, pairW p → inStrip p ∧ ¬ onLine p) := by
refine ⟨pair_closed, by decide, ?_⟩
intro p hp
refine ⟨pair_in_strip p hp, ?_⟩
rcases hp with e | e
· subst e; intro h; have h1 : (1 : Int) = 2 := h; exact absurd h1 (by decide)
· subst e; intro h; have h1 : (3 : Int) = 2 := h; exact absurd h1 (by decide)
/-! ## VIII · the line and the centre on every extension -/
/-- THE LINE OFF THE ARROW: on every map of the plane that acts on the real part by the arrow's reversal, the points
whose real part it fixes are exactly the line x = 2, Re s = 1/2. The arrow fixes one value of the real part; the
line is the set of points with that real part, whatever the map does to height. -/
theorem the_line_off_the_arrow (F : Pt → Pt) (hF : ∀ p, (F p).1 = rev zeta p.1) (p : Pt) :
(F p).1 = p.1 ↔ onLine p := by
rw [hF p]
exact zeta_hinge p.1
/-- THE FOLD IS THE HEIGHT-KEEPING EXTENSION: the one map of the plane that acts on the real part by the reversal and
keeps height is the fold. Keeping height is the conjugate symmetry composed with the functional equation,
s ↦ 1 − s̄ [Riemann 1859, cited]. -/
theorem fold_is_the_height_keeping_extension (F : Pt → Pt) (hF : ∀ p, (F p).1 = rev zeta p.1)
(hh : ∀ p, (F p).2 = p.2) (p : Pt) : F p = fold p :=
Prod.ext (hF p) (hh p)
/-- The functional equation alone, s ↦ 1 − s, on the chart: the reversal on the real part, the height reversed. -/
def pointRefl (p : Pt) : Pt := (rev zeta p.1, -p.2)
/-- THE FUNCTIONAL EQUATION ALONE FIXES ONE POINT AND READS THE SAME LINE: s ↦ 1 − s fixes only s = 1/2, and the
points whose real part it fixes are the line. -/
theorem the_point_reflection_reads_the_same_line :
(∀ p : Pt, pointRefl p = p ↔ p = (2, 0)) ∧ (∀ p : Pt, (pointRefl p).1 = p.1 ↔ onLine p) := by
refine ⟨fun p => ?_, the_line_off_the_arrow pointRefl (fun _ => rfl)⟩
obtain ⟨x, t⟩ := p
constructor
· intro e
have h1 : 0 + 4 - x = x := congrArg Prod.fst e
have h2 : -t = t := congrArg Prod.snd e
have hx : x = 2 := by omega
have ht : t = 0 := by omega
subst hx
subst ht
rfl
· intro e
have hx : x = 2 := congrArg Prod.fst e
have ht : t = 0 := congrArg Prod.snd e
subst hx
subst ht
decide
/-- THE CENTRE ON EVERY EXTENSION: under every map that acts on the real part by the reversal, the real parts of any
finite family and of its image balance on the line; the centre does not depend on what the map does to height. -/
theorem centre_on_every_extension (F : Pt → Pt) (hF : ∀ p, (F p).1 = rev zeta p.1) (L : List Pt) :
sumX (L.map F) + sumX L = 4 * (L.length : Int) := by
induction L with
| nil => rfl
| cons p L ih =>
have hf : (F p).1 = 0 + 4 - p.1 := hF p
simp only [List.map_cons, sumX, List.length_cons]
push_cast
omega
/-- The sum of real parts does not depend on the order in which a family is listed. -/
theorem sumX_perm {L M : List Pt} (h : L.Perm M) : sumX L = sumX M := by
induction h with
| nil => rfl
| cons x _ ih => simp only [sumX]; omega
| swap x y l => simp only [sumX]; omega
| trans _ _ ih1 ih2 => omega
/-- THE CENTRE OF A CLOSED FAMILY: a finite family whose mirror image is the family itself, listed in any order, has
its real parts summing to twice its size, so a nonempty one has its centre at x = 2, Re s = 1/2. -/
theorem centre_of_a_closed_family (L : List Pt) (h : (L.map fold).Perm L) : sumX L = 2 * (L.length : Int) := by
have e := centre_is_the_line L
have p := sumX_perm h
omega
/-! ## the hinge, whole -/
theorem arrow_gives_line_not_value :
(∀ A : Arrow, rev A A.tail = A.head ∧ rev A A.head = A.tail) ∧
(∀ (A : Arrow) (x : Int), rev A (rev A x) = x) ∧
(∀ (A : Arrow) (x y : Int), rev A x = x → rev A y = y → x = y) ∧
(∀ (A : Arrow) (x : Int), rev (flip A) x = rev A x ∧ off (flip A) x = off A x) ∧
(∀ x : Int, rev zeta x = x ↔ x = 2) ∧
(∀ p : Pt, fold p = p ↔ onLine p) ∧
(∀ p : Pt, ¬ onLine p → off zeta p.1 ≠ 0 ∧ off zeta (fold p).1 = - off zeta p.1) ∧
(∀ p : Pt, ¬ onLine p → fold p ≠ p ∧ reg (fold p) = reg p) ∧
(∀ Z : Pt → Prop, LeastErasure Z ↔ Value Z) ∧
(Closed pairW ∧ (∀ p, pairW p → inStrip p) ∧ ¬ Value pairW) ∧
(∀ Q : (Pt → Prop) → Prop, (∀ Z, Closed Z → Q Z) → ¬ ∀ Z, Closed Z → Q Z → Value Z) ∧
(∀ Z : ActualZeros, Value Z.zeros) :=
⟨rev_swaps, rev_involutive, hinge_unique, hinge_sign_blind, zeta_hinge, locus, off_line_leans, reg_merges,
least_erasure_iff_value, ⟨pair_closed, pair_in_strip, pair_lacks_value⟩, keyless_forces_nothing,
value_from_the_act⟩
end Hinge
end PartIV
/-! # PART IV-b · Force_Witness.lean, verbatim from the signed master v5.1.0, with the plug appended -/
section PartIVb
/-
Force_Witness.lean · PhysOS Proof PSP-FORCE-WITNESS-01 · the force-witness closure.
Core Lean 4.19.0. No import, no sorry, no admit, no native_decide, no axiom declared.
Least erasure is the final ninth-gate bit. A run of the substrate is the atomic witness that the closure was
computed: a run whose flag is true proves that a run exists. The value at the actual zero set is the field of
the act: keyed, given, free.
PART ONE is copied from Inescapable_Capstone.lean, every definition and every law unchanged, with the lemmas
they stand on: the chart, the configurations, the record, the act, the ninth gate, the deed.
PART TWO is new: the atomic step, the ninth gate packed, the deed of the substrate, the free bit, the closure
and its guard.
THE FREE BIT. Every run leaves the value to the act. the_deed_forces_nothing is the seated law, and
the_run_does_not_force_the_value states it at every run. It is the fourth conjunct of the closure.
-/
namespace ForceWitness
/-! ## PART ONE · The seated carriers and laws, copied unchanged -/
/-- A point is (d, t): d its offset from the line, t its height. The line is d = 0. -/
abbrev Point := Int × Int
/-- The fold: s ↦ 1 − s̄ on the offset chart, (d, t) ↦ (−d, t). -/
def fold (p : Point) : Point := (-p.1, p.2)
/-- The line: offset zero. -/
def onLine (p : Point) : Prop := p.1 = 0
/-- The registration: it keeps the height and forgets the side. -/
def reg (p : Point) : Point := (0, p.2)
/-- Integer negation is an involution, by the integer's constructors. -/
theorem neg_neg_free : ∀ d : Int, - -d = d := fun
| Int.ofNat 0 => rfl
| Int.ofNat (_ + 1) => rfl
| Int.negSucc _ => rfl
/-- An integer equal to its own negation is zero, by the integer's constructors. -/
theorem neg_self_zero : ∀ d : Int, -d = d → d = 0 := fun
| Int.ofNat 0, _ => rfl
| Int.ofNat (_ + 1), h => Int.noConfusion h
| Int.negSucc _, h => Int.noConfusion h
/-- The fold is an involution. -/
theorem fold_involutive (p : Point) : fold (fold p) = p := by
obtain ⟨d, t⟩ := p
show (- -d, t) = (d, t)
rw [neg_neg_free d]
/-- THE CUT IS THE LINE: the fold fixes a point exactly when it is on the line. -/
theorem the_cut_is_the_line (p : Point) : fold p = p ↔ onLine p := by
obtain ⟨d, t⟩ := p
exact ⟨fun h => neg_self_zero d (congrArg Prod.fst h), fun h => by cases h; rfl⟩
/-- The registration lands on the line. -/
theorem reg_lands (p : Point) : onLine (reg p) := rfl
/-- The registration erases nothing at a point exactly when the point is on the line. -/
theorem reg_erases_nothing_iff (p : Point) : reg p = p ↔ onLine p := by
obtain ⟨d, t⟩ := p
exact ⟨fun h => (congrArg Prod.fst h).symm, fun h => by cases h; rfl⟩
/-- A configuration: a set of points. Closed: the fold carries it to itself. -/
abbrev Config := Point → Prop
def Closed (S : Config) : Prop := ∀ p, S p → S (fold p)
/-- The value: every point of the configuration is on the line. -/
def Value (S : Config) : Prop := ∀ p, S p → onLine p
/-- Least erasure: the registration leaves every point of the configuration unchanged. -/
def LeastErasure (S : Config) : Prop := ∀ p, S p → reg p = p
/-- The record of a configuration: what the registration leaves. -/
def Rec (S : Config) (q : Point) : Prop := ∃ p, S p ∧ reg p = q
def SameRecord (S S' : Config) : Prop := ∀ q, Rec S q ↔ Rec S' q
/-- The registered world of a point and its pair world. -/
def registered (p : Point) : Config := fun s => s = reg p
def pairWorld (p : Point) : Config := fun s => s = p ∨ s = fold p
theorem pair_world_closed (p : Point) : Closed (pairWorld p) := fun _ hs =>
match hs with
| Or.inl e => Or.inr (congrArg fold e)
| Or.inr e => Or.inl (e ▸ fold_involutive p)
/-- The registered world and the pair world leave one record. -/
theorem one_record (p : Point) : SameRecord (registered p) (pairWorld p) := fun q =>
⟨fun ⟨_, hs, hq⟩ => ⟨p, Or.inl rfl, by rw [← hq, hs]; rfl⟩,
fun ⟨_, hs, hq⟩ => ⟨reg p, rfl, by
rw [← hq]
exact match hs with
| Or.inl e => by rw [e]; rfl
| Or.inr e => by rw [e]; rfl⟩⟩
theorem registered_has_value (p : Point) : Value (registered p) := fun s hs => by
rw [hs]; exact reg_lands p
theorem pair_world_lacks_value (p : Point) (h : ¬ onLine p) : ¬ Value (pairWorld p) :=
fun hv => h (hv p (Or.inl rfl))
/-- THE RECORD DECIDES NOTHING: for every point off the line, no reading that respects the record returns the
value on both its registered world and its pair world. -/
theorem record_decides_nothing (p : Point) (h : ¬ onLine p) (g : Config → Prop)
(hg : ∀ S S', SameRecord S S' → (g S ↔ g S')) :
¬ ((g (registered p) ↔ Value (registered p)) ∧ (g (pairWorld p) ↔ Value (pairWorld p))) :=
fun ⟨h1, h2⟩ => pair_world_lacks_value p h
(h2.mp ((hg _ _ (one_record p)).mp (h1.mpr (registered_has_value p))))
/-- THE ACT. The bit is supplied once, in the open, as a field of a type: a closed configuration with least
erasure at it. The field is the value supplied; the type makes the supply visible to every reader. -/
structure ActualZeros where
zeros : Config
closed : Closed zeros
supply : LeastErasure zeros
/-- FROM THE ACT, THE VALUE. -/
theorem value_from_the_act (Z : ActualZeros) : Value Z.zeros :=
fun p hp => (reg_erases_nothing_iff p).mp (Z.supply p hp)
def e (n i : Nat) : List Int := (List.range n).map (fun j => if j == i then 1 else 0)
def neg3 (s : Bool × Bool × Bool) : Bool × Bool × Bool := (!s.1, !s.2.1, !s.2.2)
def par3 (s : Bool × Bool × Bool) : Nat :=
(if s.1 then 1 else 0) + (if s.2.1 then 1 else 0) + (if s.2.2 then 1 else 0)
/-- The orientation of a sign pattern, the determinant of its diagonal: −1 to the number of flips. -/
def orient (s : Bool × Bool × Bool) : Int := if par3 s % 2 == 0 then 1 else -1
/-- The ordered factor pairs of n, by first factor; the swap sends a to n / a. -/
def pairs (n : Nat) : List Nat := (List.range (n + 1)).filter (fun a => 0 < a && n % a == 0)
/-- The price of exported freedom in native units: temperature is energy per bit, so b bits cost b·T. -/
def price (T bits : Nat) : Nat := bits * T
/-- A finite configuration: the heights of its zeros on the line, and its off-line pairs, each an offset that is not
zero and a height. -/
structure FinCfg where
line : List Int
pairs : List (Int × Int)
offset_ne : ∀ q ∈ pairs, q.1 ≠ 0
/-- The erased bits of a finite configuration: one per off-line pair, two points registered to one. -/
def erased (F : FinCfg) : Nat := F.pairs.length
/-- The executed frame: a formal content and the bit of whether it ran. Reading the content is formal. -/
abbrev Exec (Q : Type) := Bool × Q
def ran {Q : Type} (s : Exec Q) : Bool := s.1
/-- The nine: the eight sign patterns and one more. -/
abbrev Gate := Option (Bool × Bool × Bool)
/-- The fold on the nine: total negation on the eight; the ninth is its own partner. -/
def gfold : Gate → Gate
| none => none
| some s => some (neg3 s)
/-- THE SEAT IS THE NINTH: the fold of the nine fixes a gate exactly when the gate is the ninth. -/
theorem seat_is_the_ninth (g : Gate) : gfold g = g ↔ g = none := by
cases g with
| none => exact ⟨fun _ => rfl, fun _ => rfl⟩
| some s =>
obtain ⟨a, b, c⟩ := s
constructor
· intro h; cases a <;> cases b <;> cases c <;> cases h
· intro h; cases h
/-- The orientation of a pattern is never zero. -/
theorem orient_ne_zero (s : Bool × Bool × Bool) : orient s ≠ 0 := by
obtain ⟨a, b, c⟩ := s; cases a <;> cases b <;> cases c <;> decide
/-- Total negation flips the orientation. -/
theorem orient_flips (s : Bool × Bool × Bool) : orient (neg3 s) = -orient s := by
obtain ⟨a, b, c⟩ := s; cases a <;> cases b <;> cases c <;> rfl
/-- The carrier of the nine onto the chart: a pattern lands on the wall or the edge by its orientation, the ninth on
the line. -/
def toChart (t : Int) : Gate → Point
| none => (0, t)
| some s => (orient s, t)
/-- The carrier is equivariant: the fold of the nine is carried onto the fold of the chart. -/
theorem gate_carrier_equivariant (t : Int) (g : Gate) : toChart t (gfold g) = fold (toChart t g) := by
cases g with
| none => rfl
| some s => obtain ⟨a, b, c⟩ := s; cases a <;> cases b <;> cases c <;> rfl
/-- And under every carrier that separates partners, only the ninth does. -/
theorem faithful_carrier_lands_only_the_ninth (c : Gate → Point) (eqv : ∀ g, c (gfold g) = fold (c g))
(sep : ∀ g, c (gfold g) = c g → gfold g = g) (g : Gate) : onLine (c g) ↔ g = none := by
constructor
· intro h
exact (seat_is_the_ninth g).mp (sep g ((eqv g).trans ((the_cut_is_the_line (c g)).mpr h)))
· intro h
subst h
have e : fold (c none) = c none := (eqv none).symm
exact (the_cut_is_the_line (c none)).mp e
/-- The orientation carrier separates partners. -/
theorem orientation_carrier_separates (t : Int) (g : Gate) (h : toChart t (gfold g) = toChart t g) :
gfold g = g := by
cases g with
| none => rfl
| some s =>
exact absurd (neg_self_zero (orient s) ((orient_flips s).symm.trans (congrArg Prod.fst h))) (orient_ne_zero s)
/-- A gate owes a bit when some target is odd at it: no even reading returns that target, and one supplied odd
witness fixes it by one calibration bit. -/
def OwesBit (g : Gate) : Prop := ∃ d : Gate → Bool, d (gfold g) = !d g
/-- At the seat no bit is owed: nothing is odd at a fixed point. -/
theorem seat_owes_no_bit : ¬ OwesBit none := by
intro ⟨d, h⟩
have h' : d none = !d none := h
cases hd : d none <;> rw [hd] at h' <;> cases h'
/-- Off the seat a bit is owed, at every one of the eight. -/
theorem off_seat_owes_a_bit (s : Bool × Bool × Bool) : OwesBit (some s) := by
refine ⟨fun g => decide (g = some s), ?_⟩
obtain ⟨a, b, c⟩ := s
cases a <;> cases b <;> cases c <;> decide
/-- The registered orbit of a gate, as a finite configuration: the ninth is one point on the line; each of the eight
is one off-line pair. -/
def gateCfg (t : Int) : Gate → FinCfg
| none => ⟨[t], [], fun _ h => nomatch h⟩
| some s => ⟨[], [(orient s, t)], fun q h => by
cases h with
| head => exact orient_ne_zero s
| tail _ h' => nomatch h'⟩
/-- The heat of registering a gate is zero exactly at the ninth. -/
theorem gate_heat_zero_iff_ninth (T : Nat) (hT : 0 < T) (t : Int) (g : Gate) :
price T (erased (gateCfg t g)) = 0 ↔ g = none := by
cases g with
| none => exact ⟨fun _ => rfl, fun _ => Nat.zero_mul T⟩
| some s =>
constructor
· intro h
have h1 : 1 * T = 0 := h
rw [Nat.one_mul] at h1
exact absurd h1 (Nat.pos_iff_ne_zero.mp hT)
· intro h; cases h
/-- THE NINTH GATE IS LEAST ERASURE. At a gate, five readings are one: it is the fold's fixed point; it lands on
the line; registration erases nothing there (forget); its registration is free (pay); no bit is owed there
(supply). Each holds exactly at the ninth. -/
theorem ninth_gate_is_least_erasure (t : Int) (T : Nat) (hT : 0 < T) (g : Gate) :
(gfold g = g ↔ g = none) ∧
(onLine (toChart t g) ↔ g = none) ∧
(reg (toChart t g) = toChart t g ↔ g = none) ∧
(price T (erased (gateCfg t g)) = 0 ↔ g = none) ∧
(¬ OwesBit g ↔ g = none) := by
have hl : onLine (toChart t g) ↔ g = none :=
faithful_carrier_lands_only_the_ninth (toChart t) (gate_carrier_equivariant t) (orientation_carrier_separates t) g
refine ⟨seat_is_the_ninth g, hl, (reg_erases_nothing_iff (toChart t g)).trans hl,
gate_heat_zero_iff_ninth T hT t g, ?_⟩
cases g with
| none => exact ⟨fun _ => rfl, fun _ => seat_owes_no_bit⟩
| some s => exact ⟨fun h => absurd (off_seat_owes_a_bit s) h, fun h => by cases h⟩
/-- A RUN IS ITS OWN ATOMIC WITNESS, of the deed: a state that ran proves that a run exists. -/
theorem the_run_witnesses_a_run {Q : Type} (s : Exec Q) (h : ran s = true) : ∃ r : Exec Q, ran r = true := by
exact ⟨s, h⟩
/-- AND OF NOTHING ELSE: a fact that holds whatever the configuration, the deed included, forces no value. -/
theorem the_deed_forces_nothing (D : Prop) (hD : D) : ¬ ∀ S : Config, Closed S → D → Value S := by
intro hall
exact pair_world_lacks_value (1, 0) (fun e => by cases e) (hall _ (pair_world_closed (1, 0)) hD)
/-! ## PART TWO · The force-witness closure -/
/-- THE ATOMIC STEP: a witness with its check proves the existential it witnesses. -/
theorem witness_proves_exists {α : Type} (P : α → Prop) (w : α) (h : P w) : ∃ x, P x := ⟨w, h⟩
/-- THE NINTH GATE, PACKED: a gate is the ninth exactly when all five readings hold of it. The five biconditionals
of ninth_gate_is_least_erasure, bound into one. -/
theorem ninth_gate_pack (t : Int) (T : Nat) (hT : 0 < T) (g : Gate) :
g = none ↔
(gfold g = g ∧ onLine (toChart t g) ∧ reg (toChart t g) = toChart t g ∧
price T (erased (gateCfg t g)) = 0 ∧ ¬ OwesBit g) := by
have h := ninth_gate_is_least_erasure t T hT g
constructor
· intro e
exact ⟨h.1.mpr e, h.2.1.mpr e, h.2.2.1.mpr e, h.2.2.2.1.mpr e, h.2.2.2.2.mpr e⟩
· intro hh
exact h.1.mp hh.1
/-- The deed of the substrate: a run, and the fact that it ran. -/
structure SubstrateDeed (Q : Type) where
run : Exec Q
didRun : ran run = true
/-- THE FREE BIT. A run whose flag is true leaves the value free: by the run the value does not stand on every
closed configuration. It is the_deed_forces_nothing read at the flag of the deed. A computation is a deed, and
the value is the field of the act. -/
theorem the_run_does_not_force_the_value {Q : Type} (s : Exec Q) (h : ran s = true) :
¬ (∀ S : Config, Closed S → Value S) :=
fun hall => the_deed_forces_nothing (ran s = true) h (fun S hS _ => hall S hS)
/-- THE FORCE-WITNESS CLOSURE. For a deed of the substrate, a term of the act, and any gate: the gate is the ninth
exactly when it is the fold's fixed point, on the line, erased nothing, free to register at a positive
temperature and owing no bit; the value holds on the field the act supplies; a run that ran exists; and the
run leaves the value free. The fourth conjunct is the free bit. It is the implementation of the force. -/
theorem force_witness_closure {Q : Type} (d : SubstrateDeed Q) (Z : ActualZeros)
(t : Int) (T : Nat) (hT : 0 < T) (g : Gate) :
(g = none ↔
(gfold g = g ∧ onLine (toChart t g) ∧ reg (toChart t g) = toChart t g ∧
price T (erased (gateCfg t g)) = 0 ∧ ¬ OwesBit g)) ∧
Value Z.zeros ∧
(∃ r : Exec Q, ran r = true) ∧
¬ (∀ S : Config, Closed S → Value S) :=
⟨ninth_gate_pack t T hT g,
value_from_the_act Z,
the_run_witnesses_a_run d.run d.didRun,
the_run_does_not_force_the_value d.run d.didRun⟩
/-- THE GUARD ON THE CLOSURE, the double defense restated: the value comes by the act; between the registered
world and the pair world of a point off the line, every reading that respects the record leaves the value
free; and the deed leaves it free. -/
theorem force_witness_guarded {Q : Type} (d : SubstrateDeed Q) (Z : ActualZeros) :
Value Z.zeros ∧
(∀ (p : Point), ¬ onLine p → ∀ (g : Config → Prop), (∀ S S', SameRecord S S' → (g S ↔ g S')) →
¬ ((g (registered p) ↔ Value (registered p)) ∧ (g (pairWorld p) ↔ Value (pairWorld p)))) ∧
¬ (∀ S : Config, Closed S → Value S) :=
⟨value_from_the_act Z,
fun p h g hg => record_decides_nothing p h g hg,
the_run_does_not_force_the_value d.run d.didRun⟩
end ForceWitness
/-! ## The cones, pinned. Each line is the compiler's own; a drifted cone fails the compile. -/
/-- info: 'ForceWitness.neg_neg_free' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.neg_neg_free
/-- info: 'ForceWitness.neg_self_zero' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.neg_self_zero
/-- info: 'ForceWitness.fold_involutive' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.fold_involutive
/-- info: 'ForceWitness.the_cut_is_the_line' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.the_cut_is_the_line
/-- info: 'ForceWitness.reg_lands' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.reg_lands
/-- info: 'ForceWitness.reg_erases_nothing_iff' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.reg_erases_nothing_iff
/-- info: 'ForceWitness.pair_world_closed' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.pair_world_closed
/-- info: 'ForceWitness.one_record' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.one_record
/-- info: 'ForceWitness.registered_has_value' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.registered_has_value
/-- info: 'ForceWitness.pair_world_lacks_value' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.pair_world_lacks_value
/-- info: 'ForceWitness.record_decides_nothing' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.record_decides_nothing
/-- info: 'ForceWitness.value_from_the_act' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.value_from_the_act
/-- info: 'ForceWitness.seat_is_the_ninth' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.seat_is_the_ninth
/-- info: 'ForceWitness.orient_ne_zero' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.orient_ne_zero
/-- info: 'ForceWitness.orient_flips' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.orient_flips
/-- info: 'ForceWitness.gate_carrier_equivariant' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.gate_carrier_equivariant
/-- info: 'ForceWitness.faithful_carrier_lands_only_the_ninth' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.faithful_carrier_lands_only_the_ninth
/-- info: 'ForceWitness.orientation_carrier_separates' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.orientation_carrier_separates
/-- info: 'ForceWitness.seat_owes_no_bit' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.seat_owes_no_bit
/-- info: 'ForceWitness.off_seat_owes_a_bit' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.off_seat_owes_a_bit
/-- info: 'ForceWitness.gate_heat_zero_iff_ninth' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.gate_heat_zero_iff_ninth
/-- info: 'ForceWitness.ninth_gate_is_least_erasure' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.ninth_gate_is_least_erasure
/-- info: 'ForceWitness.the_run_witnesses_a_run' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.the_run_witnesses_a_run
/-- info: 'ForceWitness.the_deed_forces_nothing' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.the_deed_forces_nothing
/-- info: 'ForceWitness.witness_proves_exists' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.witness_proves_exists
/-- info: 'ForceWitness.ninth_gate_pack' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.ninth_gate_pack
/-- info: 'ForceWitness.the_run_does_not_force_the_value' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.the_run_does_not_force_the_value
/-- info: 'ForceWitness.force_witness_closure' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.force_witness_closure
/-- info: 'ForceWitness.force_witness_guarded' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.force_witness_guarded
/-! ## The closure and its guard, printed. -/
#print axioms ForceWitness.force_witness_closure
#print axioms ForceWitness.force_witness_guarded
/-! ## THE PLUG · appended, nothing above changed. The run's true flag offered as the act's supply field. -/
namespace ForceWitness
/-- The plug, attempted: if a true flag supplied least erasure on every closed world, the run would force the value.
The compiler refuses it. -/
theorem the_plug_fails {Q : Type} (s : Exec Q) (h : ran s = true) :
¬ (ran s = true → ∀ S : Config, Closed S → LeastErasure S) :=
fun plug => the_run_does_not_force_the_value s h (fun S hS => value_from_the_act ⟨S, hS, plug h S hS⟩)
/-- What the plug does deliver: with the act's field beside the run, the value stands on that field, the run is
witnessed, and the run still leaves the value free. Run and field are two inputs, never one. -/
theorem the_plug_delivers {Q : Type} (d : SubstrateDeed Q) (Z : ActualZeros) :
Value Z.zeros ∧ (∃ r : Exec Q, ran r = true) ∧ ¬ (∀ S : Config, Closed S → Value S) :=
⟨value_from_the_act Z, the_run_witnesses_a_run d.run d.didRun, the_run_does_not_force_the_value d.run d.didRun⟩
end ForceWitness
end PartIVb
/-! # PART IV-c · the time kernel of the monism-fixed codex, verbatim, with the judge probe -/
section PartIVc
/-
The time kernel of the monism-fixed codex, carried verbatim: Codex.lean of the Master Codex v5.1.0 with the patch of
APEX-PSP-MONISM-FIXED-01 applied (patched sha256 22d908f7d3d2c96b…), its two TimeLocus sections, lines 7875 to 7947,
followed by the judge probe of this edition. Nothing in the carried lines is changed. The carried chart reads real
parts as the first edition's chart does at resolution one, x = 2·Re s, with heights in ℤ, and its counter-world's
off-line pair sits at x = 0 and 2, Re s = 0 and 1;
the judge probe states the same test on the offset chart inside the open strip, with the conjugate symmetry and the
empty low band, its off-line zeros at Re s = 1/4 and 3/4. Two names in a carried docstring,
`not_constructible_off_line` and `monism_witness_fails_in_counter_world`, are theorems of the patched codex outside
the carried lines; they are not in this seed and nothing here uses them.
-/
namespace TimeLocus
def onLine (p : Int × Int) : Prop := p.1 = 1
/-- A timed world: the locus at each time, and the zeros present at each time. -/
structure World where
locus : Nat → (Int × Int → Prop)
zeros : Nat → (Int × Int → Prop)
/-- TIME PSP premise: prior and posterior locus are the SAME locus, the line, at every time. -/
def SameLocus (W : World) : Prop := ∀ t p, W.locus t p ↔ onLine p
/-- The claim to be tested: every zero at every time is bound to the locus. -/
def Bound (W : World) : Prop := ∀ t p, W.zeros t p → W.locus t p
/-- Fold-invariance at every time: the functional equation acts at each iteration. -/
def FoldInv (W : World) : Prop := ∀ t p, W.zeros t p → W.zeros t (2 - p.1, p.2)
/-- 51. Given the same locus at all times, being bound IS the line property at all times. -/
theorem bound_iff_line (W : World) (h : SameLocus W) :
Bound W ↔ ∀ t p, W.zeros t p → onLine p :=
⟨fun b t p z => (h t p).mp (b t p z), fun l t p z => (h t p).mpr (l t p z)⟩
/-- 52, the test world. A world where the locus is the same line at every time, the fold acts at every
time, the on-line zero recurs at every time, and a mirror pair sits off the line at every time. -/
def testWorld : World :=
⟨fun _ p => onLine p, fun _ p => p = (1, 0) ∨ p = (0, 5) ∨ p = (2, 5)⟩
theorem test_same_locus : SameLocus testWorld := fun _ _ => Iff.rfl
theorem test_fold_inv : FoldInv testWorld := by
intro _ p hp
rcases hp with h | h | h <;> subst h
· exact Or.inl rfl
· exact Or.inr (Or.inr rfl)
· exact Or.inr (Or.inl rfl)
theorem test_not_bound : ¬ Bound testWorld := fun b => by
have := b 0 (0, 5) (Or.inr (Or.inl rfl)); cases this
/-- 52. Therefore SameLocus and FoldInv, at every time, do not imply Bound. -/
theorem time_does_not_bind :
¬ ∀ W : World, SameLocus W → FoldInv W → Bound W :=
fun h => test_not_bound (h testWorld test_same_locus test_fold_inv)
end TimeLocus
namespace TimeLocus
/-- Residual Monism read as the Codex states it: one involution serves both routes. -/
def sigmaGeo (p : Int × Int) : Int × Int := (2 - p.1, p.2)
def sigmaForm (p : Int × Int) : Int × Int := (2 - p.1, p.2)
def OneInvolution : Prop := ∀ p, sigmaGeo p = sigmaForm p
/-- Residual Monism read as timeless: whether the zeros sit on the locus does not vary in time. -/
def P (W : World) (t : Nat) : Prop := ∀ p, W.zeros t p → onLine p
def Timeless (W : World) : Prop := ∀ t s, P W t ↔ P W s
/-- 53. The seedless reading holds in the counter-world: one involution by rfl, and timelessness
because the property "all zeros on the line" is constantly false there. Timeless and unbound.
This is not monism. The monism witness carries its seed, and in the counter-world it fails
(`not_constructible_off_line`, `monism_witness_fails_in_counter_world`). -/
theorem seedless_reading_holds_in_counter_world :
OneInvolution ∧ Timeless testWorld ∧ ¬ Bound testWorld :=
⟨fun _ => rfl, fun _ _ => Iff.rfl, test_not_bound⟩
/-- 54. What timeless monism does do: it makes one instant decide all time. With the seed, binding
follows; the seed is "every zero present at the instant is on the line". -/
theorem timeless_with_seed_binds (W : World) (h : SameLocus W) (u : Timeless W) (s0 : P W 0) :
Bound W :=
(bound_iff_line W h).mpr (fun t p z => ((u 0 t).mp s0) p z)
end TimeLocus
namespace Judge
open TimeLocus
/-- The identical locus, the fold at every time, one involution and timelessness together do not exclude a zero off
the line: the counter-world carries all four. -/
theorem identical_locus_does_not_exclude :
¬ ∀ W : World, SameLocus W → FoldInv W → OneInvolution → Timeless W → Bound W :=
fun h => test_not_bound (h testWorld test_same_locus test_fold_inv (fun _ => rfl) (fun _ _ => Iff.rfl))
/-- What does exclude it: on the same locus and timeless, being bound is exactly the seed at time zero. -/
theorem the_seed_is_exactly_what_binds (W : World) (h : SameLocus W) (u : Timeless W) : Bound W ↔ P W 0 :=
⟨fun b => fun p z => ((bound_iff_line W h).mp b) 0 p z, fun s0 => timeless_with_seed_binds W h u s0⟩
/-- The same test on the offset chart, d = 8·Re s − 4, inside the open strip: at every time the line occupied at every
height |t| ≥ 14, and one mirrored pair at Re s = 1/4 and 3/4 at height 3·10¹² + 1 with its conjugate. -/
def offsetWorld (_ : Nat) (p : RememberedOffered.Point) : Prop :=
(p.1 = 0 ∧ (14 ≤ p.2 ∨ p.2 ≤ -14)) ∨ p = (2, 3000000000001) ∨ p = (-2, 3000000000001) ∨
p = (2, -3000000000001) ∨ p = (-2, -3000000000001)
/-- Bound on the offset chart: every zero at every time on the line, the same locus at every time. -/
def BoundO (Z : Nat → RememberedOffered.Config) : Prop := ∀ t p, Z t p → RememberedOffered.onLine p
/-- Timeless on the offset chart: whether every zero sits on the line does not vary in time. -/
def TimelessO (Z : Nat → RememberedOffered.Config) : Prop :=
∀ t s, (∀ p, Z t p → RememberedOffered.onLine p) ↔ (∀ p, Z s p → RememberedOffered.onLine p)
/-- THE IDENTICAL LOCUS INSIDE THE STRIP DOES NOT EXCLUDE: on the offset chart, the same locus at every time, the fold
and conjugation at every time, the empty low band, every zero strictly inside the strip (Re s strictly between 0
and 1) and timelessness hold together on a world that is not bound; and on every timeless world being bound is
exactly the seed at time zero. -/
theorem identical_locus_inside_the_strip_does_not_exclude :
(∀ t, RememberedOffered.Closed (offsetWorld t)) ∧
(∀ t p, offsetWorld t p → offsetWorld t (p.1, -p.2)) ∧
(∀ t p, offsetWorld t p → 14 ≤ p.2 ∨ p.2 ≤ -14) ∧
(∀ t p, offsetWorld t p → -4 < p.1 ∧ p.1 < 4) ∧
TimelessO offsetWorld ∧ ¬ BoundO offsetWorld ∧
(∀ Z : Nat → RememberedOffered.Config, TimelessO Z →
(BoundO Z ↔ ∀ p, Z 0 p → RememberedOffered.onLine p)) := by
refine ⟨fun t p hp => ?_, fun t p hp => ?_, fun t p hp => ?_, fun t p hp => ?_, fun _ _ => Iff.rfl, ?_, ?_⟩
· unfold offsetWorld at hp ⊢
rcases hp with ⟨h1, h2⟩ | h | h | h | h
· exact Or.inl ⟨show -p.1 = 0 by omega, h2⟩
· subst h; exact Or.inr (Or.inr (Or.inl (by decide)))
· subst h; exact Or.inr (Or.inl (by decide))
· subst h; exact Or.inr (Or.inr (Or.inr (Or.inr (by decide))))
· subst h; exact Or.inr (Or.inr (Or.inr (Or.inl (by decide))))
· unfold offsetWorld at hp ⊢
rcases hp with ⟨h1, h2⟩ | h | h | h | h
· exact Or.inl ⟨h1, by omega⟩
· subst h; exact Or.inr (Or.inr (Or.inr (Or.inl (by decide))))
· subst h; exact Or.inr (Or.inr (Or.inr (Or.inr (by decide))))
· subst h; exact Or.inr (Or.inl (by decide))
· subst h; exact Or.inr (Or.inr (Or.inl (by decide)))
· unfold offsetWorld at hp
rcases hp with ⟨_, h2⟩ | h | h | h | h
· exact h2
all_goals (subst h; decide)
· unfold offsetWorld at hp
rcases hp with ⟨h1, _⟩ | h | h | h | h
· constructor <;> omega
all_goals (subst h; decide)
· intro b
have h : (2 : Int) = 0 := b 0 (2, 3000000000001) (Or.inr (Or.inl rfl))
exact absurd h (by decide)
· intro Z u
exact ⟨fun b => b 0, fun s0 t p z => ((u 0 t).mp s0) p z⟩
end Judge
end PartIVc
/-! # PART V · the arrow-side test -/
section PartV
/-
ARROW SIDE TEST · the ζ-specific facts, placed on RA's arrow, tested against an off-line pair.
Core Lean 4.19.0, no import, no axiom declared, no sorry.
Chart: x = 2W·Re s at resolution W, height t. The arrow's tail pole s = 0 sits at x = 0, its head pole s = 1 at
x = 2W, its hinge Re s = 1/2 at x = W. The Euler product lives beyond the head.
Each fact ζ has and the Davenport–Heilbronn shape lacks, or that is proved for ζ, enters as a predicate at its
place on the arrow, its source cited:
ENDS Build and Edge: no zero at or beyond either pole (Euler product for Re s > 1; the prime number theorem's
non-vanishing on Re s = 1; mirrored by the functional equation) [cited].
ZERO-FREE near the head, and by the fold near the tail: at height t no zero within m t of a pole
(de la Vallée Poussin; explicit constants Mossinghoff–Trudgian) [cited]; the margin is a parameter.
REAL PART every zero up to height T0 on the line (Platt–Trudgian: every zero with 0 < Im s ≤ 3·10¹²) [cited];
heights are read by their integer part, so chart height T0 = 3·10¹² − 1 reads Im s < 3·10¹².
FINITELY OFF only finitely many zeros off the line: stronger than every positive-proportion theorem
(Selberg, Levinson, Conrey) and every zero-density estimate [cited].
-/
set_option autoImplicit false
namespace ArrowSide
abbrev Pt := Int × Int
structure Chart where
W : Int
hW : 0 < W
def onLine (C : Chart) (p : Pt) : Prop := p.1 = C.W
def fold (C : Chart) (p : Pt) : Pt := (2 * C.W - p.1, p.2)
def Closed (C : Chart) (S : Pt → Prop) : Prop := ∀ p, S p → S (fold C p)
def Value (C : Chart) (S : Pt → Prop) : Prop := ∀ p, S p → onLine C p
def ArrowEnds (C : Chart) (S : Pt → Prop) : Prop := ∀ p, S p → 0 < p.1 ∧ p.1 < 2 * C.W
def ZeroFree (C : Chart) (m : Int → Int) (S : Pt → Prop) : Prop :=
∀ p, S p → m p.2 < p.1 ∧ p.1 < 2 * C.W - m p.2
def RealPart (C : Chart) (T0 : Int) (S : Pt → Prop) : Prop := ∀ p, S p → p.2 ≤ T0 → onLine C p
def FinitelyOff (C : Chart) (S : Pt → Prop) : Prop := ∃ L : List Pt, ∀ p, S p → ¬ onLine C p → p ∈ L
/-- The ζ-shaped world: a zero on the line at every height, and one mirrored pair at offset d, height H. -/
def zetaShaped (C : Chart) (d H : Int) : Pt → Prop :=
fun p => p.1 = C.W ∨ p = (C.W - d, H) ∨ p = (C.W + d, H)
theorem shaped_closed (C : Chart) (d H : Int) : Closed C (zetaShaped C d H) := by
intro p hp
unfold zetaShaped at hp ⊢
rcases hp with h | h | h
· left; show 2 * C.W - p.1 = C.W; omega
· subst h; right; right; exact Prod.ext (show 2 * C.W - (C.W - d) = C.W + d by omega) rfl
· subst h; right; left; exact Prod.ext (show 2 * C.W - (C.W + d) = C.W - d by omega) rfl
theorem shaped_ends (C : Chart) (d H : Int) (hd : 0 < d) (hdW : d < C.W) : ArrowEnds C (zetaShaped C d H) := by
have hW := C.hW
intro p hp
unfold zetaShaped at hp
rcases hp with h | h | h
· constructor <;> omega
· subst h; show 0 < C.W - d ∧ C.W - d < 2 * C.W; constructor <;> omega
· subst h; show 0 < C.W + d ∧ C.W + d < 2 * C.W; constructor <;> omega
theorem shaped_zero_free (C : Chart) (m : Int → Int) (hm : ∀ t, m t < C.W) (d H : Int) (hmH : m H < C.W - d)
(hd : 0 < d) : ZeroFree C m (zetaShaped C d H) := by
intro p hp
unfold zetaShaped at hp
rcases hp with h | h | h
· have := hm p.2; constructor <;> omega
· subst h; show m H < C.W - d ∧ C.W - d < 2 * C.W - m H; constructor <;> omega
· subst h; show m H < C.W + d ∧ C.W + d < 2 * C.W - m H; constructor <;> omega
theorem shaped_real_part (C : Chart) (T0 d H : Int) (hH : T0 < H) : RealPart C T0 (zetaShaped C d H) := by
intro p hp ht
unfold zetaShaped at hp
rcases hp with h | h | h
· exact h
· subst h; have : H ≤ T0 := ht; exfalso; omega
· subst h; have : H ≤ T0 := ht; exfalso; omega
theorem shaped_finitely_off (C : Chart) (d H : Int) : FinitelyOff C (zetaShaped C d H) := by
refine ⟨[(C.W - d, H), (C.W + d, H)], fun p hp hoff => ?_⟩
unfold zetaShaped at hp
rcases hp with h | h | h
· exact absurd h hoff
· subst h; exact List.Mem.head _
· subst h; exact List.Mem.tail _ (List.Mem.head _)
theorem shaped_lacks_value (C : Chart) (d H : Int) (hd : 0 < d) : ¬ Value C (zetaShaped C d H) := by
intro hv
have h2 : C.W - d = C.W := hv (C.W - d, H) (Or.inr (Or.inl rfl))
omega
/-- THE ARROW SIDE TEST. Every ζ-specific fact placed on the arrow (ends, zero-free region, real part to T0,
finitely many off the line) holds on a world with a mirrored pair off the line above T0, so together they do
not force the value. -/
theorem arrow_side_test (C : Chart) (m : Int → Int) (hm : ∀ t, m t < C.W) (T0 d H : Int)
(hd : 0 < d) (hdW : d < C.W) (hH : T0 < H) (hmH : m H < C.W - d) :
Closed C (zetaShaped C d H) ∧ ArrowEnds C (zetaShaped C d H) ∧ ZeroFree C m (zetaShaped C d H) ∧
RealPart C T0 (zetaShaped C d H) ∧ FinitelyOff C (zetaShaped C d H) ∧ ¬ Value C (zetaShaped C d H) :=
⟨shaped_closed C d H, shaped_ends C d H hd hdW, shaped_zero_free C m hm d H hmH hd,
shaped_real_part C T0 d H hH, shaped_finitely_off C d H, shaped_lacks_value C d H hd⟩
/-- THE FACTS ARE ζ-SPECIFIC AT THE ENDS: a zero beyond the head, the Davenport–Heilbronn shape, breaks ENDS. -/
theorem beyond_the_head_breaks_ends (C : Chart) (x t : Int) (hx : 2 * C.W ≤ x) :
¬ ArrowEnds C (fun p => p = (x, t)) := by
intro h
have h2 : x < 2 * C.W := (h (x, t) rfl).2
omega
/-- AT ζ'S OWN NUMBERS: resolution W = 4, so x = 8·Re s; the pair at Re s = 1/4 and 3/4 (x = 2 and 6); the
zero-free margin below one unit of 1/8 at every height where zeros occur (c/log t < 0.07 for t ≥ 14); the real
part to chart height T0 = 3·10¹² − 1, every zero with Im s < 3·10¹²; the pair two units of height above it. -/
def zetaChart : Chart := ⟨4, by decide⟩
theorem at_zetas_numbers :
Closed zetaChart (zetaShaped zetaChart 2 3000000000001) ∧
ArrowEnds zetaChart (zetaShaped zetaChart 2 3000000000001) ∧
ZeroFree zetaChart (fun _ => 0) (zetaShaped zetaChart 2 3000000000001) ∧
RealPart zetaChart 2999999999999 (zetaShaped zetaChart 2 3000000000001) ∧
FinitelyOff zetaChart (zetaShaped zetaChart 2 3000000000001) ∧
¬ Value zetaChart (zetaShaped zetaChart 2 3000000000001) :=
arrow_side_test zetaChart (fun _ => 0) (fun _ => show (0 : Int) < 4 by decide) 2999999999999 2 3000000000001
(by decide) (by decide) (by decide) (by decide)
/-! ## The faithful model: the facts of ζ with its two symmetries and its empty low band -/
/-- Conjugate symmetry: the zero set is closed under t ↦ −t. -/
def ConjClosed (S : Pt → Prop) : Prop := ∀ p, S p → S (p.1, -p.2)
/-- No zero below height 14 in absolute value: ζ's first zero lies at height 14.13… [cited]; heights read by their
integer part, chart height 14 holds Im s in [14, 15). -/
def NoLowZeros (S : Pt → Prop) : Prop := ∀ p, S p → 14 ≤ p.2 ∨ p.2 ≤ -14
/-- The verification in both half-planes: every zero at chart height |t| ≤ T0 is on the line; at T0 = 3·10¹² − 1,
every zero with |Im s| < 3·10¹² [Platt–Trudgian, cited]. -/
def RealPartAbs (C : Chart) (T0 : Int) (S : Pt → Prop) : Prop := ∀ p, S p → p.2 ≤ T0 → -T0 ≤ p.2 → onLine C p
/-- The zero-free margin, in units of 1/(2W): the whole width below |t| = 14, where ζ has no zero, and no unit at
every height |t| ≥ 14. At every width it holds of ζ's reading, since it adds nothing to the ends there and the
reader's rule keeps every zero of the open strip inside the open chart strip; at the widths W ≤ 7 it is the
region at full strength, since c/log t < 0.07 < 1/(2W). `faithful_every_margin` carries the region at every
width, one unit short for the rounding. -/
def margin14 (C : Chart) : Int → Int := fun t => if 14 ≤ t ∨ t ≤ -14 then 0 else C.W
/-- The faithful ζ-shaped world: a zero on the line at every height |t| ≥ 14, and one mirrored pair at offset d at
heights H and −H. -/
def zetaFaithful (C : Chart) (d H : Int) : Pt → Prop := fun p =>
(p.1 = C.W ∧ (14 ≤ p.2 ∨ p.2 ≤ -14)) ∨ p = (C.W - d, H) ∨ p = (C.W + d, H) ∨
p = (C.W - d, -H) ∨ p = (C.W + d, -H)
theorem faithful_arrow_side_test (C : Chart) (T0 d H : Int) (hd : 0 < d) (hdW : d < C.W) (hH : T0 < H)
(h14 : 14 ≤ H) :
Closed C (zetaFaithful C d H) ∧ ConjClosed (zetaFaithful C d H) ∧ ArrowEnds C (zetaFaithful C d H) ∧
ZeroFree C (margin14 C) (zetaFaithful C d H) ∧ NoLowZeros (zetaFaithful C d H) ∧
RealPartAbs C T0 (zetaFaithful C d H) ∧ FinitelyOff C (zetaFaithful C d H) ∧
¬ Value C (zetaFaithful C d H) := by
have hW := C.hW
refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· intro p hp
unfold zetaFaithful at hp ⊢
rcases hp with ⟨h1, h2⟩ | h | h | h | h
· left; exact ⟨show 2 * C.W - p.1 = C.W by omega, h2⟩
· subst h; right; right; left; exact Prod.ext (show 2 * C.W - (C.W - d) = C.W + d by omega) rfl
· subst h; right; left; exact Prod.ext (show 2 * C.W - (C.W + d) = C.W - d by omega) rfl
· subst h; right; right; right; right; exact Prod.ext (show 2 * C.W - (C.W - d) = C.W + d by omega) rfl
· subst h; right; right; right; left; exact Prod.ext (show 2 * C.W - (C.W + d) = C.W - d by omega) rfl
· intro p hp
unfold zetaFaithful at hp ⊢
rcases hp with ⟨h1, h2⟩ | h | h | h | h
· left; exact ⟨h1, show 14 ≤ -p.2 ∨ -p.2 ≤ -14 by omega⟩
· subst h; right; right; right; left; rfl
· subst h; right; right; right; right; rfl
· subst h; right; left; exact Prod.ext rfl (show -(-H) = H by omega)
· subst h; right; right; left; exact Prod.ext rfl (show -(-H) = H by omega)
· intro p hp
unfold zetaFaithful at hp
rcases hp with ⟨h1, _⟩ | h | h | h | h
· constructor <;> omega
all_goals (subst h; constructor <;> (show (_ : Int) < _; omega))
· intro p hp
unfold zetaFaithful at hp
unfold margin14
rcases hp with ⟨h1, h2⟩ | h | h | h | h
· rw [if_pos h2]; constructor <;> omega
· subst h; rw [if_pos (Or.inl h14)]; show (0 : Int) < C.W - d ∧ C.W - d < 2 * C.W - 0; constructor <;> omega
· subst h; rw [if_pos (Or.inl h14)]; show (0 : Int) < C.W + d ∧ C.W + d < 2 * C.W - 0; constructor <;> omega
· subst h; rw [if_pos (Or.inr (show -H ≤ -14 by omega))]
show (0 : Int) < C.W - d ∧ C.W - d < 2 * C.W - 0; constructor <;> omega
· subst h; rw [if_pos (Or.inr (show -H ≤ -14 by omega))]
show (0 : Int) < C.W + d ∧ C.W + d < 2 * C.W - 0; constructor <;> omega
· intro p hp
unfold zetaFaithful at hp
rcases hp with ⟨_, h2⟩ | h | h | h | h
· exact h2
· subst h; exact Or.inl h14
· subst h; exact Or.inl h14
· subst h; exact Or.inr (show -H ≤ -14 by omega)
· subst h; exact Or.inr (show -H ≤ -14 by omega)
· intro p hp ht1 ht2
unfold zetaFaithful at hp
rcases hp with ⟨h1, _⟩ | h | h | h | h
· exact h1
· subst h; have : H ≤ T0 := ht1; exfalso; omega
· subst h; have : H ≤ T0 := ht1; exfalso; omega
· subst h; have : -T0 ≤ -H := ht2; exfalso; omega
· subst h; have : -T0 ≤ -H := ht2; exfalso; omega
· refine ⟨[(C.W - d, H), (C.W + d, H), (C.W - d, -H), (C.W + d, -H)], fun p hp hoff => ?_⟩
unfold zetaFaithful at hp
rcases hp with ⟨h1, _⟩ | h | h | h | h
· exact absurd h1 hoff
· subst h; exact List.Mem.head _
· subst h; exact List.Mem.tail _ (List.Mem.head _)
· subst h; exact List.Mem.tail _ (List.Mem.tail _ (List.Mem.head _))
· subst h; exact List.Mem.tail _ (List.Mem.tail _ (List.Mem.tail _ (List.Mem.head _)))
· intro hv
have h2 : C.W - d = C.W := hv (C.W - d, H) (Or.inr (Or.inl rfl))
omega
/-- AT ζ'S OWN NUMBERS, FAITHFULLY: W = 4, so x = 8·Re s; the pair at Re s = 1/4 and 3/4 at height 3·10¹² + 1 and
its conjugate at −(3·10¹² + 1); the line occupied at every |t| ≥ 14; the verification, every zero with
|Im s| < 3·10¹², at chart height 3·10¹² − 1 in both half-planes. -/
theorem at_zetas_numbers_faithful :
Closed zetaChart (zetaFaithful zetaChart 2 3000000000001) ∧
ConjClosed (zetaFaithful zetaChart 2 3000000000001) ∧
ArrowEnds zetaChart (zetaFaithful zetaChart 2 3000000000001) ∧
ZeroFree zetaChart (margin14 zetaChart) (zetaFaithful zetaChart 2 3000000000001) ∧
NoLowZeros (zetaFaithful zetaChart 2 3000000000001) ∧
RealPartAbs zetaChart 2999999999999 (zetaFaithful zetaChart 2 3000000000001) ∧
FinitelyOff zetaChart (zetaFaithful zetaChart 2 3000000000001) ∧
¬ Value zetaChart (zetaFaithful zetaChart 2 3000000000001) :=
faithful_arrow_side_test zetaChart 2999999999999 2 3000000000001 (by decide) (by decide) (by decide) (by decide)
/-- THE FAITHFUL MODEL UNDER EVERY ZERO-FREE MARGIN: at every chart width and for every margin that, at the heights
where zeros occur, stays short of the line and leaves the off-line quadruple outside it at ±H, the facts hold on
the faithful world and the value fails. ζ's known region, c/log|t| in Re s with c/log 14 < 0.07 and
c/log(3·10¹²) < 0.0065, read in units of 1/(2W), is such a margin at every width for the pair at Re s = 1/4 and
3/4 [Mossinghoff–Trudgian 2015, cited]. -/
theorem faithful_every_margin (C : Chart) (m : Int → Int) (T0 d H : Int) (hd : 0 < d) (hdW : d < C.W)
(hH : T0 < H) (h14 : 14 ≤ H) (hm : ∀ t, (14 ≤ t ∨ t ≤ -14) → m t < C.W)
(hmH : m H < C.W - d) (hmH' : m (-H) < C.W - d) :
Closed C (zetaFaithful C d H) ∧ ConjClosed (zetaFaithful C d H) ∧ ArrowEnds C (zetaFaithful C d H) ∧
ZeroFree C m (zetaFaithful C d H) ∧ NoLowZeros (zetaFaithful C d H) ∧
RealPartAbs C T0 (zetaFaithful C d H) ∧ FinitelyOff C (zetaFaithful C d H) ∧
¬ Value C (zetaFaithful C d H) := by
have base := faithful_arrow_side_test C T0 d H hd hdW hH h14
refine ⟨base.1, base.2.1, base.2.2.1, ?_, base.2.2.2.2.1, base.2.2.2.2.2.1, base.2.2.2.2.2.2.1,
base.2.2.2.2.2.2.2⟩
intro p hp
unfold zetaFaithful at hp
rcases hp with ⟨h1, h2⟩ | h | h | h | h
· have := hm p.2 h2; constructor <;> omega
· subst h; show m H < C.W - d ∧ C.W - d < 2 * C.W - m H; constructor <;> omega
· subst h; show m H < C.W + d ∧ C.W + d < 2 * C.W - m H; constructor <;> omega
· subst h; show m (-H) < C.W - d ∧ C.W - d < 2 * C.W - m (-H); constructor <;> omega
· subst h; show m (-H) < C.W + d ∧ C.W + d < 2 * C.W - m (-H); constructor <;> omega
/-- AT WIDTH ONE THE ENDS ARE THE VALUE: the open strip holds only the line, so the placed ends force the value there,
as at the first edition's resolution one; the faithful model needs a width of at least two. -/
theorem at_width_one_the_ends_are_the_value (S : Pt → Prop) :
ArrowEnds ⟨1, by decide⟩ S ↔ Value ⟨1, by decide⟩ S := by
constructor
· intro h p hp
have := h p hp
show p.1 = 1
have h1 : 0 < p.1 ∧ p.1 < 2 * 1 := this
omega
· intro h p hp
have h1 : p.1 = 1 := h p hp
show 0 < p.1 ∧ p.1 < 2 * 1
omega
/-- AN OFF-LINE ZERO COMES IN FOUR: in a world closed under the reflection and under conjugation, with no zero below
height 14, a zero off the line brings its mirror, its conjugate and its conjugate's mirror, four distinct points:
one mirrored pair and its conjugate. -/
theorem an_off_line_zero_comes_in_four (C : Chart) (S : Pt → Prop) (hc : Closed C S) (hk : ConjClosed S)
(hl : NoLowZeros S) (p : Pt) (hp : S p) (hoff : ¬ onLine C p) :
S (fold C p) ∧ S (p.1, -p.2) ∧ S (fold C (p.1, -p.2)) ∧
fold C p ≠ p ∧ (p.1, -p.2) ≠ p ∧ fold C (p.1, -p.2) ≠ p ∧
(p.1, -p.2) ≠ fold C p ∧ fold C (p.1, -p.2) ≠ fold C p ∧ fold C (p.1, -p.2) ≠ (p.1, -p.2) := by
have h14 := hl p hp
refine ⟨hc p hp, hk p hp, hc _ (hk p hp), ?_⟩
obtain ⟨x, t⟩ := p
have hx : x ≠ C.W := hoff
have ht : 14 ≤ t ∨ t ≤ -14 := h14
refine ⟨fun e => ?_, fun e => ?_, fun e => ?_, fun e => ?_, fun e => ?_, fun e => ?_⟩
· have h1 : 2 * C.W - x = x := congrArg Prod.fst e
omega
· have h2 : -t = t := congrArg Prod.snd e
omega
· have h2 : -t = t := congrArg Prod.snd e
omega
· have h2 : -t = t := congrArg Prod.snd e
omega
· have h2 : -t = t := congrArg Prod.snd e
omega
· have h1 : 2 * C.W - x = x := congrArg Prod.fst e
omega
end ArrowSide
end PartV
/-! # PART V-b · the charts are one -/
section PartVb
/-
THE CHARTS ARE ONE. The seed reads the critical line on five charts: Part II's at x = 2n·Re s for every resolution n
(x = 2·Re s at resolution one, x = 4·Re s at resolution two), heights in ℕ; Part IV's at x = 4·Re s; Part IV-c's at
x = 2·Re s, heights in ℤ; Part V's at x = 2W·Re s for every width W; and the offset chart of Parts III and IV-b,
d = 2n·Re s − n at resolution n, whose line d = 0 and fold d ↦ −d are the same at every resolution. Each maps into
the offset chart at a definite resolution by an equivariant map, one that carries the chart's fold to the offset
fold and the chart's line to the offset line: the maps of Parts II at resolutions one and two, IV, IV-c and V at
width four land at resolution four, where one real part read on any of them lands at one offset point; the maps
at resolution n and width W land at resolution n and W. Every map keeps the chart's height and scales the offset
from the line by a positive factor; the maps out of the charts with heights in ℤ commute with conjugation, and
the first edition's chart reads the upper half-plane. Transport carries
reflection-closure and the value across. Every act type of the seed is an act of the offset chart at the image of
its zero set; the root read at the zeros on Part II's chart is the root read twice at the image; both constructed
roots, Part I's and Part II's, feed the closing theorems. The zero set of ζ is read on the offset chart at every
resolution by the reader's rule, and the act supplies least erasure at every resolution.
-/
set_option autoImplicit false
namespace Charts
/-- The image of a configuration under a chart map into the offset chart. -/
def img {α : Type} (φ : α → RememberedOffered.Point) (S : α → Prop) : RememberedOffered.Config :=
fun q => ∃ p, S p ∧ φ p = q
/-- A chart map is equivariant when it carries the chart's fold to the offset fold and the chart's line to the
offset line. -/
structure Equivariant {α : Type} (fold : α → α) (onLine : α → Prop) (φ : α → RememberedOffered.Point) : Prop where
comm : ∀ p, φ (fold p) = RememberedOffered.fold (φ p)
line : ∀ p, RememberedOffered.onLine (φ p) ↔ onLine p
/-- TRANSPORT: an equivariant map carries reflection-closure across, and the value both ways. -/
theorem transport {α : Type} {fold : α → α} {onLine : α → Prop} {φ : α → RememberedOffered.Point}
(E : Equivariant fold onLine φ) (S : α → Prop) :
((∀ p, S p → S (fold p)) → RememberedOffered.Closed (img φ S)) ∧
((∀ p, S p → onLine p) ↔ RememberedOffered.Value (img φ S)) := by
refine ⟨fun hS q ⟨p, hp, e⟩ => ⟨fold p, hS p hp, by rw [E.comm, e]⟩,
⟨fun hv q ⟨p, hp, e⟩ => ?_, fun hv p hp => (E.line p).mp (hv _ ⟨p, hp, rfl⟩)⟩⟩
rw [← e]; exact (E.line p).mpr (hv p hp)
/-- Part IV's chart, x = 4·Re s, into the offset chart d = 8·Re s − 4. -/
def φH (p : Hinge.Pt) : RememberedOffered.Point := (2 * p.1 - 4, p.2)
/-- Part V's chart at ζ's resolution, x = 8·Re s, into the offset chart. -/
def φA (p : ArrowSide.Pt) : RememberedOffered.Point := (p.1 - 4, p.2)
/-- Part II's chart, x = 2·Re s with heights in ℕ, into the offset chart. -/
def φP (z : PrimeFreedom.Pt) : RememberedOffered.Point := (4 * z.x - 4, (z.t : Int))
/-- Part II's chart at resolution two, x = 4·Re s, into the offset chart. -/
def φP₂ (z : PrimeFreedom.Pt) : RememberedOffered.Point := (2 * z.x - 4, (z.t : Int))
/-- Part V's chart at every width W, x = 2W·Re s, into the offset chart at resolution W: d = x − W. -/
def φW (C : ArrowSide.Chart) (p : ArrowSide.Pt) : RememberedOffered.Point := (p.1 - C.W, p.2)
/-- Part II's chart at every resolution n, x = 2n·Re s with heights in ℕ, into the offset chart at resolution n. -/
def φPn (n : Int) (z : PrimeFreedom.Pt) : RememberedOffered.Point := (z.x - n, (z.t : Int))
/-- Part IV-c's chart, x = 2·Re s with heights in ℤ, into the offset chart. -/
def φT (p : Int × Int) : RememberedOffered.Point := (4 * p.1 - 4, p.2)
/-- Part IV-b's chart is the offset chart: the identity. -/
def φF (p : ForceWitness.Point) : RememberedOffered.Point := p
theorem eqH : Equivariant Hinge.fold Hinge.onLine φH :=
⟨fun p => Prod.ext (show 2 * (0 + 4 - p.1) - 4 = -(2 * p.1 - 4) by omega) rfl,
fun p => show 2 * p.1 - 4 = 0 ↔ p.1 = 2 by omega⟩
theorem eqA : Equivariant (ArrowSide.fold ArrowSide.zetaChart) (ArrowSide.onLine ArrowSide.zetaChart) φA :=
⟨fun p => Prod.ext (show 2 * 4 - p.1 - 4 = -(p.1 - 4) by omega) rfl,
fun p => show p.1 - 4 = 0 ↔ p.1 = 4 by omega⟩
theorem eqP : Equivariant PrimeFreedom.fold PrimeFreedom.onLine φP :=
⟨fun z => Prod.ext (show 4 * (2 - z.x) - 4 = -(4 * z.x - 4) by omega) rfl,
fun z => show 4 * z.x - 4 = 0 ↔ z.x = 1 by omega⟩
theorem eqP₂ : Equivariant PrimeFreedom.fold₂ PrimeFreedom.onLine₂ φP₂ :=
⟨fun z => Prod.ext (show 2 * (4 - z.x) - 4 = -(2 * z.x - 4) by omega) rfl,
fun z => show 2 * z.x - 4 = 0 ↔ z.x = 2 by omega⟩
theorem eqW (C : ArrowSide.Chart) : Equivariant (ArrowSide.fold C) (ArrowSide.onLine C) (φW C) :=
⟨fun p => Prod.ext (show 2 * C.W - p.1 - C.W = -(p.1 - C.W) by omega) rfl,
fun p => show p.1 - C.W = 0 ↔ p.1 = C.W by omega⟩
theorem eqPn (n : Int) : Equivariant (PrimeFreedom.foldAt n) (fun z => z.x = n) (φPn n) :=
⟨fun z => Prod.ext (show 2 * n - z.x - n = -(z.x - n) by omega) rfl,
fun z => show z.x - n = 0 ↔ z.x = n by omega⟩
theorem eqT : Equivariant TimeLocus.sigmaGeo TimeLocus.onLine φT :=
⟨fun p => Prod.ext (show 4 * (2 - p.1) - 4 = -(4 * p.1 - 4) by omega) rfl,
fun p => show 4 * p.1 - 4 = 0 ↔ p.1 = 1 by omega⟩
theorem eqF : Equivariant ForceWitness.fold ForceWitness.onLine φF :=
⟨fun _ => rfl, fun _ => Iff.rfl⟩
/-- EVERY MAP KEEPS HEIGHT AND SCALES THE OFFSET from the line by a positive factor. -/
theorem the_maps_keep_height_and_scale :
(∀ p : Hinge.Pt, φH p = (2 * (p.1 - 2), p.2)) ∧
(∀ p : ArrowSide.Pt, φA p = (1 * (p.1 - 4), p.2)) ∧
(∀ (C : ArrowSide.Chart) (p : ArrowSide.Pt), φW C p = (1 * (p.1 - C.W), p.2)) ∧
(∀ z : PrimeFreedom.Pt, φP z = (4 * (z.x - 1), (z.t : Int))) ∧
(∀ z : PrimeFreedom.Pt, φP₂ z = (2 * (z.x - 2), (z.t : Int))) ∧
(∀ (n : Int) (z : PrimeFreedom.Pt), φPn n z = (1 * (z.x - n), (z.t : Int))) ∧
(∀ p : Int × Int, φT p = (4 * (p.1 - 1), p.2)) ∧
(∀ p : ForceWitness.Point, φF p = (1 * (p.1 - 0), p.2)) :=
⟨fun p => Prod.ext (show 2 * p.1 - 4 = 2 * (p.1 - 2) by omega) rfl,
fun p => Prod.ext (show p.1 - 4 = 1 * (p.1 - 4) by omega) rfl,
fun C p => Prod.ext (show p.1 - C.W = 1 * (p.1 - C.W) by omega) rfl,
fun z => Prod.ext (show 4 * z.x - 4 = 4 * (z.x - 1) by omega) rfl,
fun z => Prod.ext (show 2 * z.x - 4 = 2 * (z.x - 2) by omega) rfl,
fun n z => Prod.ext (show z.x - n = 1 * (z.x - n) by omega) rfl,
fun p => Prod.ext (show 4 * p.1 - 4 = 4 * (p.1 - 1) by omega) rfl,
fun p => Prod.ext (show p.1 = 1 * (p.1 - 0) by omega) rfl⟩
/-- The first edition's act, carried to the offset chart at the image of its zero set. -/
def actP (A : PrimeFreedom.ActualZeros) : RememberedOffered.ActualZeros :=
⟨img φP A.zeros, (transport eqP A.zeros).1 A.fold_closed,
(RememberedOffered.twins_on_every_world _).mpr ((transport eqP A.zeros).2.mp (PrimeFreedom.rh_from_the_act A))⟩
/-- The first edition's act at every resolution n, carried to the offset chart at the image of its zero set. -/
def actPn (n : Int) (A : PrimeFreedom.ActualZerosAt n) : RememberedOffered.ActualZeros :=
⟨img (φPn n) A.zeros, (transport (eqPn n) A.zeros).1 A.closed,
(RememberedOffered.twins_on_every_world _).mpr ((transport (eqPn n) A.zeros).2.mp
(fun z hz => (PrimeFreedom.foldAt_fixed_iff n z).mp (PrimeFreedom.rh_from_the_act_at n A z hz)))⟩
/-- Part IV's act, carried to the offset chart at the image of its zero set. -/
def actH (A : Hinge.ActualZeros) : RememberedOffered.ActualZeros :=
⟨img φH A.zeros, (transport eqH A.zeros).1 A.closed,
(RememberedOffered.twins_on_every_world _).mpr ((transport eqH A.zeros).2.mp (Hinge.value_from_the_act A))⟩
/-- Part IV-b's act is an act of the offset chart as it stands. -/
def actF (A : ForceWitness.ActualZeros) : RememberedOffered.ActualZeros := ⟨A.zeros, A.closed, A.supply⟩
/-- The constructed root of Part I, as the root the closing theorems of Part III take. -/
def rootOf {R : Prop} (G : TOE0.SelfGrounding R) : RememberedOffered.SelfGrounding R := ⟨G.Act, G.anAct, G.instances⟩
/-- Part II's self-grounding root, as the root the closing theorems of Part III take. -/
def rootP {R : Prop} (G : PrimeFreedom.SelfGrounding R) : RememberedOffered.SelfGrounding R :=
⟨G.Act, G.anAct, G.instances⟩
/-- THE CHARTS ARE ONE. Every plane chart of the seed maps equivariantly into the offset chart, at every resolution and every
width; the value of a configuration is the value of its image on every chart; every act type of the seed is an act
of the offset chart at the image of its zero set; the root read at the zeros on Part II's chart is the root read
twice at the image; and both constructed roots feed the closing theorems of Part III: Part I's forces no value,
and the deed of either is the supply at a zero set exactly where the value holds. -/
theorem the_charts_are_one :
Equivariant Hinge.fold Hinge.onLine φH ∧
Equivariant (ArrowSide.fold ArrowSide.zetaChart) (ArrowSide.onLine ArrowSide.zetaChart) φA ∧
Equivariant PrimeFreedom.fold PrimeFreedom.onLine φP ∧
Equivariant PrimeFreedom.fold₂ PrimeFreedom.onLine₂ φP₂ ∧
(∀ S : Hinge.Pt → Prop, Hinge.Value S ↔ RememberedOffered.Value (img φH S)) ∧
(∀ S : ArrowSide.Pt → Prop, ArrowSide.Value ArrowSide.zetaChart S ↔ RememberedOffered.Value (img φA S)) ∧
(∀ Z : PrimeFreedom.World, PrimeFreedom.RH Z ↔ RememberedOffered.Value (img φP Z)) ∧
(∀ A : PrimeFreedom.ActualZeros, ∃ Z : RememberedOffered.ActualZeros, Z.zeros = img φP A.zeros) ∧
(∀ Z : PrimeFreedom.World, PrimeFreedom.RootAtZeros Z ↔ RememberedOffered.RootReadTwice (img φP Z)) ∧
(¬ ∀ S : RememberedOffered.Config, RememberedOffered.Closed S → TOE0.RA₀ → RememberedOffered.Value S) ∧
(∀ S : RememberedOffered.Config, RememberedOffered.Closed S →
((TOE0.ra₀.Act → ∃ Z : RememberedOffered.ActualZeros, Z.zeros = S) ↔ RememberedOffered.Value S)) ∧
(∀ C : ArrowSide.Chart, Equivariant (ArrowSide.fold C) (ArrowSide.onLine C) (φW C)) ∧
(∀ n : Int, Equivariant (PrimeFreedom.foldAt n) (fun z => z.x = n) (φPn n)) ∧
Equivariant TimeLocus.sigmaGeo TimeLocus.onLine φT ∧
Equivariant ForceWitness.fold ForceWitness.onLine φF ∧
(∀ (C : ArrowSide.Chart) (S : ArrowSide.Pt → Prop),
ArrowSide.Value C S ↔ RememberedOffered.Value (img (φW C) S)) ∧
(∀ (n : Int) (A : PrimeFreedom.ActualZerosAt n),
∃ Z : RememberedOffered.ActualZeros, Z.zeros = img (φPn n) A.zeros) ∧
(∀ A : Hinge.ActualZeros, ∃ Z : RememberedOffered.ActualZeros, Z.zeros = img φH A.zeros) ∧
(∀ A : ForceWitness.ActualZeros, ∃ Z : RememberedOffered.ActualZeros, Z.zeros = A.zeros) ∧
(∀ (R : Prop) (G : PrimeFreedom.SelfGrounding R) (S : RememberedOffered.Config), RememberedOffered.Closed S →
(((rootP G).Act → ∃ Z : RememberedOffered.ActualZeros, Z.zeros = S) ↔ RememberedOffered.Value S)) :=
⟨eqH, eqA, eqP, eqP₂,
fun S => (transport eqH S).2, fun S => (transport eqA S).2, fun Z => (transport eqP Z).2,
fun A => ⟨actP A, rfl⟩,
fun Z => ((PrimeFreedom.root_at_zeros_is_the_hypothesis Z).trans (transport eqP Z).2).trans
(RememberedOffered.the_root_read_twice_is_the_value _).symm,
RememberedOffered.the_floor_alone_decides_no_value (rootOf TOE0.ra₀),
fun S hS => (RememberedOffered.the_last_act (rootOf TOE0.ra₀) S hS).1,
eqW, eqPn, eqT, eqF, fun C S => (transport (eqW C) S).2,
fun n A => ⟨actPn n A, rfl⟩, fun A => ⟨actH A, rfl⟩, fun A => ⟨actF A, rfl⟩,
fun _ G S hS => (RememberedOffered.the_last_act (rootP G) S hS).1⟩
/-- The model pair of the zero side: Re s = 3/4 at height 3·10¹² + 1 on the offset chart at resolution four (d = 2),
with its mirror at Re s = 1/4 (d = −2). -/
def thePair : RememberedOffered.Point := (2, 3000000000001)
/-- THE ONE PAIR, READ BY EVERY INSTRUMENT, on the charts that hold it. On the offset chart it is closed, off the line, of one
record with its registered point, without the root read twice, and every report of it reads no act; its preimage
on Part IV's chart is centred on the line; its preimage on Part V's chart lies in the faithful ζ-shaped world,
which satisfies every fact of ζ placed on the arrow. -/
theorem the_pair_read_by_every_instrument :
RememberedOffered.Closed (RememberedOffered.pairWorld thePair) ∧
¬ RememberedOffered.Value (RememberedOffered.pairWorld thePair) ∧
RememberedOffered.SameRecord (RememberedOffered.registered thePair) (RememberedOffered.pairWorld thePair) ∧
¬ RememberedOffered.RootReadTwice (RememberedOffered.pairWorld thePair) ∧
(¬ ∃ Z : RememberedOffered.ActualZeros, ∀ p ∈ [thePair, RememberedOffered.fold thePair], Z.zeros p) ∧
(φH (3, 3000000000001) = thePair ∧ φH (1, 3000000000001) = RememberedOffered.fold thePair ∧
Hinge.sumX [(1, 3000000000001), (3, 3000000000001)] = 2 * 2) ∧
(φA (6, 3000000000001) = thePair ∧ φA (2, 3000000000001) = RememberedOffered.fold thePair ∧
ArrowSide.zetaFaithful ArrowSide.zetaChart 2 3000000000001 (6, 3000000000001) ∧
ArrowSide.zetaFaithful ArrowSide.zetaChart 2 3000000000001 (2, 3000000000001)) := by
have off : ¬ RememberedOffered.onLine thePair := fun h => by
have h2 : (2 : Int) = 0 := h
exact absurd h2 (by decide)
have nv := RememberedOffered.pair_world_lacks_value thePair off
refine ⟨RememberedOffered.pair_world_closed thePair, nv, RememberedOffered.one_record thePair,
RememberedOffered.the_line_no_contradicts_the_root_read_twice _ nv,
(RememberedOffered.row_four_from_the_zero_side (RememberedOffered.pairWorld thePair)).2.1
[thePair, RememberedOffered.fold thePair] ⟨thePair, List.Mem.head _, off⟩,
⟨by decide, by decide, by decide⟩, ⟨by decide, by decide, ?_, ?_⟩⟩
· exact Or.inr (Or.inr (Or.inl (by decide)))
· exact Or.inr (Or.inl (by decide))
/-- THE BLOCKS AT THE MODEL PAIR: at the pair at height 3·10¹² + 1, which every fact of ζ placed on the arrow admits,
the registered world and the pair world leave one record; both readings of the halt hold on the first and fail on
the second; no reading of the record decides the value; every deed is the supply at the first and not at the
second; and the loop closes on the first and stays open on the second. -/
theorem the_blocks_at_the_one_pair :
RememberedOffered.SameRecord (RememberedOffered.registered thePair) (RememberedOffered.pairWorld thePair) ∧
(RememberedOffered.ZeroReports (RememberedOffered.registered thePair) ∧
RememberedOffered.PrimeBound (RememberedOffered.registered thePair)) ∧
(¬ RememberedOffered.ZeroReports (RememberedOffered.pairWorld thePair) ∧
¬ RememberedOffered.PrimeBound (RememberedOffered.pairWorld thePair)) ∧
(∀ g : RememberedOffered.Config → Prop,
(∀ S S', RememberedOffered.SameRecord S S' → (g S ↔ g S')) →
¬ ((g (RememberedOffered.registered thePair) ↔
RememberedOffered.Value (RememberedOffered.registered thePair)) ∧
(g (RememberedOffered.pairWorld thePair) ↔
RememberedOffered.Value (RememberedOffered.pairWorld thePair)))) ∧
((TOE0.ra₀.Act → ∃ Z : RememberedOffered.ActualZeros, Z.zeros = RememberedOffered.registered thePair) ∧
¬ (TOE0.ra₀.Act → ∃ Z : RememberedOffered.ActualZeros, Z.zeros = RememberedOffered.pairWorld thePair)) ∧
((TOE0.RA₀ ↔ RememberedOffered.RootReadTwice (RememberedOffered.registered thePair)) ∧
¬ (TOE0.RA₀ ↔ RememberedOffered.RootReadTwice (RememberedOffered.pairWorld thePair))) := by
have off : ¬ RememberedOffered.onLine thePair := fun h => by
have h2 : (2 : Int) = 0 := h
exact absurd h2 (by decide)
have nv := RememberedOffered.pair_world_lacks_value thePair off
have rv := RememberedOffered.registered_has_value thePair
have pc := RememberedOffered.pair_world_closed thePair
have rc : RememberedOffered.Closed (RememberedOffered.registered thePair) := fun s hs => by
rw [hs]
show RememberedOffered.fold (RememberedOffered.reg thePair) = RememberedOffered.reg thePair
rfl
have zr : ∀ T : RememberedOffered.Config, RememberedOffered.Closed T →
(RememberedOffered.ZeroReports T ↔ RememberedOffered.Value T) :=
fun T hT => (RememberedOffered.row_four_from_the_zero_side T).2.2.2 hT
have la : ∀ T : RememberedOffered.Config, RememberedOffered.Closed T →
((TOE0.ra₀.Act → ∃ Z : RememberedOffered.ActualZeros, Z.zeros = T) ↔ RememberedOffered.Value T) :=
fun T hT => (RememberedOffered.the_last_act (rootOf TOE0.ra₀) T hT).1
have lp : ∀ T : RememberedOffered.Config,
((TOE0.RA₀ ↔ RememberedOffered.RootReadTwice T) ↔ RememberedOffered.Value T) :=
fun T => (RememberedOffered.the_loop (rootOf TOE0.ra₀) T).2.2.2.2.1
exact ⟨RememberedOffered.one_record thePair,
⟨(zr _ rc).mpr rv, (RememberedOffered.prime_side_halts _ rc).mpr rv⟩,
⟨fun h => nv ((zr _ pc).mp h), fun h => nv ((RememberedOffered.prime_side_halts _ pc).mp h)⟩,
fun g hg ⟨h1, h2⟩ => nv (h2.mp ((hg _ _ (RememberedOffered.one_record thePair)).mp (h1.mpr rv))),
⟨(la _ rc).mpr rv, fun h => nv ((la _ pc).mp h)⟩,
⟨(lp _).mpr rv, fun h => nv ((lp _).mp h)⟩⟩
/-- THE VERIFIED PART TRANSPORTS: at every width, the verification in both half-planes on Part V's chart is the
verified part on the offset chart with the height in absolute value. -/
theorem the_verified_part_transports (C : ArrowSide.Chart) (T : Nat) (S : ArrowSide.Pt → Prop) :
ArrowSide.RealPartAbs C (T : Int) S ↔
RHUnicorn.RealPartAt (img (φW C) S) RememberedOffered.onLine RememberedOffered.htAbs T := by
constructor
· intro h q ⟨p, hp, e⟩ hq
subst e
have hq' : (p.2).natAbs ≤ T := hq
have h1 : p.1 = C.W := h p hp (by omega) (by omega)
show p.1 - C.W = 0
omega
· intro h p hp h1 h2
have h3 : p.1 - C.W = 0 := h (φW C p) ⟨p, hp, rfl⟩ (show (p.2).natAbs ≤ T by omega)
show p.1 = C.W
omega
/-- THE FAITHFUL MODEL ON THE OFFSET CHART: its image carries the verified part at chart height 3·10¹² − 1, every zero
with |Im s| < 3·10¹², and lacks the value. -/
theorem the_faithful_model_on_the_offset_chart :
RHUnicorn.RealPartAt (img φA (ArrowSide.zetaFaithful ArrowSide.zetaChart 2 3000000000001))
RememberedOffered.onLine RememberedOffered.htAbs 2999999999999 ∧
¬ RememberedOffered.Value (img φA (ArrowSide.zetaFaithful ArrowSide.zetaChart 2 3000000000001)) :=
⟨(the_verified_part_transports ArrowSide.zetaChart 2999999999999 _).mp
ArrowSide.at_zetas_numbers_faithful.2.2.2.2.2.1,
fun v => ArrowSide.at_zetas_numbers_faithful.2.2.2.2.2.2.2 ((transport eqA _).2.mpr v)⟩
/-- ONE REAL PART, ONE OFFSET POINT, AT RESOLUTION FOUR: a real part a/4 read on Part IV's chart, on Part V's chart at
width four, on Part II's chart at resolution two, and a real part a/2 read on Part II's chart at resolution one
and on Part IV-c's chart, land at one point of the offset chart at resolution four. -/
theorem the_maps_agree_at_resolution_four :
(∀ a t : Int, φH (a, t) = φA (2 * a, t) ∧ φA (2 * a, t) = φW ArrowSide.zetaChart (2 * a, t)) ∧
(∀ z : PrimeFreedom.Pt, φP₂ z = φH (z.x, (z.t : Int)) ∧ φP z = φH (2 * z.x, (z.t : Int))) ∧
(∀ x t : Int, φT (x, t) = φH (2 * x, t)) :=
⟨fun a t => ⟨Prod.ext (show 2 * a - 4 = 2 * a - 4 from rfl) rfl, rfl⟩,
fun z => ⟨rfl, Prod.ext (show 4 * z.x - 4 = 2 * (2 * z.x) - 4 by omega) rfl⟩,
fun x t => Prod.ext (show 4 * x - 4 = 2 * (2 * x) - 4 by omega) rfl⟩
/-- Conjugation on a chart with heights in ℤ. -/
def conj (p : Int × Int) : Int × Int := (p.1, -p.2)
/-- THE MAPS COMMUTE WITH CONJUGATION on every chart with heights in ℤ; the first edition's chart, with heights in ℕ,
reads the upper half-plane, and its maps reach only heights at or above zero. -/
theorem the_maps_commute_with_conjugation :
(∀ p : Hinge.Pt, φH (conj p) = conj (φH p)) ∧ (∀ p : ArrowSide.Pt, φA (conj p) = conj (φA p)) ∧
(∀ (C : ArrowSide.Chart) (p : ArrowSide.Pt), φW C (conj p) = conj (φW C p)) ∧
(∀ p : Int × Int, φT (conj p) = conj (φT p)) ∧ (∀ p : ForceWitness.Point, φF (conj p) = conj (φF p)) ∧
(∀ (n : Int) (z : PrimeFreedom.Pt), 0 ≤ (φPn n z).2) ∧ (∀ z : PrimeFreedom.Pt, 0 ≤ (φP z).2) ∧
(∀ z : PrimeFreedom.Pt, 0 ≤ (φP₂ z).2) :=
⟨fun _ => rfl, fun _ => rfl, fun _ _ => rfl, fun _ => rfl, fun _ => rfl,
fun _ z => Int.ofNat_nonneg z.t, fun z => Int.ofNat_nonneg z.t, fun z => Int.ofNat_nonneg z.t⟩
/-! ## The reading at every resolution -/
/-- The open chart strip at resolution n: a reading inside the open strip 0 < Re s < 1 is kept at 1 ≤ x ≤ 2n − 1. -/
def clampStrip (n x : Int) : Int := max 1 (min (2 * n - 1) x)
/-- THE CLAMP KEEPS THE OPEN STRIP, COMMUTES WITH THE FOLD, AND KEEPS THE SIDE: at every resolution n ≥ 1 the clamped
reading lies in the open chart strip; the clamp commutes with x ↦ 2n − x; and at every resolution n ≥ 2 it lands
on the line exactly when the rounded reading does. -/
theorem the_clamp_keeps_strip_fold_and_side :
(∀ n x : Int, 1 ≤ n → 1 ≤ clampStrip n x ∧ clampStrip n x ≤ 2 * n - 1) ∧
(∀ n x : Int, 1 ≤ n → clampStrip n (2 * n - x) = 2 * n - clampStrip n x) ∧
(∀ n x : Int, 2 ≤ n → (clampStrip n x = n ↔ x = n)) :=
⟨fun n x _ => by unfold clampStrip; omega, fun n x _ => by unfold clampStrip; omega,
fun n x _ => by unfold clampStrip; omega⟩
/-- Rounding half to even of a / b, for b > 0. -/
def roundHalfEven (a b : Int) : Int :=
let q := a / b
let r := a % b
if 2 * r < b then q else if 2 * r > b then q + 1 else if q % 2 = 0 then q else q + 1
/-- THE READER'S RULE on the offset chart at resolution n ≥ 1: a real part σ = a / b of the open strip is read at
x = round(2n·σ), rounded half to even and kept in the open chart strip, and at d = x − n. -/
def readAt (n : Nat) (a b : Int) : Int := clampStrip n (roundHalfEven (2 * n * a) b) - n
/-- ONE RESOLUTION IS NOT ENOUGH: a zero at Re s = 51/100 and its mirror at 49/100 read onto the line at resolution
four and off it at resolution fifty; the pair at Re s = 1/4 and 3/4 reads at d = ∓2 at resolution four; and a
zero at Re s = 97/100 or 3/100 is kept off the poles, at d = ±3. -/
theorem one_resolution_is_not_enough :
readAt 4 51 100 = 0 ∧ readAt 4 49 100 = 0 ∧ readAt 50 51 100 = 1 ∧ readAt 50 49 100 = -1 ∧
readAt 4 1 4 = -2 ∧ readAt 4 3 4 = 2 ∧ readAt 4 97 100 = 3 ∧ readAt 4 3 100 = -3 := by decide
/-- A zero at Re s = 51/100 with its mirror at 49/100, at height 3·10¹² + 1, read at resolution n. -/
def nearWorld (n : Nat) : RememberedOffered.Config := fun q =>
q = (readAt n 51 100, 3000000000001) ∨ q = (readAt n 49 100, 3000000000001)
/-- THE VALUE AT ONE RESOLUTION DOES NOT DECIDE IT AT A FINER ONE: read at resolution four the near pair is closed and
has the value; read at resolution fifty it is closed and lacks it. -/
theorem one_resolution_does_not_decide_the_next :
RememberedOffered.Closed (nearWorld 4) ∧ RememberedOffered.Value (nearWorld 4) ∧
RememberedOffered.Closed (nearWorld 50) ∧ ¬ RememberedOffered.Value (nearWorld 50) := by
obtain ⟨e1, e2, e3, e4, _, _, _, _⟩ := one_resolution_is_not_enough
refine ⟨fun q hq => ?_, fun q hq => ?_, fun q hq => ?_, fun v => ?_⟩
· unfold nearWorld at hq ⊢
rw [e1, e2] at hq ⊢
rcases hq with h | h <;> (subst h; exact Or.inl (by decide))
· unfold nearWorld at hq
rw [e1, e2] at hq
rcases hq with h | h <;> (subst h; rfl)
· unfold nearWorld at hq ⊢
rw [e3, e4] at hq ⊢
rcases hq with h | h
· subst h; exact Or.inr (by decide)
· subst h; exact Or.inl (by decide)
· have h : (1 : Int) = 0 := v (1, 3000000000001) (by unfold nearWorld; rw [e3]; exact Or.inl rfl)
exact absurd h (by decide)
/-- THE ACT AT EVERY RESOLUTION: a family of readings of the offset chart, one at each resolution, each closed under
the fold, with least erasure supplied at every resolution. The zero set of ζ read by the reader's rule at every
resolution n ≥ 1 is such a family by the reading of the paper's Section 11; resolution zero is no reading, and the
family's term there is the empty configuration by stipulation. -/
structure ActualZerosEvery where
zeros : Nat → RememberedOffered.Config
closed : ∀ n, RememberedOffered.Closed (zeros n)
supply : ∀ n, RememberedOffered.LeastErasure (zeros n)
/-- The act at every resolution is an act of the offset chart at each one. -/
def ActualZerosEvery.atRes (Z : ActualZerosEvery) (n : Nat) : RememberedOffered.ActualZeros :=
⟨Z.zeros n, Z.closed n, Z.supply n⟩
/-- THE VALUE AT EVERY RESOLUTION, ON NO AXIOM: on the act at every resolution, every reading has the value. -/
theorem the_value_at_every_resolution (Z : ActualZerosEvery) (n : Nat) : RememberedOffered.Value (Z.zeros n) :=
RememberedOffered.value_from_the_act (Z.atRes n)
/-- THE ACT AT EVERY RESOLUTION, WHOLE: the act stands at the readings exactly where the value holds at every
resolution; on it, at every resolution, the value, the zero reports and the prime bound hold; every proof of the
value at every resolution, from any premise, is a supply of the act; the supply is unique; and the atomic proof,
the atomic necessity and the two-sided halt hold at every resolution. -/
theorem the_act_at_every_resolution (R : Nat → RememberedOffered.Config)
(hR : ∀ n, RememberedOffered.Closed (R n)) :
((∃ Z : ActualZerosEvery, Z.zeros = R) ↔ ∀ n, RememberedOffered.Value (R n)) ∧
(∀ (Z : ActualZerosEvery) (n : Nat), RememberedOffered.Value (Z.zeros n) ∧
RememberedOffered.ZeroReports (Z.zeros n) ∧ RememberedOffered.PrimeBound (Z.zeros n)) ∧
(∀ Q : Prop, (Q → ∀ n, RememberedOffered.Value (R n)) → Q → ∃ Z : ActualZerosEvery, Z.zeros = R) ∧
(∀ Z₁ Z₂ : ActualZerosEvery, Z₁.zeros = R → Z₂.zeros = R → Z₁ = Z₂) ∧
(∀ n, type_of% (RememberedOffered.the_atomic_proof (rootOf TOE0.ra₀) (R n) (hR n))) ∧
(∀ n, type_of% (RememberedOffered.the_atomic_necessity (R n) (hR n))) ∧
(∀ n, type_of% (RememberedOffered.bidirectional_halted_uniduction (R n) (hR n))) := by
have mk : (∀ n, RememberedOffered.Value (R n)) → ∃ Z : ActualZerosEvery, Z.zeros = R := fun v =>
⟨⟨R, hR, fun n => (RememberedOffered.twins_on_every_world (R n)).mpr (v n)⟩, rfl⟩
refine ⟨⟨fun ⟨Z, hZ⟩ n => by rw [← hZ]; exact RememberedOffered.value_from_the_act (Z.atRes n), mk⟩,
fun Z n => ⟨RememberedOffered.value_from_the_act (Z.atRes n),
(RememberedOffered.bidirectional_halted_uniduction _ (Z.closed n)).2.2.2.2.2 (Z.atRes n)⟩,
fun _ hQ q => mk (hQ q), ?_,
fun n => RememberedOffered.the_atomic_proof (rootOf TOE0.ra₀) (R n) (hR n),
fun n => RememberedOffered.the_atomic_necessity (R n) (hR n),
fun n => RememberedOffered.bidirectional_halted_uniduction (R n) (hR n)⟩
intro Z₁ Z₂ h₁ h₂
obtain ⟨z₁, c₁, s₁⟩ := Z₁
obtain ⟨z₂, c₂, s₂⟩ := Z₂
change z₁ = R at h₁
change z₂ = R at h₂
subst h₁
subst h₂
rfl
/-- THE PRIME BOUND AT ONE RESOLUTION IS WEAKER: the near pair at Re s = 51/100 meets the prime bound read at
resolution four and fails it read at resolution fifty; at one resolution n the chart's prime bound reads a zero
within 1/(4n) of the line onto it. -/
theorem the_prime_bound_at_one_resolution :
RememberedOffered.PrimeBound (nearWorld 4) ∧ ¬ RememberedOffered.PrimeBound (nearWorld 50) := by
have h := one_resolution_does_not_decide_the_next
exact ⟨(RememberedOffered.prime_side_halts _ h.1).mpr h.2.1,
fun b => h.2.2.2 ((RememberedOffered.prime_side_halts _ h.2.2.1).mp b)⟩
/-- THE HALT AT EVERY RESOLUTION: for every family of reflection-closed readings, the zero reports at every resolution,
the prime bound at every resolution and the value at every resolution are one proposition. The prime bound at
every resolution together is the chart's image of the cited bound at x^(1/2 + ε). -/
theorem the_halt_at_every_resolution (R : Nat → RememberedOffered.Config)
(hR : ∀ n, RememberedOffered.Closed (R n)) :
((∀ n, RememberedOffered.ZeroReports (R n)) ↔ ∀ n, RememberedOffered.Value (R n)) ∧
((∀ n, RememberedOffered.PrimeBound (R n)) ↔ ∀ n, RememberedOffered.Value (R n)) ∧
((∀ n, RememberedOffered.ZeroReports (R n)) ↔ ∀ n, RememberedOffered.PrimeBound (R n)) := by
have z := fun n => (RememberedOffered.bidirectional_halted_uniduction (R n) (hR n)).1
have p := fun n => (RememberedOffered.bidirectional_halted_uniduction (R n) (hR n)).2.1
refine ⟨⟨fun h n => (z n).mp (h n), fun h n => (z n).mpr (h n)⟩,
⟨fun h n => (p n).mp (h n), fun h n => (p n).mpr (h n)⟩,
⟨fun h n => (p n).mpr ((z n).mp (h n)), fun h n => (z n).mpr ((p n).mp (h n))⟩⟩
end Charts
end PartVb
/-! # PART VI · THE TWO-SIDED CLOSURE -/
section PartVI
namespace BothSides
/-- THE TWO-SIDED CLOSURE. One theorem, every capstone of the seed bound by its exact type.
I the floor, on no axiom: the root holds for every self-grounding root; the Root Axiom on its constructed
domain; the master seal of the three axes; the line is the fixed set of conjugation.
II the arrow: the only rigid reversal of the two poles; the freedom cut, the line blind to the arrow's sign;
the hinge at Re s = 1/2; the fold's fixed set is the line.
III the prime side: the primes admit every assignment; prime freedom forces nothing; the prime bound halts
at the value; the ζ-specific facts on the arrow, their test and their reach at the ends.
IV the non-trivial-zero side: the zero set's own centre is the line; a centred pair off it; row four read
from the zeros.
V the nine rows: the form; the open leg; the blind record; the premise forced, the act, the weakest
forcing premise; the barred refuter; the terminal saturation; the capstone; the annihilating timeless
closure and the one; the atomic form forced.
VI the termination: the bidirectional halted uniduction; the atomic proof; the last act; least erasure and
least escape; the loop.
VII the run: a run witnesses that it ran and leaves the value free; a run's flag offered as the field at every
closed configuration is refused; beside the field, the run is witnessed and the value stands on the field.
VIII the charts are one; the one model pair read by every instrument; the faithful model of ζ's zeros; the hinge
exists; both values of the bit are atomic.
IX further capstones and row mechanisms of Parts II, III, IV, IV-b and IV-c.
X every further theorem the body of the paper cites, generated from the body's citations: with I to IX, the
closure binds every theorem the body cites. -/
theorem the_two_sided_closure :
-- I · the floor
(type_of% @TOE0.the_floor_is_universal) ∧ (type_of% @TOE0.root_on_the_constructed_domain) ∧
(type_of% @TOE0.the_master_seal) ∧ (type_of% @TOE0.the_line_is_the_fixed_set) ∧
-- II · the arrow
(type_of% @Hinge.the_only_rigid_reversal) ∧ (type_of% @Hinge.hinge_sign_blind) ∧
(type_of% @Hinge.zeta_hinge) ∧ (type_of% @Hinge.locus) ∧
-- III · the prime side
(type_of% @PrimeFreedom.primes_admit_every_assignment) ∧ (type_of% @PrimeFreedom.prime_freedom_forces_nothing) ∧
(type_of% @RememberedOffered.prime_side_halts) ∧ (type_of% @ArrowSide.arrow_side_test) ∧
(type_of% @ArrowSide.beyond_the_head_breaks_ends) ∧ (type_of% @ArrowSide.at_zetas_numbers) ∧
-- IV · the non-trivial-zero side
(type_of% @Hinge.centre_is_the_line) ∧ (type_of% @Hinge.centred_yet_off) ∧
(type_of% @RememberedOffered.row_four_from_the_zero_side) ∧
-- V · the nine rows
(type_of% @PrimeFreedom.least_erasure_is_the_value) ∧ (type_of% @PrimeFreedom.keyless_forces_nothing) ∧
(type_of% @PrimeFreedom.record_decides_nothing) ∧ (type_of% @PrimeFreedom.rh_from_the_act) ∧
(type_of% @PrimeFreedom.rh_is_the_weakest_forcing_premise) ∧ (type_of% @PrimeFreedom.the_tenth_is_barred_by_the_act) ∧
(type_of% @PrimeFreedom.nothing_left_open_on_the_act) ∧ (type_of% @PrimeFreedom.the_capstone) ∧
(type_of% @RememberedOffered.the_annihilation_closure) ∧ (type_of% @RememberedOffered.the_one) ∧
(type_of% @RememberedOffered.the_atomic_necessity) ∧
-- VI · the termination
(type_of% @RememberedOffered.bidirectional_halted_uniduction) ∧ (type_of% @RememberedOffered.the_atomic_proof) ∧
(type_of% @RememberedOffered.the_last_act) ∧ (type_of% @RememberedOffered.least_erasure_and_least_escape) ∧
(type_of% @RememberedOffered.the_loop) ∧
-- VII · the run
(type_of% @ForceWitness.force_witness_closure) ∧ (type_of% @ForceWitness.the_plug_fails) ∧
(type_of% @ForceWitness.the_plug_delivers) ∧
-- VIII · the charts, the pair and the faithful model
(type_of% @Charts.the_charts_are_one) ∧ (type_of% @Charts.the_pair_read_by_every_instrument) ∧
(type_of% @ArrowSide.at_zetas_numbers_faithful) ∧ (type_of% @Hinge.hinge_exists) ∧
(type_of% @RememberedOffered.both_values_atomic) ∧
-- IX · every further capstone and row mechanism the paper cites
(type_of% @PrimeFreedom.vocabulary_law) ∧ (type_of% @PrimeFreedom.the_front) ∧
(type_of% @PrimeFreedom.posit_is_the_value) ∧ (type_of% @PrimeFreedom.every_face_proves_every_face) ∧
(type_of% @PrimeFreedom.keyless_forces_nothing₂) ∧ (type_of% @PrimeFreedom.no_reading_decides_in_the_strip) ∧
(type_of% @PrimeFreedom.the_tenth_is_the_refuter) ∧ (type_of% @PrimeFreedom.reader_frame) ∧
(type_of% @RememberedOffered.the_timeless_zone_closed) ∧ (type_of% @RememberedOffered.the_unicorn_contained) ∧
(type_of% @RememberedOffered.unicorn_blocked_on_the_chart) ∧ (type_of% @RememberedOffered.flowed_record_forgets) ∧
(type_of% @RememberedOffered.reality_transported) ∧ (type_of% @RememberedOffered.upstream_is_not_forced) ∧
(type_of% @RememberedOffered.the_deed_is_not_the_supply) ∧ (type_of% @RememberedOffered.floor_is_not_least_erasure) ∧
(type_of% @ForceWitness.force_witness_guarded) ∧ (type_of% @Hinge.arrow_gives_line_not_value) ∧
(type_of% @Judge.identical_locus_does_not_exclude) ∧ (type_of% @Judge.the_seed_is_exactly_what_binds) ∧
(type_of% @TimeLocus.time_does_not_bind) ∧
-- X · every further theorem the body of the paper cites
(type_of% @Hinge.the_line_off_the_arrow) ∧ (type_of% @RememberedOffered.no_closed_principle_decides) ∧
(type_of% @Hinge.keyless_forces_nothing) ∧ (type_of% @ArrowSide.faithful_arrow_side_test) ∧
(type_of% @Charts.the_act_at_every_resolution) ∧ (type_of% @PrimeFreedom.independence_forces_truth) ∧
(type_of% @Charts.the_blocks_at_the_one_pair) ∧ (type_of% @RememberedOffered.twins_on_every_world) ∧
(type_of% @ArrowSide.faithful_every_margin) ∧ (type_of% @RememberedOffered.the_unicorn_contained_abs) ∧
(type_of% @RememberedOffered.the_form_is_the_hypothesis) ∧ (type_of% @RememberedOffered.line_no_has_a_world) ∧
(type_of% @RememberedOffered.tongue_no_has_no_world) ∧ (type_of% @Charts.the_value_at_every_resolution) ∧
(type_of% @TOE0.denial_reenacts_root) ∧ (type_of% @PrimeFreedom.denial_reenacts_root) ∧
(type_of% @RememberedOffered.denial_reenacts_root) ∧ (type_of% @TOE0.no_level_above) ∧
(type_of% @PrimeFreedom.root_at_zeros_is_least_erasure) ∧ (type_of% @RememberedOffered.the_root_read_twice_is_the_value) ∧
(type_of% @RememberedOffered.monism_witness_is_the_claim) ∧ (type_of% @RememberedOffered.the_floor_alone_decides_no_value) ∧
(type_of% @RememberedOffered.merging_at_a_world_is_the_supply) ∧ (type_of% @TOE0.twenty_four_units_twelve_gates) ∧
(type_of% @TOE0.the_shell_splits_twelve_and_twelve) ∧ (type_of% @Charts.the_maps_keep_height_and_scale) ∧
(type_of% @Charts.the_maps_agree_at_resolution_four) ∧ (type_of% @Charts.the_maps_commute_with_conjugation) ∧
(type_of% @Charts.transport) ∧ (type_of% @Charts.one_resolution_is_not_enough) ∧
(type_of% @Charts.one_resolution_does_not_decide_the_next) ∧ (type_of% @Hinge.hinge) ∧
(type_of% @Hinge.hinge_unique) ∧ (type_of% @Hinge.hinge_iff_even) ∧
(type_of% @Hinge.centre_on_every_extension) ∧ (type_of% @Hinge.the_point_reflection_reads_the_same_line) ∧
(type_of% @Hinge.fold_is_the_height_keeping_extension) ∧ (type_of% @PrimeFreedom.liouville_is_the_sign_arrow) ∧
(type_of% @ForceWitness.record_decides_nothing) ∧ (type_of% @PrimeFreedom.open_strip_forces_at_resolution_one) ∧
(type_of% @ArrowSide.an_off_line_zero_comes_in_four) ∧ (type_of% @ArrowSide.at_width_one_the_ends_are_the_value) ∧
(type_of% @Charts.the_halt_at_every_resolution) ∧ (type_of% @Charts.the_prime_bound_at_one_resolution) ∧
(type_of% @RememberedOffered.price_zero_iff_value) ∧ (type_of% @Hinge.centre_of_a_closed_family) ∧
(type_of% @RememberedOffered.two_doors) ∧ (type_of% @RememberedOffered.doors_exclusive) ∧
(type_of% @RememberedOffered.the_false_world_carries_the_floor_and_no_monism) ∧ (type_of% @RememberedOffered.one_record) ∧
(type_of% @ForceWitness.one_record) ∧ (type_of% @RememberedOffered.price_counts_pairs) ∧
(type_of% @RememberedOffered.monism_is_the_sole_witness) ∧ (type_of% @Judge.identical_locus_inside_the_strip_does_not_exclude) ∧
(type_of% @PrimeFreedom.least_erasure_unconditional) ∧ (type_of% @RememberedOffered.four_names_one_proposition) ∧
(type_of% @PrimeFreedom.unicorn_block) ∧ (type_of% @RHUnicorn.unicorn_block) ∧
(type_of% @PrimeFreedom.the_witness_forced_by_the_act) ∧ (type_of% @PrimeFreedom.two_denials) ∧
(type_of% @RememberedOffered.two_denials) ∧ (type_of% @RememberedOffered.no_arrival_off_the_line_on_the_act) ∧
(type_of% @RememberedOffered.on_the_act_the_line_no_is_refuted) ∧ (type_of% @RememberedOffered.the_unconditional_route_is_blocked) ∧
(type_of% @RememberedOffered.accepting_rh_forces_the_atomic_proof) ∧ (type_of% @RememberedOffered.band_does_not_force) ∧
(type_of% @RememberedOffered.band_zero_is_value) ∧ (type_of% @RememberedOffered.the_form_of_a_field) ∧
(type_of% @RememberedOffered.premise_trichotomy) ∧ (type_of% @Charts.the_clamp_keeps_strip_fold_and_side) ∧
(type_of% @PrimeFreedom.unicorn_never_registered) ∧ (type_of% @PrimeFreedom.round_trip_identity) ∧
(type_of% @PrimeFreedom.trip_adds_presence_only) ∧ (type_of% @PrimeFreedom.massless_arrow) ∧
(type_of% @PrimeFreedom.no_coalition_decides) :=
⟨@TOE0.the_floor_is_universal, @TOE0.root_on_the_constructed_domain, @TOE0.the_master_seal,
@TOE0.the_line_is_the_fixed_set,
@Hinge.the_only_rigid_reversal, @Hinge.hinge_sign_blind, @Hinge.zeta_hinge, @Hinge.locus,
@PrimeFreedom.primes_admit_every_assignment, @PrimeFreedom.prime_freedom_forces_nothing,
@RememberedOffered.prime_side_halts, @ArrowSide.arrow_side_test, @ArrowSide.beyond_the_head_breaks_ends,
@ArrowSide.at_zetas_numbers,
@Hinge.centre_is_the_line, @Hinge.centred_yet_off, @RememberedOffered.row_four_from_the_zero_side,
@PrimeFreedom.least_erasure_is_the_value, @PrimeFreedom.keyless_forces_nothing,
@PrimeFreedom.record_decides_nothing, @PrimeFreedom.rh_from_the_act,
@PrimeFreedom.rh_is_the_weakest_forcing_premise, @PrimeFreedom.the_tenth_is_barred_by_the_act,
@PrimeFreedom.nothing_left_open_on_the_act, @PrimeFreedom.the_capstone,
@RememberedOffered.the_annihilation_closure, @RememberedOffered.the_one, @RememberedOffered.the_atomic_necessity,
@RememberedOffered.bidirectional_halted_uniduction, @RememberedOffered.the_atomic_proof,
@RememberedOffered.the_last_act, @RememberedOffered.least_erasure_and_least_escape,
@RememberedOffered.the_loop,
@ForceWitness.force_witness_closure, @ForceWitness.the_plug_fails, @ForceWitness.the_plug_delivers,
@Charts.the_charts_are_one, @Charts.the_pair_read_by_every_instrument, @ArrowSide.at_zetas_numbers_faithful,
@Hinge.hinge_exists, @RememberedOffered.both_values_atomic,
@PrimeFreedom.vocabulary_law, @PrimeFreedom.the_front, @PrimeFreedom.posit_is_the_value,
@PrimeFreedom.every_face_proves_every_face, @PrimeFreedom.keyless_forces_nothing₂,
@PrimeFreedom.no_reading_decides_in_the_strip, @PrimeFreedom.the_tenth_is_the_refuter, @PrimeFreedom.reader_frame,
@RememberedOffered.the_timeless_zone_closed, @RememberedOffered.the_unicorn_contained,
@RememberedOffered.unicorn_blocked_on_the_chart, @RememberedOffered.flowed_record_forgets,
@RememberedOffered.reality_transported, @RememberedOffered.upstream_is_not_forced,
@RememberedOffered.the_deed_is_not_the_supply, @RememberedOffered.floor_is_not_least_erasure,
@ForceWitness.force_witness_guarded, @Hinge.arrow_gives_line_not_value,
@Judge.identical_locus_does_not_exclude, @Judge.the_seed_is_exactly_what_binds, @TimeLocus.time_does_not_bind,
@Hinge.the_line_off_the_arrow, @RememberedOffered.no_closed_principle_decides, @Hinge.keyless_forces_nothing,
@ArrowSide.faithful_arrow_side_test, @Charts.the_act_at_every_resolution, @PrimeFreedom.independence_forces_truth,
@Charts.the_blocks_at_the_one_pair, @RememberedOffered.twins_on_every_world, @ArrowSide.faithful_every_margin,
@RememberedOffered.the_unicorn_contained_abs, @RememberedOffered.the_form_is_the_hypothesis, @RememberedOffered.line_no_has_a_world,
@RememberedOffered.tongue_no_has_no_world, @Charts.the_value_at_every_resolution, @TOE0.denial_reenacts_root,
@PrimeFreedom.denial_reenacts_root, @RememberedOffered.denial_reenacts_root, @TOE0.no_level_above,
@PrimeFreedom.root_at_zeros_is_least_erasure, @RememberedOffered.the_root_read_twice_is_the_value, @RememberedOffered.monism_witness_is_the_claim,
@RememberedOffered.the_floor_alone_decides_no_value, @RememberedOffered.merging_at_a_world_is_the_supply, @TOE0.twenty_four_units_twelve_gates,
@TOE0.the_shell_splits_twelve_and_twelve, @Charts.the_maps_keep_height_and_scale, @Charts.the_maps_agree_at_resolution_four,
@Charts.the_maps_commute_with_conjugation, @Charts.transport, @Charts.one_resolution_is_not_enough,
@Charts.one_resolution_does_not_decide_the_next, @Hinge.hinge, @Hinge.hinge_unique,
@Hinge.hinge_iff_even, @Hinge.centre_on_every_extension, @Hinge.the_point_reflection_reads_the_same_line,
@Hinge.fold_is_the_height_keeping_extension, @PrimeFreedom.liouville_is_the_sign_arrow, @ForceWitness.record_decides_nothing,
@PrimeFreedom.open_strip_forces_at_resolution_one, @ArrowSide.an_off_line_zero_comes_in_four, @ArrowSide.at_width_one_the_ends_are_the_value,
@Charts.the_halt_at_every_resolution, @Charts.the_prime_bound_at_one_resolution, @RememberedOffered.price_zero_iff_value,
@Hinge.centre_of_a_closed_family, @RememberedOffered.two_doors, @RememberedOffered.doors_exclusive,
@RememberedOffered.the_false_world_carries_the_floor_and_no_monism, @RememberedOffered.one_record, @ForceWitness.one_record,
@RememberedOffered.price_counts_pairs, @RememberedOffered.monism_is_the_sole_witness, @Judge.identical_locus_inside_the_strip_does_not_exclude,
@PrimeFreedom.least_erasure_unconditional, @RememberedOffered.four_names_one_proposition, @PrimeFreedom.unicorn_block,
@RHUnicorn.unicorn_block, @PrimeFreedom.the_witness_forced_by_the_act, @PrimeFreedom.two_denials,
@RememberedOffered.two_denials, @RememberedOffered.no_arrival_off_the_line_on_the_act, @RememberedOffered.on_the_act_the_line_no_is_refuted,
@RememberedOffered.the_unconditional_route_is_blocked, @RememberedOffered.accepting_rh_forces_the_atomic_proof, @RememberedOffered.band_does_not_force,
@RememberedOffered.band_zero_is_value, @RememberedOffered.the_form_of_a_field, @RememberedOffered.premise_trichotomy,
@Charts.the_clamp_keeps_strip_fold_and_side, @PrimeFreedom.unicorn_never_registered, @PrimeFreedom.round_trip_identity,
@PrimeFreedom.trip_adds_presence_only, @PrimeFreedom.massless_arrow, @PrimeFreedom.no_coalition_decides⟩
end BothSides
end PartVI
/-! # The cones of Parts IV to VI -/
/-- info: 'ArrowSide.an_off_line_zero_comes_in_four' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.an_off_line_zero_comes_in_four
/-- info: 'ArrowSide.arrow_side_test' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.arrow_side_test
/-- info: 'ArrowSide.at_width_one_the_ends_are_the_value' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.at_width_one_the_ends_are_the_value
/-- info: 'ArrowSide.at_zetas_numbers' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.at_zetas_numbers
/-- info: 'ArrowSide.at_zetas_numbers_faithful' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.at_zetas_numbers_faithful
/-- info: 'ArrowSide.beyond_the_head_breaks_ends' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.beyond_the_head_breaks_ends
/-- info: 'ArrowSide.faithful_arrow_side_test' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.faithful_arrow_side_test
/-- info: 'ArrowSide.faithful_every_margin' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.faithful_every_margin
/-- info: 'ArrowSide.shaped_closed' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.shaped_closed
/-- info: 'ArrowSide.shaped_ends' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.shaped_ends
/-- info: 'ArrowSide.shaped_finitely_off' does not depend on any axioms -/
#guard_msgs in #print axioms ArrowSide.shaped_finitely_off
/-- info: 'ArrowSide.shaped_lacks_value' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.shaped_lacks_value
/-- info: 'ArrowSide.shaped_real_part' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.shaped_real_part
/-- info: 'ArrowSide.shaped_zero_free' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms ArrowSide.shaped_zero_free
/-- info: 'BothSides.the_two_sided_closure' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms BothSides.the_two_sided_closure
/-- info: 'Charts.eqA' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Charts.eqA
/-- info: 'Charts.eqF' does not depend on any axioms -/
#guard_msgs in #print axioms Charts.eqF
/-- info: 'Charts.eqH' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Charts.eqH
/-- info: 'Charts.eqP' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Charts.eqP
/-- info: 'Charts.eqPn' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Charts.eqPn
/-- info: 'Charts.eqP₂' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Charts.eqP₂
/-- info: 'Charts.eqT' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Charts.eqT
/-- info: 'Charts.eqW' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Charts.eqW
/-- info: 'Charts.one_resolution_does_not_decide_the_next' does not depend on any axioms -/
#guard_msgs in #print axioms Charts.one_resolution_does_not_decide_the_next
/-- info: 'Charts.one_resolution_is_not_enough' does not depend on any axioms -/
#guard_msgs in #print axioms Charts.one_resolution_is_not_enough
/-- info: 'Charts.the_act_at_every_resolution' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Charts.the_act_at_every_resolution
/-- info: 'Charts.the_blocks_at_the_one_pair' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Charts.the_blocks_at_the_one_pair
/-- info: 'Charts.the_charts_are_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Charts.the_charts_are_one
/-- info: 'Charts.the_clamp_keeps_strip_fold_and_side' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Charts.the_clamp_keeps_strip_fold_and_side
/-- info: 'Charts.the_faithful_model_on_the_offset_chart' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Charts.the_faithful_model_on_the_offset_chart
/-- info: 'Charts.the_halt_at_every_resolution' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Charts.the_halt_at_every_resolution
/-- info: 'Charts.the_maps_agree_at_resolution_four' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Charts.the_maps_agree_at_resolution_four
/-- info: 'Charts.the_maps_commute_with_conjugation' does not depend on any axioms -/
#guard_msgs in #print axioms Charts.the_maps_commute_with_conjugation
/-- info: 'Charts.the_maps_keep_height_and_scale' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Charts.the_maps_keep_height_and_scale
/-- info: 'Charts.the_pair_read_by_every_instrument' does not depend on any axioms -/
#guard_msgs in #print axioms Charts.the_pair_read_by_every_instrument
/-- info: 'Charts.the_prime_bound_at_one_resolution' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Charts.the_prime_bound_at_one_resolution
/-- info: 'Charts.the_value_at_every_resolution' does not depend on any axioms -/
#guard_msgs in #print axioms Charts.the_value_at_every_resolution
/-- info: 'Charts.the_verified_part_transports' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Charts.the_verified_part_transports
/-- info: 'Charts.transport' does not depend on any axioms -/
#guard_msgs in #print axioms Charts.transport
/-- info: 'ForceWitness.the_plug_delivers' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.the_plug_delivers
/-- info: 'ForceWitness.the_plug_fails' does not depend on any axioms -/
#guard_msgs in #print axioms ForceWitness.the_plug_fails
/-- info: 'Hinge.arrow_gives_line_not_value' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Hinge.arrow_gives_line_not_value
/-- info: 'Hinge.centre_is_the_line' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.centre_is_the_line
/-- info: 'Hinge.centre_of_a_closed_family' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.centre_of_a_closed_family
/-- info: 'Hinge.centre_on_every_extension' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.centre_on_every_extension
/-- info: 'Hinge.centred_yet_off' does not depend on any axioms -/
#guard_msgs in #print axioms Hinge.centred_yet_off
/-- info: 'Hinge.fold_is_the_height_keeping_extension' does not depend on any axioms -/
#guard_msgs in #print axioms Hinge.fold_is_the_height_keeping_extension
/-- info: 'Hinge.fold_keeps_height' does not depend on any axioms -/
#guard_msgs in #print axioms Hinge.fold_keeps_height
/-- info: 'Hinge.hinge' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Hinge.hinge
/-- info: 'Hinge.hinge_exists' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.hinge_exists
/-- info: 'Hinge.hinge_iff_even' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.hinge_iff_even
/-- info: 'Hinge.hinge_sign_blind' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.hinge_sign_blind
/-- info: 'Hinge.hinge_unique' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.hinge_unique
/-- info: 'Hinge.keyless_forces_nothing' does not depend on any axioms -/
#guard_msgs in #print axioms Hinge.keyless_forces_nothing
/-- info: 'Hinge.least_erasure_iff_value' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.least_erasure_iff_value
/-- info: 'Hinge.locus' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.locus
/-- info: 'Hinge.off_line_leans' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.off_line_leans
/-- info: 'Hinge.pair_closed' does not depend on any axioms -/
#guard_msgs in #print axioms Hinge.pair_closed
/-- info: 'Hinge.pair_in_strip' does not depend on any axioms -/
#guard_msgs in #print axioms Hinge.pair_in_strip
/-- info: 'Hinge.pair_lacks_value' does not depend on any axioms -/
#guard_msgs in #print axioms Hinge.pair_lacks_value
/-- info: 'Hinge.reg_keeps_on_line' does not depend on any axioms -/
#guard_msgs in #print axioms Hinge.reg_keeps_on_line
/-- info: 'Hinge.reg_merges' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.reg_merges
/-- info: 'Hinge.rev_flips_offset' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.rev_flips_offset
/-- info: 'Hinge.rev_involutive' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.rev_involutive
/-- info: 'Hinge.rev_swaps' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.rev_swaps
/-- info: 'Hinge.sumX_perm' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.sumX_perm
/-- info: 'Hinge.the_line_off_the_arrow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Hinge.the_line_off_the_arrow
/-- info: 'Hinge.the_only_rigid_reversal' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.the_only_rigid_reversal
/-- info: 'Hinge.the_point_reflection_reads_the_same_line' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Hinge.the_point_reflection_reads_the_same_line
/-- info: 'Hinge.value_from_the_act' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Hinge.value_from_the_act
/-- info: 'Hinge.zeta_hinge' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms Hinge.zeta_hinge
/-- info: 'Judge.identical_locus_does_not_exclude' does not depend on any axioms -/
#guard_msgs in #print axioms Judge.identical_locus_does_not_exclude
/-- info: 'Judge.identical_locus_inside_the_strip_does_not_exclude' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms Judge.identical_locus_inside_the_strip_does_not_exclude
/-- info: 'Judge.the_seed_is_exactly_what_binds' does not depend on any axioms -/
#guard_msgs in #print axioms Judge.the_seed_is_exactly_what_binds
/-- info: 'RememberedOffered.accepting_rh_forces_the_atomic_proof' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.accepting_rh_forces_the_atomic_proof
/-- info: 'RememberedOffered.bidirectional_halted_uniduction' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.bidirectional_halted_uniduction
/-- info: 'RememberedOffered.both_values_atomic' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.both_values_atomic
/-- info: 'RememberedOffered.least_erasure_and_least_escape' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.least_erasure_and_least_escape
/-- info: 'RememberedOffered.premise_trichotomy' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.premise_trichotomy
/-- info: 'RememberedOffered.prime_side_halts' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.prime_side_halts
/-- info: 'RememberedOffered.row_four_from_the_zero_side' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.row_four_from_the_zero_side
/-- info: 'RememberedOffered.the_atomic_necessity' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_atomic_necessity
/-- info: 'RememberedOffered.the_atomic_proof' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_atomic_proof
/-- info: 'RememberedOffered.the_form_is_the_hypothesis' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_form_is_the_hypothesis
/-- info: 'RememberedOffered.the_form_of_a_field' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_form_of_a_field
/-- info: 'RememberedOffered.the_last_act' does not depend on any axioms -/
#guard_msgs in #print axioms RememberedOffered.the_last_act
/-- info: 'RememberedOffered.the_loop' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_loop
/-- info: 'RememberedOffered.the_one' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_one
/-- info: 'RememberedOffered.the_unconditional_route_is_blocked' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_unconditional_route_is_blocked
/-- info: 'RememberedOffered.the_unicorn_contained_abs' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in #print axioms RememberedOffered.the_unicorn_contained_abs
/-- info: 'TimeLocus.seedless_reading_holds_in_counter_world' does not depend on any axioms -/
#guard_msgs in #print axioms TimeLocus.seedless_reading_holds_in_counter_world
/-- info: 'TimeLocus.time_does_not_bind' does not depend on any axioms -/
#guard_msgs in #print axioms TimeLocus.time_does_not_bind
#print axioms BothSides.the_two_sided_closure