PKL Rev3
DE · EN · Repository

The Mathematical Shape of the Architecture

Polycontextural Logic in Lean 4 and Mathlib — Edition PKL Rev3

On the standing of this text. This is the English edition of the German original, and the two are the same document in two languages, not two documents: every figure, every label, every Lean name and every measured number stands at the same place in both. Where they would diverge, the German edition governs and the divergence is a translation backlog, not a contradiction between two originals. Lean names, commands, axiom profiles and measured figures are not translated.

What this paper is about

It is about a formalisation that labels its own claims, and about a reviewing practice meant to be transferable. Its subject is the reformulation of Gotthard Günther's polycontextural logic in a type-theoretic proof environment.

The project works with one definition, and it stands at the front — quoted from README.md, state b51b4fc, and at home there and not here:

A structure is formally-operationally polycontextural if it carries several local contextures — regions closed under the admitted signature, which may overlap — and if there is an operation on it that acts on each of these contextures like one of the classical connectives and nevertheless is not generable from the intra-contextural term calculus.

Formally-operational means: this non-generability is not asserted but machine-checked as a theorem.

This definition is narrower than Günther's world-picture notion of polycontexturality and stronger than mere many-valuedness or plurality of roles. It is the measure against which everything else is to be read.

As of this edition the project's definitions edition carries a second stage of the concept — formally-operationally polycontextural in ascent, predicated of families rather than of structures, with four clauses and four named theorems as carriers. It stands exactly once, in §6.3 of the definitions edition, and is deliberately mirrored nowhere; this paper describes it in §V and does not quote it.

Two axes per claim

Every claim in this paper carries two labels.

First axis — the kind:

Second axis — the range, measured on the import closures and not on the directory:

Across these stands a mark that is not a closure value: frozen denotes the branch PathC/, shut down with explicit thawing conditions. A frozen module can still be built — two of eighteen are reached through a call target.

The reason for the second axis is not tidiness. Proved means something else in the aggregate than in a call target: there a machine barrier bites, here it does not. A paper that carries theorems of both ranges without distinction claims for the one an assurance only the other has.

The two columns of the definition ledger — carrier status and assignment status — are a third thing: they classify carriers, whereas the labels here classify claims in running text. The ledger table lives in docs/definition-ledger.md and is not repeated here.

New in this edition is a third distinction that is not an axis but a form of measurement: wherever an axiom profile is explained, the explanation carries either a measurement with a differential — two versions differing in exactly one quantity — or the mark unmeasured. What that means and where it comes from stands in §IX.

What this edition changes relative to the second

The second edition is dated 1 August 2026 and measures at commit e5ef3d7; it remains reachable under docs/rev2/ and is not updated. The two files are docs/rev2/de.html and docs/rev2/en.html, built like the rev1/ filing.

Edition Rev2 (1 August)this edition (3 August)
world-picture notion (L06-1)open, one ledger rowboth structural clauses carry theorems; the totality open, with four references
project definitionone stagetwo stages; the first recast, the second over families
richness figure 2^C(m,2)computedproved, as a bijection together with its cardinality
value-filling of patternsopen rowtwo bridges proved (two-valued and k-valued)
M₃ counterexamplecomputed, then an addendumproved and integrated
axiom provenancedeclaredmeasured at four sites, with differentials in one quantity
ledger79 rows91 rows, revision 10, two-digit row IDs
figures3018 / 396 / 7263255 / 470 / 792

The five dated figure sites of the Rev2 editions are dissolved with this edition: every number again carries the state at which it was measured.

What has not been added, so that no one has to look for it: the proemial relation as a whole is not built — a section of it is term-borne, and which one stands in §XI; the compound contexture is carried in one of its three ledger lines and is not built as a concept; a limit object of the ascent is neither built nor claimed nor excluded; the totality of the world-picture notion remains open and is carried as open (L06-1, carrier status Offen — and why that is a result and not an arrears stands in §V.6).

I · The ground: a combinatorics prior to logic

At the very bottom lies a structure that is not yet a logic: the kenogrammatic layer, a combinatorics of empty places. Finite sequences are classified solely by which places repeat which. No values, no negation, no truth; only distinguishability and repetition. Everything later is an assignment on these patterns.

Günther distinguishes three granularities (source-verified). The proto-structure counts only how many distinct marks occur. The deutero-structure records the repetition profile. The trito-structure retains the position-exact pattern. Only the third is fine enough to be the ground of a logic: an assignment must be able to say which places carry the same value.

sequence 1 sequence 2 normal form abb ac xyy xz 011 02 proto3 marks deutero2, 2, 1 trito0, 1, 1, 0, 2 coarser → finer
Figure 1 — The same sequence in three granularities: proto, deutero and trito as increasingly fine classifications. The coarser ones are quotients of the finest; only the finest can say which places carry the same value.

Formally the trito-structure is represented by a normal form: a sequence of natural numbers beginning with 0 in which each new mark exceeds the previous maximum by exactly one — known in combinatorics as a restricted growth string. The predicate is decidable, and the canonisation is built as a procedure, not asserted (proved · aggregate; ledger row L16-1, K.relabel, axiom-free profile).

The built-in directional asymmetry

The maps between patterns are not symmetric. A pattern whose largest mark is k has exactly k+2 extensions — it repeats one of the existing marks or introduces a new one. Retraction, by contrast, is unique: delete the last place and precisely one pattern remains (computed).

This is no notational nicety but the structure itself: ascent chooses, descent computes. Between the two directions lies not a change of sign but a difference in the kind of determinacy. Günther calls one direction evolutive, the other emanative (source-verified). In §V.3 this asymmetry returns as a theorem: the ascent that chooses exceeds every finite stock of values.

011 emanative unique pattern 01 10 011 00 011 01 011 02 evolutive branching
Figure 2 — Retraction unique, extension branching. A pattern with largest mark k has k + 2 extensions and exactly one retraction (computed).

The morphogram bridge

On the normal form sits pattern identity: two sequences carry the same morphogram if their normal forms agree. The core holdings (proved · aggregate):

rowcarrierkindprofile
L16-1K.relabeldefinitionaxiom-free
L16-2K.rgs_unique_of_patterntheorem[propext, Quot.sound]
L16-3KM.SamePatterndefinition—
L16-4KM.samePattern_iff_patterntheorem[propext, Classical.choice, Quot.sound]
L16-5KM.samePattern_iff_common_nftheorem[propext, Classical.choice, Quot.sound]

No quotient type. The bridge is built as a normal-form semantics, not as a quotient; that was a construction decision and not an embarrassment. L16-5 carries the note that the characterisation via the common normal form hangs on List ℕ, whereas L16-4 is type-transverse.

Value-filling, in Rev2 the open row of this section

Rev2 carried an open question here: which patterns can be filled by a sequence of values at all? As of this edition it has a proved answer — in the two-valued version here, in the k-valued version in §V.3:

Theorem (fillability, two-valued). A pattern is fillable by a two-valued sequence if and only if its marks do not exceed 1.
(proved · aggregate; KF.marksLeOne_iff_fillable)

The direction from the mark to the sequence is an encoding; the converse runs via the density of the normal form — a mark ≥ 2 forces three pairwise distinct marks, hence three distinct values, and a two-valued sequence does not have them. Counted at length four, both numbers as theorems: of the 15 patterns of length 4 exactly 8 are two-valued fillable (proved · aggregate; KF.card_rgs_four, KF.card_rgs_four_fillable, with fillable_card_lt_card as a strict inequality — the number 15, the fourth Bell number, is thereby proved inside the corpus and not imported). A witness of the excess stands beside it: the pattern 0,1,2,0 needs three values. The kenogrammatic layer is richer than any fixed valency — at length four as an inequality, in general as the theorem of §V.3. The current state of this section's ledger rows (by now up to L16-10) is carried by the ledger itself; §VII shows the mechanism.

II · Contextures: two discontexturalities, one of them proved

A contexture is an assignment on the ground with the rank of a logic of its own.

1 · What discontexturality is not

Günther's most elementary case of discontexturality is the opposition of Being and Nothing — and for him these two are isomorphic (source-verified). Between them there is a complete, structure-preserving map, and they are discontextural nonetheless.

From this follows the formalisation decision that carries this paper: discontexturality appears not as the non-existence of a map, but as non-generability in the term clone — as the impossibility of assembling a mediating operation from intra-contextural means. What is missing is not the map, but the path to it from within.

Two short forms are therefore excluded and carried in the corpus as construction prohibitions: Disjoint K₁ K₂ fails because the elementary contextures overlap pairwise in exactly one value and this overlap carries the proofs — which is why the recast project definition names the permission to overlap in the definition itself rather than in a comment; ¬ ∃ f : K₁ → K₂ fails at the basic case Being/Nothing.

2 · The first relation: symmetric, and proved

Günther names two fundamental relations. The first is the exchange relation between elementary contextures: an unordered pair, symmetric, without directional sense (source-verified).

Theorem (E3). For every m ≥ 4, a contexture-preserving, locally classical operation on m values lies in the clone of the intra-contextural connectives if and only if it is the minimum or the maximum.
(proved · aggregate; GeneralCloneBound.locally_classical_in_clone_iff)

This is a characterisation, not an existence claim: the set of non-assemblable operations is not merely non-empty but completely determined. And in this edition it has become the most consumed theorem of the corpus: two applications (§VI), the ∀m witness of the ascent and the reachability half of the richness count (§V) all compute on it; none rebuilds it — consumption is measured at the proof term, non-rebuilding by must-not routes.

The exchange relation itself has gained a second, unexpected property in this edition: it is stage-relative. What that means and why it is provable stands in §V.2.

3 · The second relation: asymmetric, and divided

The second relation holds between contexture and trans-contexturality. Its standing is a divided result: the structural part is available as a theorem, the conceptual part remains modelling — that a change of stage is a change of contexture is closed by no theorem. A contextural boundary never closes by theorem alone, but by definition plus theorem (posited, marked as such in the corpus).

4 · Where the posit sits

A two-element set of neighbouring values is an elementary contexture in Günther's sense. (posited — the load-bearing choice of the entire series of bounds)

There is a substantive reason for this choice, and it is not cut to fit after the fact: a two-element set is closed under the local operations if and only if its two elements are comparable. On incomparable pairs the minimum leaves the set — then it is no longer a self-contained connection and no contexture in the sense of the definitions. Since the M₃ move this reason is itself a theorem (meet_leaves_incomparable, proved · aggregate): the posit remains a posit, but its ground is provably the one claimed. The limit of the formalisation lies in the concept, not in the proof.

III · The mode of proof: the differential

How does one prove what is inalienably missing from a structure, without the self-contradiction of a system certifying its own limit from within? Not positively within one system, but differentially between two. For each structural feature a poor class is named and a pair is exhibited: over all instances of the poor class the feature is impossible — as a universally quantified theorem — and a rich witness carries it.

the hard halfthe easy half
X is impossible — universally quantifiedX is exhibited — a construction
all strict orders, the generated cloneone concrete structure, built internally

Three marks discipline the mode. First, the poor model is built internally, not asserted in the metalanguage. Second, the result is conditional relative to the posited premises; it symmetrises the sceptic, it does not compel him. Third, what is proved is the form, never the naming — that a contexture-relative choice of operation is unreachable from local means is a theorem; that this choice is called mediation remains interpretation. The file in the corpus is therefore named NonUniformCloneBound and not Mediation.

poor class all strict orders, the generated clone X is impossible — universally quantified the hard half ⊢ rich witness one concrete structure, built internally X is exhibited — a construction the easy half
Figure 3 — The differential and its two unequally heavy halves. It is delivered only with the negative one.

New is that in this edition the form was applied twice to the architecture itself. Once to a theorem of the ascent: the parity obstruction (§V.2) has exactly the differential shape — the impossibility half universally quantified over all maps, without injectivity or monotonicity assumptions, the possibility half with an explicit witness beside it. And once to a measurement: wherever an axiom profile is to be explained, the workshop has since this block required two versions differing in exactly one quantity (§IX). The differential is thus not only the mode of proof of the subject, but also the mode of checking of the workshop.

IV · The witnesses: the series of bounds

theoremkind of non-internalityreach
Drejection does not lie in the clonetranscendence — it leaves the contexturem = 3
E1complete classificationnon-uniformity — it stays and chooses differentlym = 3
E2characterisationexactly minimum and maximumm = 4
E3characterisationexactly minimum and maximumall m ≥ 4
E4stage aggregationface of applicationm = 4

All five: proved · aggregate. The series has not grown longer since Rev2 — it has been consumed more widely, and its numbers have changed kind: what was computed there is in part proved here.

1 · D — locating the first bound

The rejection operation refuses an offered pair of values as a whole and does not lie in the clone over three values (proved · aggregate; the proof is arity-blind and runs via contexture preservation).

Lying outside a clone is cheap in itself: in the binary fragment the clone comprises 82 of 19,683 operations, 0.42 per cent (computed). The claim does not rest there. The basis preserves three invariants, and every term over it preserves all three — not merely the generators (proved · aggregate, by term induction). Rejection violates exactly one of them and preserves the other two. It therefore lies not somewhere outside, but at a determinate place.

The marginal note of Rev2 still holds: the binary clone fragment has the same size 82 at three, four, five and six values (computed) — the number hangs on the signature, not on the number of values.

all binary operations over three values: 19,683 generated clone 82 rejection three invariants are preserved by every term (proved · aggregate): two-valued embedding · fixed point · tolerance relation rejection violates exactly one and preserves the other two the clone size 82 holds equally at four, five and six values — it depends on the signature, not on the number of values
Figure 4 — The location: not somewhere outside, but beyond exactly one of three preserved invariants. Clone counts computed, outside the corpus.

2 · E1 — the second reason, and the complete division

An operation can fail to be assemblable for two distinct reasons: by transcendence — it leaves the elementary contexture (this is D) — or by non-uniformity — it preserves every contexture, acts classically on each, and chooses different classical operations on different contextures.

The second reason has a witness, and a complete one: of the eight choice patterns over three values exactly four are assemblable and exactly four are not (proved · aggregate; the division is closed under negation conjugation — a transport lemma replaces three copies of a proof by one theorem).

The four reachable patterns are not four arbitrary ones (computed). Ordering the three elementary contextures as {0,1}, {0,2}, {1,2}, they are (min,min,min), (max,min,min), (max,max,min), (max,max,max) — a chain of thresholds and not a scattered selection. The word choice pattern in this paragraph is, incidentally, more than a manner of speaking since this edition: that a locally classical operation is nothing but a choice vector over the elementary contextures is proved as a bijection (§V.4).

3 · E2 and E3 — from existence to characterisation

At four values the picture tips: of the 64 locally classical operations two remain assemblable, namely minimum and maximum themselves (proved · aggregate). At five values it is 2 of 1,024, at six 2 of 32,768.

Rev2 wrote at this point: the pattern counts are no accident, there are 2^C(m,2) patterns — and carried that as computed. As of this edition it is a theorem: the number of locally classical operations on m values is 2^C(m,2), for every m, as the cardinality of a proved bijection (§V.4); the marks 8, 64, 1,024, 32,768 are instances of that theorem and no longer counts of their own. C(m,2) = m(m−1)/2 is the number of elementary contextures of an m-valued system; the triangular numbers Günther carries for compound contextures and for the hierarchy of ontologies stand here as the exponent — now proved, not observed.

E3 hangs on no fixed number of values — D and E1 stand at three values, E2 at four. Its proof uses no decision procedure and no case distinction on m; it runs over six families of edges with closed-form breaking points and an induction on path length.

The threshold lies at four, and this is not an artefact. At three values the statement is false — there four of eight patterns are assemblable. At two values there is no witness at all, because there is only one contexture. This meets Günther's own threshold: the classical two-valued system does not yet represent a compound contexture, the second value yields nothing new and stands unmediated over against the first (source-verified). Mediation begins at three — in Rev2 as a counted zero, as of this edition as a proved one: at m = 2 the total is 2^1 = 2, and both operations are generable — the excess is zero, as a theorem (§V.4).

4 · Robustness: how much each bound claims

A non-generability bound hangs on its invariant. If the signature is extended by constants, the bound survives precisely when the invariant is reflexive.

witnessinvariantsurvives constants
Done elementary contextureno
E2, E3, E4neighbourhood with broken edgesyes

A bound that falls to an added constant claims less than it appears to. The inspection is written into the corpus as a duty before every new witness — and the four moves of this edition draw no new bound: they consume the existing one, including its constants version, and their file headers say explicitly that there was nothing to inspect here, so that no one misses an inspection.

V · The ascent: the two structural clauses of the world-picture notion

Günther takes polycontexturality as a world picture: reality as a system of infinitely expanding contextures with growing structural richness. The world picture is no subject for theorems and is not claimed. But the two structural clauses are subjects for theorems, and as of this edition both have them — on four carriers, built in four moves, each with its own specification and review.

1 · The stage ascent: the gap is inhabited everywhere, and it travels along

The E3 characterisation determines what is reachable; by itself it does not yet say that the unreachable is inhabited at every stage. Now a theorem says it:

Theorem. For every m ≥ 4 there exists a locally classical operation on m values outside the clone.
(proved · aggregate; SAsc.exists_locally_classical_not_in_clone — as a consumption of the E3 iff, not as a new bound)

The witness is a family: w acts as maximum exactly on the elementary contexture {0,1} and as minimum elsewhere — the same rule at every stage. The choice of the max-island is a chosen basis, not a found one; any other pair would give another witness, and the file header says so. What matters is stage compatibility: under the embedding Fin m ↪ Fin (m+1) stage m+1 agrees with stage m on the embedded square (proved · aggregate; SAsc.w_castSucc). That is the formula of the definitions edition — "stage n contains all structures of stage n−1 as substructures" — as a theorem, not as a programme. Beside it the growth arithmetic: each step brings exactly m new elementary contextures (SAsc.choose_two_succ), and the image of the stage misses the new element (SAsc.ascent_proper) — what is added was not there before.

2 · The parity obstruction: the ascent has no signature-faithful shape

The embedding carries the lattice and the witness. It never carries the negation — at no place, for no m (proved · aggregate; SPar.castSucc_negFin_ne; the values differ at every place by exactly one). One might suspect a cleverer map would heal this. The answer is a differential in the sense of §III:

Theorem (parity no-go). For odd m, no map Fin m → Fin (m+1) commutes with the negation — without injectivity or monotonicity assumptions.
(proved · aggregate; SPar.odd_no_neg_compatible)

The argument is three lines and therefore exhibitable: for odd m the negation a ↦ m−1−a has a fixed point, the middle value; a compatible map would have to send it to a fixed point of the successor stage, and the even successor stage has none. For even m, by contrast, an order-faithful, negation-compatible embedding exists, with an explicit witness: eSym leaves the gap at the middle place (proved · aggregate; SPar.eSym_strictMono, SPar.eSym_negFin), and from m ≥ 4 the witness family of §V.1 ascends under it as well (SPar.w_eSym). The number of compatible embeddings for even m — 2, 8, 48 for m = 2, 4, 6 — remains computed and outside the corpus; what went in was existence.

The stage step therefore fails to carry the full signature {∧, ∨, ¬} precisely when m is odd. The lattice ascends stepwise, the negation only in parity jumps — the exchange relation is stage-relative. The interpretation — that this is exactly why the ascent has no shape that would close it; that the expansion is genuine because it cannot be caught up signature-faithfully — is called that and stands in no theorem name. This is not a "no colimit" theorem, and none is claimed; about double steps m → m+2 the theorem says nothing, and the file says that too.

3 · No finite stock of values: infinity at the object

The two-valued fillability bridge of §I generalises:

Theorem (fillability, k-valued). A pattern of length n is fillable by a k-valued sequence if and only if all its marks lie below k.
(proved · aggregate; KU.marksLt_iff_fillable, including the boundary cases: at k = 0 with a non-empty pattern both sides are false, at the empty pattern both are vacuously true)

The path from the mark to impossibility is the same as in §I, only general: a mark ≥ k forces, via density, k+1 pairwise distinct values, and a k-valued sequence does not have them — the closing cardinality argument is the one place where the proof goes beyond the encoding.

On the stream layer this becomes the infinity claim, with the identity stream as the first named corpus object (KU.idRGSStream — the anonymous illustration in the stream file was not consumable and still stands there):

Theorem. A kenogrammatic stream with unbounded marks is exceeded by every finite stock of values: for every k there is a prefix length beyond which the prefix is not k-valued fillable — and the identity stream is such a stream.
(proved · aggregate; KU.unbounded_not_fillable, KU.idRGSStream_not_fillable)

That is "infinitely expanding" in its most honest formal shape: as a negative theorem about every finite system of values, without a limit object — the evolutive direction of §I, the one that chooses, provably exceeds every stock it could choose from. The interpretive jump is stated explicitly in the corpus: kenogram is not contexture; reading the k-valued sequences as a "k-valued system" hangs on the bridge that supports it as a theorem, and the ledger row of the theorem names the jump (interpretation, marked).

4 · The richness count: exponentially many, two reachable

Theorem (bijection). The locally classical operations on Fin m are in bijection with the choice vectors over the ordered pairs; their number is 2^C(m,2), for every m.
(proved · aggregate; CV.locallyClassicalEquiv, CV.card_locallyClassical)

The bijection is constructive in both directions: forwards one reads off, for each pair, whether the operation acts there as maximum — well defined because minimum and maximum come apart at distinct places; backwards the choice vector builds the operation, with a forced diagonal. "Locally classical" is thereby no longer a mere property but a blueprint: one choice per elementary contexture, nothing further. The boundary cases carry without side conditions as well: for m ≤ 1 there are no pairs and exactly one operation, 2^0 = 1.

Theorem (reachability). From m ≥ 4 exactly two of these lie in the clone: minimum and maximum — as a set equality, with min ≠ max as an inequality of its own.
(proved · aggregate; CV.clone_locallyClassical_eq, CV.min_ne_max; both halves consuming E3. Deliberately no cardinality over the clone predicate: "lying in the clone" is phrased as an existence over terms and therefore carries no decidability instance; a counting form over it would need classical instances without necessity. The set equality does without them)

Theorem (growth). From stage to stage the number grows strictly; and from m ≥ 3 it exceeds two.
(proved · aggregate; CV.card_locallyClassical_lt, CV.two_lt_card_locallyClassical — the bounds are sharp: at m = 0 both sides of the growth stand at 1, at m = 2 everything present is generable)

The staggering of the beginnings — at two values no excess, at three eight against four, from four 2^C(m,2) against the constant two — is the quantitative shape of "growing structural richness at constant reachability". That it is that is interpretation and is marked as such; what is proved is a bijection, a cardinality, a set equality and two inequalities.

5 · The second stage of the concept

The four moves together carry a second-stage definition, which as of this edition stands in §6.3 of the definitions edition — over families of structures: every member formally-operationally polycontextural; embeddings that preserve the witness; strict growth of the stock; at every member exactly the same two named reachable operations. Satisfied by the stage family of the Fin m from four upwards, with four theorems as carriers. Not claimed there, explicitly: a preservation of the full signature (the parity obstruction forbids it — the preservation clause therefore speaks of the witness and not of the signature), a limit object, and the world-picture notion itself. Deliberately no Lean bundle: a structure with four Prop fields that no theorem requests would be a renaming of the library — the same decision with which the project already let a planned naming layer lapse. The definition stands exactly once and is not mirrored — not here either; this is a description with a reference, not a second site.

6 · What this means for the world-picture notion

The ledger row L06-1 — the strong, world-picture notion — still stands at Offen, now with four references to the probes and still without a carrier. That is the result, not an arrears: that the totality ("reality as …") is not a structural property is the load-bearing Deutung of this edition — the only formal path to it would be a constitutive posit; it would not approximate the definition, it would posit it, and it is not taken. What is structure in that notion has theorems.

VI · The application layer, and what is measured on it

Two applications are in place: a release policy over four authorisation levels and a source authority over four evidence levels. Both are aggregate.

The load-bearing claim is not that they exist. It is that the applications consume the generic theorem instead of reproducing its proof. That is measurable at the proof term and nowhere else, and it is measured (measured · aggregate):

theoremreferenced in the term
PolicyCheck.freigabe_nicht_erzeugbarGCB.locally_classical_in_clone_iffyes
RAGAuthority.autoritaet_nicht_erzeugbarGCB.locally_classical_in_clone_iffyes
PolicyCheck.freigabe_nicht_erzeugbar_konstantenGCB.constant_clone_min_or_maxyes
RAGAuthority.autoritaet_nicht_erzeugbar_konstantenGCB.constant_clone_min_or_maxyes
PolicyCheck.freigabe_lokal (control)the same targetno
RAGAuthority.autoritaet_lokal (control)the same targetno

The control is the point. A route that reports yes everywhere measures nothing. This one discriminates, and it does so at the prerequisite lemmas of the same files — at the nearest non-hit and not at some arbitrarily distant counterpart.

The limit in the same breath

The bound bites on linearly graded carriers from four levels upwards. From non-generability follows no security, legal, truth or retrieval guarantee. What the theorem says is: a mixed policy is not assemblable from local, contexture-blind checkers — in whatever wiring and to whatever depth. What it does not say is that the policy is right.

On a lattice of equal-ranking roles the bound falls. On the smallest non-distributive lattice M₃ — bottom, three incomparable elements, top — the binary clone fragment comprises 166 operations, of which, over seven comparable pairs, ten are locally classical, and eight of those are neither infimum nor supremum (computed). The witness is, since the M₃ move, proved and no longer computed: M3CloneWitness.m3_mixed_term_exists exhibits the term (x ∧ y) ∨ ((x ∨ y) ∧ (¬x ∧ ¬y)) — locally classical on every comparable pair, globally neither infimum nor supremum (proved · aggregate, choice-free; the carrier is an inductive type of its own, to exclude any instance ambiguity). With it the conceptual limit stands as a theorem (meet_leaves_incomparable, §II.4). Exactly the pattern E3 excludes on linear scales is assemblable here — the clone counts remain outside the corpus, what went into the corpus is the existence form.

A transition graph of named roles without a grading is not carried by this bound; what remains provable there is reachability, and that a type system achieves too.

VII · The ledger and the register: the concepts and their carriers

Günther's concepts stand in a definitions edition of nineteen paragraphs. The question which concept has which Lean carrier is machine-checked.

The ledger carries 91 rows, of which 75 have a carrier over 67 distinct carrier names, and covers 19 of 19 paragraphs (measured; revision 10). The carrier statuses distribute over 57 theorems, 17 definitions, one posit and 16 open rows. Five carriers appear in more than one row; the surplus rows are eight, and 75 − 67 = 8 is checked as an equation. This sentence stood wrong in the self-report for five revisions — "eight carriers more than once" instead of "five carriers, eight surplus rows" — and none of the eight rules could see it, because they read rows and not sentences about rows; what found it was the rule of reading the neighbourhood of every number one touches.

The paper does not establish the assignment itself. It shows the mechanism that holds it; the table lives in docs/definition-ledger.md and there alone. Eight rules check it, six at lint time and two at build time:

R3 through R8 set the exit code of the lint. Sixteen open rows remain open — among them the strong notion (L06-1, now with four references). An open row is not a defect of the ledger but its achievement.

The register of posits

Posits do not disappear, they are registered. The load-bearing rule is not "the aggregate contains no posit" but no theorem of the aggregate hangs on a posit. A field of type True can enter no proof; why it must nevertheless be marked is an epistemic and not a logical argument: what stands in the aggregate reads as certified holdings. The class division (placeholders with an exit criterion against constitutive posits with a justification) and the standing probe — no non-projection of the aggregate has conclusion True, value 0, with a known counter-count on the projection side — hold unchanged. Re-measured at the generation state and unchanged: 30 placeholders and 2 constitutive posits, the equation 32 = 30 + 2 holds.

VIII · Movement and time

Over the web lies a modal triad as a stock of movement: displacement — the same structure at another place; reorganisation — the same parts in another order; irreversible positing — the step that is not taken back. Their compositions are smooth in exactly one direction; there is no canonical interchange of directions.

Before that, the place where Günther first came upon the matter is worth a look. In 1937 he sets three propositions about potency side by side, each immediately plausible on its own: time is more powerful than will; thought is more powerful than time; will is more powerful than thought. Take the first two together and it follows that thought is more powerful than will — the third says the opposite. The three close into a circle (source-verified, Wahrheit, Wirklichkeit und Zeit, Paris 1937).

What the architecture makes of this is a differential and not a thesis. What is proved is the poor side: in every transitive, irreflexive relation — on every carrier, without exception — a three-cycle is impossible, and there is likewise no relation-preserving image of such a cycle into a strict order. It is not claimed that thought, will and time behave this way; what is claimed is: if they do, then no linear order is their measure — not because none has been found so far, but because none can exist.

thoughttimewill memory reaches back to the beginning decisions fall in time “that I think” rests on “that I will to think” ≻ means more powerful than Chaining the first two gives thought ≻ will — the third says the opposite. The cycle closes.
Figure 5 — Günther's three principles of potency of 1937 and their intransitive cycle. What is proved is not the cycle but its impossibility in every transitive, irreflexive relation (proved · aggregate).

The carriers of this section

The load-bearing theorem of the potency cycle is Proemial.IntransitivityDifferential.no_cycle_in_strict_order (proved · aggregate, profile axiom-free). That such a cycle also has no relation-preserving image into a strict order is carried by cyc3_not_representable ([propext]); that the cycle itself holds is carried by cyc3_holds, cyc3_irrefl and cyc3_not_transitive. All six theorems are guarded. The missing interchange of directions is Proemial.NoUniformSwap.no_uniform_swap ([propext, Classical.choice, Quot.sound]; the choice component presumably comes from the category machinery — the path of the axiom into the term is not measured, see §IX). The full name with its module is no pedantry: a theorem of the same name lies in a call target, unguarded, as a historical record — whoever names the name without the module leaves open which one is meant, and the second axis runs empty.

Newly connectable, without claiming more here: the parity obstruction of §V.2 is of the same genus — an impossibility of transporting a direction, universally quantified over all candidates, with a proved possibility half beside it. The intransitive 1937 motif and the stage-relative exchange relation are two shapes of the same finding: Günther's structures resist embedding into a single linear measure — and that is provable, not programmatic.

IX · The safeguards: guards, profiles, ranges

An architecture that asserts impossibilities must be able to say what its proofs rest on — and must prevent that from changing silently.

The standing

figurevaluerange
constants checked (gate)3255import tree of Reformulation, name-filtered
axiom guards, written470 in 51 filesReformulation/ and Foreign/
axiom guards, enforced460import closure of the five default targets
theorems792Reformulation/ alone, widened route
build jobs1307the five default targets together
declared gaps0whitelist empty

The guard equation holds: 470 written = 460 enforced + 10 in Foreign/PeresMermin.lean. The theorem count is comparable with the Rev2 figure 726 — the same route, widened since Rev2; the increase is the theorems of the four ascent moves and of this block's instrument moves. Figures not re-measured since e5ef3d7 — statement pins, def count, profile distribution, import-closure map, clone-construction replicability — do not appear in this edition with a new state; where Rev2 carries them, they hold there, at the commit named there. Their state anchor is therefore e5ef3d7, visible in the Rev2 edition; none of them is re-measured.

The four mechanisms

First, the axiom guards. For every load-bearing theorem the axiom profile is measured and frozen as an expectation; if the proof basis shifts silently, the build breaks. The guard secures the basis, not the wording. Since this block, file completeness also covers definitions and instances whose value contains proof terms — with a measured justification, not out of caution.

Second, the statement pins. Guards secure the basis, not the formulation; a weakened theorem with the same profile would pass. Pins nail down the full wording and break the build on definitional drift.

Third, the global gate. It reports:

AXIOM-GATE GRÜN — Aggregat Reformulation (3255 geprüfte Konstanten)
zieht kein sorryAx. Whitelist leer.

Fourth, the separation of ranges. Five targets build on lake build; five more run only when called. The gate's assurance holds for the aggregate and for no other range; the target table together with the warning that build outputs must not be summed stands in Rev2 and holds on.

Measured axiom provenance — new as a practice, run four times

Measuring a profile is cheap; saying where an axiom comes from is a second measurement, and since this block it has a form: two versions differing in exactly one quantity. Four findings (measured, each with a must and a must-not case):

What is measured throughout are profiles and dividing lines; what is not measured is the path of the axiom into the term — the file headers say both, in that order.

What a foreign grep finds

Whoever searches the tree for sorry finds three numbers, and each answers a different question (measured): 132 raw word occurrences across the whole tracked holdings, 97 in the Lean sources, 27 affected declarations — all of them outside the aggregate. The third is the load-bearing one; the first two count prose along — freeze notes, doc strings, the phrase "sorry-free". The frozen branch PathC/ stays frozen, with the same thawing conditions; green means compiles there, not gap-free.

X · The instruments as a subject of their own

Alongside the theorems something has arisen that knows nothing of Günther and could travel further: a reviewing practice for the formalisation of philosophical texts. Whoever formalises a thinker has a problem foreign to pure mathematics — the interpretation outruns the term. A theorem is built, its name is chosen, and the name claims more than the theorem. Against this gradient no resolutions help, only mechanisms.

Rules, each from a misstep

The eleven rules of Rev2 hold on — from "look for the theorem first, then build only as much carrier as the theorem demands" to "build outputs of several targets are not summed". This block has added four:

  1. A route carries a must and a must-not case, and its name boundary is a character class, not a colon — the colon is an assumption about the binder form of the build, not a check. Violated three times in a row, each time differently; the sharpening of the second error was itself the third.
  2. The stipulations of a specification are checked against each other, not only each on its own. Two individually correct stipulations can jointly force something neither demands — three times, at rising cost: first a linter exception, then a non-construction decision, then an axiom in a profile.
  3. A statement of holdings is a pointer, not a list. Enumerating statements without a route go stale silently; in one block four classes of them were replaced by pointers, among them nineteen identically built ones in a single file.
  4. Claims about the reachability of a location are write probes, not inferences from empty search results. A missing result looks like an answer; twice it was none.

The toolchain pitfalls have grown by two, and they are filed in two different places: an unresolved type name silently becomes a variable under mild auto-binding, and the follow-up messages point at healthy places (control: #check on the bare name) — that one stands in the pitfall list of the published corpus; and #print axioms breaks its output at the sum of name and profile length — measured against the fact that a longer name with a shorter profile does not break — that one is filed in the unpublished specification corpus and cannot be looked up in the codebase.

The lint

The doc lint checks three groups unchanged: the rank claims of group (A) are read, not enforced — a breaking lint gets circumvented, a reporting one gets read —, group (B) guards a conceptual relapse, and the ledger group (C) sets the exit code. Measured at the generation state: (A) 49 running hits and 4 in the frozen rev1/ and rev2/ editions, (B) 0, (C) 0 — the lint runs green. Six of the running hits stand in this edition itself: a route whose search term occurs in prose counts its own documentation.

The list of errors

The evidence that the review layers bite is the list of errors — and it is continued, not shortened. The Rev2 list holds on; from the block that led to this edition, among others:

None of these errors was found by the instance that made it. The sentence stood so in Rev2, and this block has not refuted it but confirmed it in both directions.

XI · Reach and limit

What this architecture claims is conditional and is carried as such. It does not promise to compel the sceptic to acknowledge an irreducibility; it promises to symmetrise him — from the comfortable position this reduces to the known to the explicit position I posit the one encompassing logic, which is itself a posit and as such no longer has precedence.

The three limits

First, mathematical: M₃. The characterisation lives on linearly graded carriers and falls on lattices of equal-ranking elements. This is not a proof gap but a counterexample — and since the M₃ move it stands on the same ground as what it limits. That "the characterisation falls on lattices" remains a reading: E3 is formulated on linearly ordered carriers, and a lattice version of E3 does not exist.

Second, hermeneutic: the identification. That the two-element value set is Günther's elementary contexture is settled by no theorem. The posit stands on grounded soil — since the M₃ move, theorem-supported — and remains a choice.

Third, in principle: the spontaneity of enactment. Not the will as a function, but solely the that of enactment is no structural feature; there is no poorer model in which it is missing as a position, because it is not a position.

What is not built

The proemial relation as a whole — the core of Günther's theory — is not built. A section of it is term-borne, namely the stage movement: the descent has a section (appending a place and deleting it again returns to the start), it is no isomorphism (two distinct preimages lie over one pattern), and both together show that the movement does not collapse to an isomorphism. That this fibre asymmetry is Günther's proemial type inversion is settled by no theorem — it is interpretation, and the file header carries it as such. Untouched are the proemial interlocking and the generality over arbitrary permutations of places. Scope, measured: the four probes do not lie in the aggregate and carry no axiom guard; they are built on every lake build through a default target of their own, but the gate's assurance does not extend to them. The compound contexture is carried in one of its three ledger lines: its exponent C(m,2) is a theorem as of this edition, with assignment status Deutung; the two remaining ledger lines on the subject stand at Offen. As a concept — not as a number sequence — it is not built. The totality of the world-picture notion is open and is carried as open; its two structural clauses have theorems, and the limit column of the open row names them. A limit object of the ascent is neither built nor claimed nor excluded; the directed system as an object remains an open ledger row. Sixteen ledger rows stand at Offen, and they are to stay there as long as no carrier carries them.

The note on counting compound contextures holds on: the definitions edition gives n(n+1)/2 from one upwards and states at the same time that a compound contexture requires at least three values; the two do not agree — the first compound contexture is the three-valued one, the 1 belongs to the ontology sequence. The architecture counts m(m−1)/2 elementary contextures; this is compatible with Günther's series, but it is a stipulation and not a derivation.

The picture

A ground that counts repetition and whose value-filling now has two proved bridges; logics whose separation is not posited but proved — in a form that withstands Günther's basic case; a mode of proof that knows its hard half and in this block measured the workshop as well; a series of witnesses whose numbers have turned from computations into theorems; an ascent that is inhabited, preserves itself, grows strictly — and whose parity obstruction is proved, whence it has, so the file header's interpretation, no signature-faithful shape; an application layer with measured consumption; a ledger of ninety-one rows, sixteen of them open; a gate with no sorryAx; and three limits, none of which is a defeat.

What is posited stands at the beginning; what is proved is counted; what is interpretation is called so.

Appendix · Counting routes

So that the figures are recomputable and not merely credible, each carries a route. All entries hold at commit 56fe9a0 unless anchored otherwise; the two following commits (b51b4fc, fb41c2f) shifted no figure (measured, in the corresponding report). Figures not re-measured since e5ef3d7 do not appear here; they hold in Rev2, at the commit named there.

quantityvalueroute
constants checked3255build output of the axiom gate
guards written470 / 51 filesgrep -rE '#guard_msgs.*in #print axioms' over Reformulation/ and Foreign/
guards enforced460the same route, import closure of the five default targets; equation 470 = 460 + 10 (Foreign/PeresMermin.lean)
theorems792widened theorem route over Reformulation/; comparable with Rev2 (726), same route
build jobs1307lake build, not summed
Proemial/62 files / 475 theoremsstructure table
sorry132 / 97 occurrences · 27 declarations (load-bearing)word boundary, occurrences rather than lines, over git ls-files
ledger91 rows / 75 pairs / 67 names / 19 of 19doc lint group (C); surplus 75 − 67 = 8 as an equation
carrier statuses57 / 17 / 1 / 16self-report of the ledger file, checked at lint time
locally classical operations2^C(m,2), every mproved: CV.card_locallyClassical; 8/64/1,024/32,768 are instances
of these in the clone2 (from m ≥ 4) · 4 of 8 (m = 3) · 2 of 2 (m = 2)proved: CV.clone_locallyClassical_eq resp. E1; the zero excess at 2 from CV.two_lt_card_locallyClassical with its sharpness
patterns of length 415, of these 8 two-valued fillableproved: KF.card_rgs_four, KF.card_rgs_four_fillable
negation-compatible embeddings0 (odd m) · exist (even) · 2/8/48 at m = 2/4/6non-existence and existence proved (SPar.); the counts computed, exhaustive enumeration over all maps resp. injections
clone fragment {min,max,neg}82 at m = 3…6computed, unchanged from Rev2
M₃166 / 10 / 8computed, unchanged from Rev2; the existence form proved (m3_mixed_term_exists)

Three rules on counting, unchanged: counting is done over the shell; aggregate and corpus figures are kept apart; build outputs of several targets are never summed. Added by this block, a fourth: a number standing next to a related one is checked against it as an equation — twice exactly that found a standing error.