Foundations of persistent computation

Retain facts once; notify only relevant rule fragments

A new construction removes the eager solver's obligation to deliver every boundary fact to every leaf. It keeps a global fact set and routes each fact only toward subtrees containing a rule body that uses it. Old versions and exact syntax remain available.

Written construction theorem: arbitrary retained joins and positive updates preserve exact satisfiability and least-boundary answers, with charged work and allocation

W charges merging the static dependency indexes; V counts routing visits. The other terms charge initial facts, supplied facts, new local facts, antecedent visits and identifier length. An irrelevant fact visits only the router root, even with many empty leaves.

The fact remains globally available: if a later fragment contains x implies y, an earlier x is replayed and y is derived. This is why skipping delivery is safe but forgetting the fact is not.

Dependency-directed fixed-point scheduling is classical, including Apt's generic constraint-propagation framework. Our argument supplies the persistent composition invariant and resource accounting; novelty is unestablished. This application separates semantic information, communication, derivation and routing costs. The boundary-equivalence lemma and the composition-cost audit above now supply the subsequent semantic and quantitative checkpoints.

Construction, proofs and classical foundations · Finite checker · Verification scope

Safe rotations do not remove boundary broadcast work

A completed Horn composition can be reassociated using its existing conditional solver states, with constant local work and no rule replay. Its syntax and retained versions remain intact. Accessing a deeper node still charges the path to it.

Written theorem: for a successful positive update of the current eager engine, with I internal composition occurrences, the propagation count is exactly

Every newly forced boundary fact reaches every composition node. Thus balancing the tree cannot reduce this count. Even empty leaves incur broadcast work. This resolves the proposed optimization and identifies the next issue: sharing inherited facts without eagerly copying their consequences into irrelevant descendants.

The identity concerns this algorithm, not every representation or machine. The proofs reuse classical closure and persistence ideas; finite checks corroborate them, and novelty remains unestablished.

Proofs, scope and next question · Checker · Finite evidence

Joining retained Horn fragments without rebuilding indexes

If one fragment already knows x and another contains x implies y, the join must deliver x to the second fragment. Simply merging counters misses that interaction. The new construction keeps every leaf index intact and exchanges facts through a persistent tree of composite solver states.

Written construction theorem: arbitrary retained Join and positive-Pin terms over a common boundary have exact satisfiability and least-boundary answers. Old versions and the separate syntax DAG are preserved; shared private names remain separate by occurrence, including when a handle is joined with itself.

Here z counts the operand boundary names initially enumerated, k the supplied positive facts, D the propagation events at composition nodes, A new leaf facts and E processed antecedent occurrences. Names have length l. The bound explicitly charges traversal through the stored composition tree.

Two consistent operands with empty forced-boundary sets join in constant work, regardless of their private index sizes. A new fact can nevertheless require work at many descendants. There is no bound here solely in changed output facts or in the number of physically distinct nodes of a shared DAG.

Classical Horn propagation, closure iteration and persistence supply the ingredients. The additional argument specifies how conditional child states can be reused safely and charges their composition. Written proofs and finite semantic checks support it; novelty and proof-assistant verification remain unestablished.

Join invariant, cost proof and failed alternatives · Semantic checker · Verification scope

Loading Horn programs with a linear clock budget

The Horn construction now starts with an empty store and reads the program descriptions as ordinary symbols. It then uses an explicit block of clock symbols to validate names, build indexes, and propagate facts. No prepared program is hidden in initialization.

Written transfer theorem: let H contain the valid, satisfiable Horn-pair descriptions in the specified finite alphabet. For some fixed integer C, a finite-degree, distance-two scaffold recognizes exactly

The clock budget is linear in the full bit-encoded description length, including names. A shared immutable list checks the exact number of clocks. Each clock executes at most one binary-record allocation with bounded local access. The source instruction calculus and loader expansion are given in the proof.

The PEG transfer recognizes the reversed language

The clocks remain part of both languages. No same-speed ordinary Turing-machine simulation is implied. Loff, Moreira and Reis already established padding-based PEG universality; the result here supplies a linear budget and an explicit initialization contract for this Horn encoding. Novelty is unestablished.

The proof is a finite instruction expansion with resource accounting. Grammar and fuel checks pass; the full instruction listing, a numerical constant C, and a new Lean proof have not been extracted. The retained-Join construction above addresses the next operation gap by keeping leaf counters separate and charging propagation through composite nodes.

Encoding, loader and transfer proof · Specification checker · Verification scope

Horn composition with the local computation charged

Suppose one fragment says x implies a private u, and u implies y. Another asserts x and forbids y. Exchanging x, then y, discovers the contradiction. Retaining each fragment’s propagation state means that neither fragment needs to restart its computation after an exchange.

Written construction: two fixed Horn 3CNF programs, prepared independently with a shared boundary of b variables and explicit names of length l, admit persistent least-model composition with time and fresh-record bound

The bound includes preparation. Each antecedent occurrence is processed at most once along a version lineage, and at most 2b boundary-name notifications are sent. Immutable binary tries charge for name traversal and for every copied update path. With logarithmic-length names, this gives a near-linear bound.

Any retained version can be extended by positive boundary facts. Along one lineage, K supplied facts in t requests give total cost $O((N_F+N_G+b+K+t)(\ell+1))$. Different branches may repeat propagation; this is not one linear budget across the version tree. Arbitrary rule changes, retractions and arbitrary fragment-Join histories are outside the construction.

This supplies the charged implementation missing from the earlier short Horn protocol. The ingredients are classical forward chaining and path copying; novelty of their combination here is unestablished. The proof is written and finite model checks pass. A complete input loader and clock schedule remain necessary for a new scaffold or strict TM language theorem.

Construction, proofs and classical sources · Finite checker · Verification scope and output

SAT fragments: what must survive for future composition?

Two satisfiable fragments can have an unsatisfiable join: one requires x and the other requires not-x. A fragment therefore needs a description of its compatibility with future fragments. Expose b variables B, keep the remaining variables Y private, and define its boundary relation:

Boundary-equivalence lemma: two fragments give the same satisfiability answer in every allowed future context if and only if their boundary relations agree. Join intersects the relations; forgetting projects them. Necessity follows by pinning the boundary to any assignment on which the relations differ. Private variables must be renamed apart, including when a stored fragment is reused. Both positive and negative unit pins are allowed.

Let N(b) count possible boundary relations and let H(b) be the minimum fixed-length exact summary size in bits. Existential private variables are allowed in every row.

These are worst-case counts over all finite fragments, which may themselves be large. They do not assert exponential compilation from every small formula. A concrete local-view bound connects this information to a representation: with s roots, arity q, h metadata choices, g endpoint observations and combined Join/Query radius R, independent immutable handles require

A stronger access obstruction: if every probe of old storage returns one of g outcomes, a deterministic Join followed by exact Query for arbitrary 3CNF fragments requires

Here T is total old-information probes. This follows by simulating the implementation as a two-party protocol for set disjointness. It allows arbitrary separate preprocessing but requires independently composable handles, opaque pointers, charged observations and no hidden joint index. It is not a general SAT running-time lower bound.

Horn gives a different boundary. Two Horn fragments can test compatibility by alternately reporting newly forced boundary variables. At most b variables are added, giving O(b log(b+1)+1) communicated bits. Each party may still do substantial local work. Exponential summary information therefore does not imply exponential interaction: representation size, communication and local computation are distinct resources.

Concrete realizations: fix the number w of live variable slots and supply a well-typed postfix construction using clause addition, forgetting, renaming and joining. Finite relation tags and immutable constructor records preserve exact fragments and retained versions. The full evaluator uses at most two fresh binary records and old radius two per instruction; its scaffold has degree five and native distance three.

A smaller evaluator caches the current relation in finite control and uses one stack for earlier operands. It gives a degree-one, distance-two scaffold for the unpadded instruction language K(w). This language is nonregular even at w=0, so distance two is optimal for recognition. The smaller decoder preserves the semantic stack; the larger construction also retains exact formula values.

An explicit one-work-tape TM recognizes the encoding that puts one clock symbol after each instruction. It starts entirely blank and makes one transition per input symbol. The checked TM transfer gives a degree-two, distance-two scaffold for that encoded language. Scaffold-to-PEG transfer reverses the recognized language in each case. Width-dependent finite alphabets and supplied construction instructions are essential; raw SAT encodings are a separate task.

The proofs combine established constraint semantics, Horn closure, knowledge compilation, communication lower bounds and the reviewed machine compilers. Written universal arguments and finite semantic, pointer-layout and machine checks are available below. No new proof- assistant verification or established novelty is claimed. The next question is the charged local cost of the Horn closure protocol on immutable data, beyond its short communication transcript.

• Complete statements, proofs, model assumptions and primary literature
• Reproducible finite checker
• Verification scope, results and source hashes

One theorem for values and their contexts

Fix a finite many-sorted constructor algebra and finite observations. Two values are equivalent when every typed one-hole context gives the same observation. This is the established syntactic congruence.

Operational theorem: uniformly bounded application of every stored context, together with exact queries and the constructor operations, admits an immutable local realization exactly when this quotient is finite. The model fixes finite tags, arity, roots and initialization, permits independent handle composition, and excludes address tests and hidden unbounded work.

Necessity follows from finitely many bounded local views. Sufficiency stores quotient classes and context transformations at roots while constructor DAGs preserve exact values and all retained versions. Each operation needs at most one fresh record and reads only root tags. Word regularity and the balanced-language VPL result are instances of the same theorem.

A finite family of context templates also makes primitive locality sufficient. Words have the template u x v. Balanced contexts have arbitrarily deep holes and no such full cover in their basic signature. This does not exclude covers sufficient for particular observations. Bojanczyk's existing syntactic-algebra and finite-cover theory, including a uniform-continuity theorem, supplies the mathematical foundation. The added persistent resource argument is elementary; novelty and proof-assistant verification are not claimed.

Definitions, proofs, resource bounds, examples and primary-source comparison

Bounding each construction step and bounding an entire context

Balanced concatenation and one layer of bracket wrapping can both have bounded local persistent implementations while membership requires infinitely many contextual distinctions. A concrete language accepts exactly the single-nesting words with depths 2, 5, 10, 19, 36, and so on:

Each wrap advances a persistent queue clock using at most three queue operations. Joining two nonempty balanced fragments marks the word as having multiple components; it can never become a single nesting by further wrapping. The invariant holds across arbitrary retained-version histories. The accepted depths have unbounded gaps, so a finite context algebra cannot recognize them.

The exact stronger boundary: for a fixed visibly partitioned alphabet and a language consisting of balanced words, a bounded local persistent interface that also applies any stored one-hole context in one uniformly bounded operation exists if and only if the language is visibly pushdown. It includes immediate exact membership and independent composition of valid handles, with fixed finite labels, roots and arity and no hidden index, growing scalar or deferred scan.

Equal finite local value views must then agree against every context, giving a finite contextual quotient. Conversely, a finite quotient lets value roots store classes and context roots store transformations of those classes. Application evaluates a finite table and creates one binary record. The congruence theorem and the value/context algebra are established work, credited to Alur and collaborators and to Bojanczyk and Walukiewicz.

Written proofs establish the two interface results. The clock construction depends on the written strict-queue invariant; its resource audit uses a conservative radius that includes copied old targets. Finite semantic checks corroborate examples and retained branches. There is no proof-assistant verification or established novelty claim. These are operations on constructed values, with a separate input contract from streaming the flattened bracket word.

• Complete model, counterexample, context-application theorem and resource accounting
• Finite semantic checker
• Exact verification scope and dependency hash

Residual theory gives a precise boundary for joining word values

The semantic foundation is established: a word's residual records its answer against every possible continuation. Myhill–Nerode characterizes finite residual systems; coalgebra describes their derivatives. The additional question is which operations realize these semantics with bounded persistent work.

Exact interface boundary. A language admits independently composable immutable word values with bounded local concatenation and immediate bounded local membership testing if and only if it is regular. This statement assumes fixed finite record labels, handle metadata, root count and pointer arity; fixed initialization; and no address tests, growing integer fields, hidden global index or deferred scan. It concerns every admitted representation within this model.

Necessity follows because equal finite local views give identical answers against every appended word, hence equal right residuals. Conversely, a regular language's finite transition monoid supplies a root tag: concatenation multiplies tags and creates one binary record; membership reads the tag. The proof is written for all words and retained-value histories. Its classical ingredients are credited; novelty is unestablished, and finite example checks do not constitute proof-assistant verification.

Dyck bracket matching illustrates the distinction. A persistent stack supports constant-work streaming recognition, while the theorem excludes this stronger arbitrary-word join-and-query interface. With unbounded unit-cost integers, one bracket type instead has a balance/minimum-prefix summary; that example lies outside the finite-label model. Finite contextual algebras for visibly pushdown languages and derivative calculi for context-free languages already exist. Their semantic theorems do not by themselves settle the cost of additional version operations.

The balanced-fragment test is resolved above. It retains the same local immutable model and isolates whether an entire stored context can be applied in one operation. The original arbitrary word-joining theorem keeps its stated hypotheses.

• Definitions, universal proof, classical dependencies and model limits
• Finite regular and Dyck example checker
• Exact finite verification scope
• Supporting indexed-plan result and failure of the narrow closure claim

The stored words are rich enough; structural closure remains

The actual catenable-deque stored-element type can represent every sufficiently long word at each positive level. An induction using its Small constructor proves this. Consequently, independent stored roots admit the distinguishing inputs needed by the finite semantic selection argument, even at fixed levels.

This settles a semantic obstacle, not the full construction problem. A finite menu of separately type-certified plans can be tested by comparing formal words. Finding and certifying an adequate menu, and ensuring that its residuals support later operations, remain separate obligations. The source's empty chain is valid at arbitrary levels, so the previous perfect-block typing proof cannot simply be transferred.

The accumulated results provide a useful restricted selection principle, not a general characterization of persistent computation. This study isolated structural typing and closure. The following proof is written and supported by finite model checks and pinned source inspection; it has no proof-assistant verification, and novelty remains unestablished.

• Source contracts, richness proof, selection consequence and remaining gap
• Finite witness construction and source-provenance checker
• Exact verification scope and source hashes

One construction rule despite shared block lengths

Perfect ternary blocks give a positive answer to the next selection test. If every input at every shared level admits a construction within a fixed allocation budget, one rule works at every level without reading the level. A finite search checks its types and formal output words. The proof uses distinguishable word markers padded to the required lengths and excludes accidental small-level type matches.

This is an exact result for the stated one-call constructor model. It does not yet solve recursive head removal. Exposing a ternary block gives three smaller blocks; removing one leaves a two-block buffer, outside the perfect-block class. The actual catenable deque has richer, variable-length stored elements, so the theorem cannot be transferred to it without another argument.

Written proofs cover arbitrary levels and budgets. Finite checks corroborate marker separation and typing; no proof assistant has verified the theorem, and novelty is unestablished. The remaining test concerns the exact stored-element domain and preservation of the structure required by subsequent operations.

• Separation proof, uniform synthesis theorem and source boundary
• Finite marker and indexed-template checker
• Exact verification scope

A fixed number of list segments cannot absorb repeated doubling

The proposed flat-segment extension fails for a precise reason. Repeated self-concatenation doubles the represented word at each call. Bounded allocation can increase the longest ordinary list only linearly, and a fixed number of list slots cannot hold the exponentially growing result. The proof includes auxiliary lists prepared in advance and even grants access to every old node.

This rules out every controller within the stated flat-list class, not other persistent representations. Sharing a binary concatenation node escapes the length bound, but still leaves the problem of cheap head removal. Push, pop, and concatenation when enough slots remain provide positive controls. The next step is recursive composition and its structural invariants, rather than adding more fixed slots.

The argument is elementary and has a written unbounded proof with finite computational checks, without proof-assistant verification. Novelty is unestablished; established catenable structures already use richer representations.

• Capacity bound, full proof, sharing control and next question
• Finite capacity and guarded-operation checker
• Exact verification scope

Preserving the structure needed by the next operation

Head removal now fits the finite construction test for proper-list bases with concatenation caches. Each call exposes a base head and tail. Word equations check the cached values; a separate structural check ensures that the resulting bases still support another head removal. Together they give a decidable bounded-template test and correctness through every finite sequence from a valid initialization.

Persistent stacks with cached prefixes provide a concrete application. Push and pop repair a fixed number of caches, regardless of stack length, while preserving old versions. A negative example explains why both checks matter: returning a concatenation node can satisfy every word equation while destroying the next legal list view.

The theorem is complete only for the declared typed templates. Written proofs and finite checks support it; it has no proof-assistant verification, and novelty is unestablished. Persistent lists and their concatenation copying costs are established ingredients. The next question is whether a bounded descriptor of list segments can remain closed under both concatenation and head removal.

• Typed-view theorem, construction, proof and structural counterexample
• Typed-template and persistent push/pop checker
• Exact finite verification scope

Keeping related word caches valid through updates

When stored words cache explicit concatenations of base pieces, a finite test can both find a bounded construction and check that the cache equations remain true afterward. Substituting the declared expressions into each construction gives the test. Induction then proves correctness through every finite sequence of operations, preserving old versions.

A prefix-cache example gives a matching cost bound. Retain d word factors and a root for every prefix. Appending to factor 1 requires exactly d fresh binary records in the worst case; appending to factor i greater than 1 requires d minus i plus 2. Each distinct new cached word needs a new root on a suitable input, and an explicit construction achieves that bound.

The bound is exact for the specified available-root interface. It does not exclude other representations or extra prepared roots. Written proofs and finite checks support the result; proof-assistant verification and novelty are unestablished. The next boundary is head removal through changing structural views, where newly exposed pieces may introduce relations this expression model cannot track.

• Construction criterion, preservation proof and exact prefix costs
• Finite construction and persistent-history checker
• Verification scope and results

When individual constructions yield one uniform rule

Suppose an operation receives independent opaque word pieces and specifies its answer by concatenating them and fixed letters. If every assignment admits some construction within a fixed allocation budget, one template works for every assignment within that same budget. A finite enumeration of templates and comparison of their formal words decides this restricted one-call problem.

The proof substitutes distinctive words for the pieces, separating all bounded templates at once. This requires an alphabet with at least two letters and independently variable pieces. It preserves old versions and uses no descent into the pieces.

Hidden correlations can defeat uniform choice. In a paired rope example, each correct tail is already available, but identical bounded views conceal which tail is required. Positivity also rules out constructing an alternative answer. A visible selector bit repairs this example. The remaining question is which useful correlated interfaces admit a checkable rule and preserve their guarantees through subsequent operations.

Both results have written proofs and finite computational controls. No proof assistant has verified them; novelty is unestablished. Their scope is the specified interfaces, not every persistent representation or language.

• Hypothesis, characterization proof and separating example
• Finite template and paired-view checker
• Verification scope and results

A local answer can leave an expensive residual

Knowing the first letter is not enough to make removing it cheap. In a restricted immutable rope made only of letters and binary concatenation, an append history can store a followed by n copies of b while caching its first letter. Returning the remaining word still requires at least the ceiling of log base two of n new records, even with unlimited access and arbitrary output sharing.

The proof counts how much a-free output can be assembled from a-free pieces already stored. Each fresh concatenation can at most double their maximum length. A linked list, a previously prepared tail, or a richer substring constructor changes the representation and escapes this particular obstruction.

This is a written allocation lower bound for specified heaps and constructors, not a limitation on every representation or language. Small executable checks corroborate it; no proof assistant has verified it and novelty is unestablished. The certificate study has supplied a useful sufficient verification method. The next question is when residual states admit bounded construction from local pieces using one uniform finite family of rules.

• Model, allocation proof, controls and research assessment
• Finite DAG-growth checker
• Exact verification scope and results

Two-sided repair with a bounded fallback

Joining two persistent sequences now has an indexed certificate under explicit buffer contracts. Each side can be converted to a compatible view or a vector containing at most six stored entries. A small left side is prepended in order to the original right side; otherwise a small right side is appended to the original left. Two large views are joined directly.

The reusable condition is a fixed bound on the number of entries handled by the fallback, together with separately verified view conversions and insertion operations. Each entry may represent a long word. The proof preserves its order and nesting level without inspecting that word. Allowing an unbounded fallback would lose this particular resource guarantee.

This closes the semi_concat and insertion premises used by prefix repair, leaving the buffer interface as the remaining module obligation. It is a sufficient construction principle, not a characterization. The deque algorithm and its Rocq correctness result are established work; novelty of our certificate interface is unestablished. The next assessment asks what this method predicts beyond the completed example.

• Two-sided lemma, indexed proof, resource bounds and limitations
• Symbolic word and occupancy checker
• Checked obligations and source provenance

A fixed boundary can carry a local repair

The remaining pair-chain green-pop route now closes under the same local-view method. Popping the left view has two outcomes: either it leaves a valid residual view, or it exposes exactly six stored entries. A separate splice places those six entries in front of the unchanged right view. In both branches, the input word is exactly the returned head followed by the residual word.

This yields a reusable finite-boundary lemma. If a local operation returns either a residual representation or a fixed-shape boundary, and the boundary has a certified splice into the neighboring representation, then their composition is a bounded persistent operation. The proof is a commuting word triangle; physical inverse representations are not required.

Combining the pair result with the preceding single-chain result proves the complete source-level pop_greensequence contract at every nesting level, under explicit buffer contracts. This is not raw graph equivalence or a new proof of the stronger upstream Rocq theorem. The two-sidedsemi_concat dependency is now covered in the result above.

• Finite-boundary lemma, pair proof, full-pop corollary and bounds
• Symbolic pair-route checker
• Checked cases, negative controls and source provenance

A local view makes one real pop route finite

The single-chain branch of the deque's green pop now has an independent certificate. The source first converts a chain to a temporary triple view, removes one stored entry locally, and converts the residual triple back. The two conversions preserve the exact flattened word; the middle step exposes the head. Their equations compose into the required head-plus-tail law.

Indexed type inversion gives an exhaustive finite list at every nesting level: seven view-conversion cases, seven typed pop subcases, and six return-conversion cases. The color changes track prefix thresholds 8 to 7 to 6 to 5. A stored entry remains an arbitrary word block, so structural occupancy is never confused with payload length.

This section proves the real Single route and gives a conditional uniform resource bound from the buffer primitive. The pair route is now certified in the result above. Neither result equates physical graphs or replaces the stronger existing Rocq theorem of Viennot, Wendling, Gueneau and Pottier. The useful general pattern is to move through a locally operable view using maps that commute with the intended observation; physical inverse representations are unnecessary.

• Single-chain theorem, branch proof, bounds and scope
• Symbolic view, pop and composition checker
• Exact checked cases and source provenance

Unbounded proof levels, finite runtime rules

A concrete test of the certificate method exposes an important distinction. Exact agreement of nested record levels cannot always be recognized by finitely many ordinary record types. A short tree-automaton argument proves this for the three-entry stored-value fragment. This limits that shape-certificate format; it does not establish a runtime lower bound.

The proof can instead track a symbolic nesting level that the program never stores or reads. Applied to the deque's prefix repair, the same finite cases preserve the word and restore at least eight prefix entries at every level, under explicit pop, buffer and semi-chain contracts. Entries and payload letters must be counted separately: one higher-level entry can represent a long word.

The repair algorithm and its existing Rocq contracts belong to Viennot, Wendling, Gueneau and Pottier. The new working argument identifies what our certificate format must express and supplies a conditional, uniformly indexed instance. The symbolic checker covers a handwritten model of the helper clauses, not a formal translation of the OCaml source. The single-chain and pair-chain pop routes are now discharged in the two results above.

• Finite-sort boundary, uniform lifting proof and conditional prefix repair
• Symbolic rank, occupancy and word-equation checker
• Verification scope and source provenance

Finite checks can certify unbounded future use

For a restricted class of immutable constructor programs, the local-to-global argument now has a precise form. Check that every rule preserves the permitted record shapes, stays within its access and allocation bounds, and satisfies its intended word equation. A substitution argument proves each step correct; induction then covers every finite sequence of certified operations, including reuse of earlier versions.

The equations are checked symbolically. For example, a tree rotation must preserve the word XYZ, while a concatenation that returns YX fails the requiredXY equation. The checker derives the implementation and specification sides separately. The examples include concatenation, context composition and a complete persistent binary-stack interface.

A boundary is equally concrete. Bare concatenation trees can store a word correctly while hiding its first symbol at arbitrary depth. No query with one fixed access radius can recover that symbol from every such tree without additional information. A cached first-letter summary defeats this particular obstruction. The limitation concerns this representation and query interface.

This is a sufficient certificate theorem with a written unbounded proof, not a characterization of all persistent computation or a proof-assistant formalization. It combines established invariant and algebraic methods with explicit bounds for the scaffold compiler; novelty of the combination remains unestablished. Its future guarantee covers the certified operations, not arbitrary scaffold observations. The indexed prefix-repair test above separates finite runtime rules from the richer proof annotations needed for exact nesting-level invariants.

• Model, certificate theorem, full proof and representation boundary
• Independently specified rules and interface equations
• Symbolic certificate checker
• Exact verification scope, normal forms and negative examples

The filtering obstruction is about locality, not total work

The repeated odd-position filter defeats every fixed finite summary, but a growing persistent representation may retain a tower w, P(w), P²(w), …. A first attempt to rule this out does fail: if every link in that tower must be ready immediately, appending after a word of length 2ʲchanges j+1 consecutive levels. No fixed allocation bound can maintain that eager layout.

That is not a general lower bound. The changed levels form a binary carry cascade, and the cascade has deadlines. A filtering request can expose only one additional level. In the forward fragment with append and filtering, processing the shallowest pending carry before each request always prepares the next level in time. There is never more than one pending carry at a given level, and one carry step per request suffices.

A strict persistent transport primitive

One part of the locality problem now has a construction. The classical Hood-Melville real-time queue distributes a list reversal across later operations, but standard presentations use unbounded integer counters. Those counters can be removed. A unary token stack records rotation progress, while two list cursors certify the remaining difference between front and rear lengths. Enqueue and dequeue then use only finite tags, bounded pointer access and bounded immutable allocation.

The construction is fully persistent and strict: it does not rely on mutation, memoization or amortized work. Conservatively, its records have arity at most six, old-access radius at most six, and at most twelve fresh records per queue operation. This gives a concrete application of the simultaneous-record compiler beyond the palindrome development.

Overlapping repairs become alternating segments

A single queue still does not compose overlapping cascades, but the overlap geometry now has an exact reduction. Store the tower as alternating exact segments and pending-carry markers. The first marker is the shallowest pending carry. Servicing it either moves that marker one position deeper or removes it and concatenates its two neighboring exact segments.

This makes filtering local in the right coordinates. AP request removes one item only from the first exact segment. Every deeper gap between markers is unchanged, so no hidden layer must be advanced. In the smallest overlap, the structure evolves from old levels one, two, three to a marker followed by old levels two and three, then to new level one, a marker, old level three, and finally to new levels one and two followed by old level three.

Each level stores only finite information: whether it is empty, its first symbol, its length parity, and its aparity. That summary determines both the observed answer and whether an append propagates to the next filtered level.

The resulting segment-dominance theorem handles every reachable nesting depth in the forward fragment. It reduces each request to at most three operations on a fully persistent catenable sequence plus constant frame work. Therefore any strict bounded-record catenable sequence yields a bounded-record forward filtering controller.

Fixed thresholds do not require stored lengths

The efficient source's integer lengths are not a structural obstruction for this interface. Its catenable core asks only four fixed size questions, with largest cutoff eleven. In a fully persistent deque, a fixed cutoff K can be answered by at most K trial pops on temporary versions. The original root and any useful intermediate root remain available, so no restoration or counter is needed.

Applying that lemma replaces all four length tests and bypasses the public exact-length wrapper. The resulting required source slice has only finite algebraic constructors, no recursive operation, no mutation, and no pointer-identity test. Encoding its tuples and constructors as records gives arity at most eight. A deliberately enormous source-inlining argument also supplies explicit finite radius and allocation bounds. These are construction bounds, not useful estimates or optima.

The concat layer has an exact fringe semantics

The semantic gap now factors cleanly. Assign every stored value, node, packet and chain a fringe word, using an accumulator where a child chain is inserted. With only the ordinary sequence equations for finite buffers, every helper on the concat path becomes an identity in the free monoid of words. This proves exact sequence behavior for the hand-written source'sempty, push, inject andconcat operations on every persistent branch.

The note supplies a written level-erased relation; it does not provide a formal Rocq-to-OCaml refinement. It does not yet provepop. The first missing equations are thatpop_green removes the first fringe symbol andensure_green preserves the residual fringe. Those equations may be studied under the same abstract buffer contract. Proving the buffer implementation is a separate obligation for an unconditional result.

The restricted certificate theorem above separates shape, locality and word equations. It does not yet certify the whole catenable source. Its level-indexed invariants and pop regularization remain the stress-test; promised typed undo remains a later obligation.

The earlier concat checker has a narrower scope than its check count might suggest: several assertions compare identically constructed expressions, and its source checks establish alignment of names, hashes and selected statements. They do not independently verify the function bodies. The new certificate checker derives the two sides separately for its authored rule format; it does not retroactively certify the catenable source.

The segment theorem preserves this fixed controller's parity observations on forward traces. It does not preserve raw graph identity or arbitrary future scaffold-context observations, and it makes no language-recognition or PEG claim. Finite exploration checks the recorded transition cases but does not prove the unbounded theorem. Novelty of the segment reduction has not been established.

• Model, eager-layout lower bound, forward scheduling proof and open pointer invariant
• Executable adversarial explorer
• Recorded finite verification scope
• Counter-free strict queue construction, proof and filtering boundary
• Persistent branching queue checker
• Queue verification scope and construction bounds
• Alternating-segment invariant, conditional construction and literature boundary
• Segment transport checker
• Segment verification scope
• Bounded-threshold erasure theorem and catenable-deque source certificate
• Structural threshold checker
• Threshold and source-audit verification scope
• Fringe simulation for the hand-written concat path
• Free-monoid and source-alignment audit
• Concat verification scope

Constructing memory for future changes

The program now has a constructive answer for a restricted class of changes to a remembered history. If a finite observation can be maintained with appends and correctly supplied undo operations, it can also be maintained through any sequence of installed word substitutions and additions of fixed prefixes or suffixes. Extra finite memory may be needed, and the construction finds it.

For example, one bit records whether the number ofa symbols is even. That bit alone cannot survive a later swap of a and b: the answer would then depend on the old number of b symbols. Keeping both parities works. Four states are necessary and sufficient for this example, compared with two before the swap was allowed.

The general construction collects the finite group evaluations that the installed substitutions can require. This collection has a proved finite bound. Its tuple supplies fixed tables for appends, legal typed undo and the transformations. The test is effective: minimize the original observation machine and check whether every letter permutes its states. No stable summary is assumed as input.

Agreement over finite horizons is weaker

A small change of operation breaks that conclusion. LetP keep the first, third, fifth and subsequent odd positions. For every fixed number of repetitions, finite reversible memory can retain the required parity answers. But no one finite summary works for arbitrarily many repetitions.

The single a survives exactly through the indicated filtering depth. Every pair of these histories can therefore be distinguished by a sufficiently long future experiment. This forces infinitely many exact summary states, although any fixed horizon can be handled with finitely many. The filtering transducer itself has only two states, and each input symbol permutes those states.

This gives a concrete boundary between finite approximation and one memory representation stable under all allowed futures. It does not rule out a persistent graph with bounded allocation per operation. Whether such a graph can support appends, legal typed undo and repeated filtering in worst-case constant work is the next question.

The synthesis proof applies established permutation automata and finite-algebra constructions. The separating argument uses classical future-observation reasoning. These are written proofs with finite executable checks; originality is not established. Legal undo is a promise throughout. The scaffold implementation preserves observations on those promised traces; recognizing exactly which traces are legal requires a separate validator.

• Exact synthesis theorem, finite-horizon obstruction, resources and sources
• Executable construction and finite checks
• Recorded verification scope

When local memories compose across calls

A retained call stack can save the finite summary of a caller while a child computation runs. For a pure return that simply resumes the caller, this introduces no new obstruction: the nested system admits uniform history-dependent finite summaries exactly when every reachable segment has a finite reversible cover, including its call and exit observations. Typed undo and returns are promised legal.

The boundary changes when a child result transforms its caller. If sigma is the saved caller summary andT is the return transformation, the necessary and sufficient compatibility condition for that supplied cover is: equal saved summaries must still be equal after applyingT, on caller histories where that call and child outcome can actually occur.

When this holds, each call frame stores the caller summary. Return combines it with the child's finite outcome using a fixed table. Induction over nesting depth proves that every suspended and active history has the right summary. When it fails, the call boundary asks for information that the local cover discarded.

A sharp counterexample shows that separate local tests are not enough. Let a caller observe the parity of its number ofa operations. Its two-state reversible cover is immediate. Now let return replace the caller by aexactly when its old history ended in b, and by the empty history otherwise. The post-return parity reveals whether the old word ended in b.

No finite reversible refinement can retain that predicate. Total internal updates must be permutations. If everyb transition reached an accepting state, the permutation's image would make every state accepting, contradicting rejection of the empty word. Thus all segments can be locally restorable while the nested protocol still has no finite realization in the stated model of uniform summaries and an immutable call stack.

For a supplied deterministic subsequential transformation, the compatibility condition has a finite product test. The product tracks the caller cover state, transducer state, and cover state reached by the output produced so far. This checks a proposed cover without a history-depth cutoff.

Saved caller state and child-state joins are classical nested word and recursive-state-machine mechanisms. The new progress here is the restoration-specific separation: pure resume is modular, while a transforming return adds a genuine cross-boundary stability obstruction. The remaining problem is to synthesize a stable reversible refinement, or decide that none exists, rather than merely test a supplied one.

• Composition theorem, counterexample, resources and literature comparison
• Finite compatibility and nested-trace checker
• Recorded verification scope

When visible frames can carry the missing history

An unbounded history need not require a separately allocated record for every operation. A retained stack can carry bounded pieces of the omitted history, provided those pieces are saved at the right boundaries. We now have a characterization for a precise version of this idea.

Let legal stack contents form a prefix-closed regular language. Divide the labels into hidden and visible ones. Require exact answers about which pushes and typed pops are legal. Hidden operations may change finite control only; visible pushes allocate immutable frames with finite annotations, and visible pops may read the annotation they remove. In this model,

The positive construction keeps the active hidden block in finite control. Each visible push saves that block and its starting controller state. Popping the visible frame restores both, even after arbitrarily many nested operations. Thus the visible stack and the total number of hidden frames may both be unbounded.

The converse explains why the bound matters. During a hidden block the retained stack cannot change. Different block prefixes must remain distinguishable because future pops can expose their different lengths or labels. Finite control has room for only finitely many such distinctions. The argument rules out every finite annotation scheme in this model, rather than just one proposed summary.

A finite graph test detects an unbounded hidden block by a hidden-labelled cycle. If no such cycle exists, its longest hidden path supplies the buffer bound and the construction. The resulting immutable stack meets the reviewed compiler contract, yielding a degree-two, distance-two scaffold. The scaffold preserves the operation-trace language; its PEG counterpart recognizes the reversal.

This is a written proof with finite executable checks, not a proof-assistant result. Finite buffering, saved caller states and residual distinguishability are established ingredients; originality of this precise characterization has not been established. Exact typed-pop observation forces lossless retention of logical stack information. The next question is when a more restricted controller can truly forget distinctions, while still restoring the summaries needed across visible frames.

• Model, both directions of the proof, resource bounds and literature comparison
• Executable checkpoint and boundary tests
• Recorded finite verification scope

How much memory does undo require?

For a controller whose legal operation histories are regular, the finite-memory question now has a computable answer. A reversible summary must keep enough copies of each forward behavioral state to distinguish predecessors that a later undo will need. Every same-operation merge adds a capacity requirement. A merge feeding back into its own cycle can make that requirement impossible for every finite summary.

After minimizing the forward controller, let m(q) count the summary states lying above behavioral state q. Every operation must satisfy

Different predecessor copies need disjoint destinations because the inverse operation must recover each one. The proof gives both directions: positive integer capacities produce a reversible realization, and every such realization must satisfy the inequalities. A computation over the graph's strongly connected components gives the exact minimum state count.

This is an application of established reversible-automata theory. Holzer, Jakobi and Kutrib supplied the forbidden-pattern and minimal-construction results; Lavado, Pighizzini and Prigioniero analyzed minimum copy counts, and Lavado and Prigioniero gave the same component recurrence used here. The contribution to this program is a checked translation into the restoration interface and its resource interpretation.

The contract preserves observations and which pushes are legal; it restores correctly typed pops supplied by a legal protocol. Detecting whether a pop is legal is a stronger task. On a prefix-closed tree of histories, observable pop legality distinguishes every history, even when the output is constant. The earlier group result relies on the legal-pop promise.

This also clarifies the metric intuition. The discrete zero-or-one residual distance expresses cancellation. A distance based on the shortest distinguishing experiment carries more information: each reversible operation changes it by a factor between one-half and two. Neither metric alone supplies a storage-cost bound.

The proof and finite construction are available below. The automata theorem and algorithm are classical, and no proof-assistant verification is claimed. The next question is how to synthesize restoration summaries when an unbounded visible stack remains. That is where finite memory and persistent structure must work together.

• Counting proof, exact resources, examples and source attribution
• Executable minimum-cover construction
• Recorded checks and their scope

Reversible memory lives between two notions of future

Restricted reachability changes the group theorem in a precise way. If every legal push, pop, and enabledness test may be used by an arbitrary future context, two configurations are equivalent only when all such two-way experiments agree. This symmetric future residual has an exact characterization: a finite locally restorable realization exists exactly when the residual has finite index.

On the residual quotient, every operation is a partial bijection. Its inverse is supplied by the matching reverse experiment. The resulting operations form an inverse-semigroup action. Total generators on a finite quotient become permutations. The earlier hidden-stack group result uses a different observation contract: pops are promised legal, and their concrete enabledness need not be detected.

This is also the clean metric statement we were seeking. Give distinct future residuals distance one. Every enabled operation is then a partial isometry: it can neither create nor collapse a future-observable distinction on its domain. A local inverse supplies the reverse inequality.

One fixed controller has a different semantics. It may merge two states that have identical forward futures even though a later restoration step must know which predecessor was used. A four-state fork-merge example proves that injectivity of the minimal forward residual is sufficient but not necessary. The right object is a finite reversible cover of that residual, retaining exactly the extra predecessor distinctions.

This corrects the previous candidate characterization rather than merely weakening it. The arbitrary-context theorem has a complete paper proof and a unique minimal quotient. For a fixed controller, reversible-cover existence is exact as a semantic condition, but effectivity and size bounds remain open for infinite visibly structured sources. Existing reversible- automata theory already shows that reversible minima need not be unique, so novelty is not claimed from terminology alone.

• Two residual semantics, proof, counterexample, and next target
• Partial-Moore residual and injectivity checker
• Recorded finite verification scope

Reversible forgetting forces group memory

The previous characterization tests a supplied finite stack summary. A sharper question is intrinsic: which observations admit any finite summary that can be updated on a hidden push and restored on the matching pop, without reading the discarded frame or a predecessor graph?

On a full reversible cone of hidden frames, the answer is exact. Every hidden frame type acts as a permutation of the finite summary states, and its matching pop applies the inverse permutation. A push update that merges two old states cannot be undone locally. Because the summary set is finite, the retained transition monoid is necessarily a group of permutations.

This yields a Myhill-Nerode-style characterization. Two hidden stacks are equivalent when every possible prefix of future hidden pushes gives the same selected observation. A finite locally reversible summary exists exactly when this residual equivalence has finite index and adding one hidden frame is cancellative. The residual classes give the unique minimal summary, so their number is an optimum rather than merely an upper bound.

The earlier examples now fall on a structural boundary. Parity succeeds because a hidden X toggles a two-state group. Presence of X and exact emptiness fail because a push irreversibly merges residual states. The rightmost-tag summary succeeds only in its earlier restricted seven-configuration presentation; its overwrite update is not reversible on a full cone.

If a pop does not even reveal which hidden label was removed, all hidden push labels must induce the same permutation. The finite summary can then retain only stack height modulo a fixed period, not frame content. This is a limitation of the stated finite-control restoration interface. Visible shadow frames, saved predecessors, restricted reachability, or control-carried history change the model and are not ruled out.

In the induced discrete metric, matching hidden pushes and pops are isometries: they preserve and reflect zero distance. This is the metric form of cancellation. The proof is written, finite examples and the untyped-pop collapse have executable checks, and novelty is unestablished. No proof-assistant verification is claimed.

• Residual characterization, group-forcing proof and boundary examples
• Minimal residual and common-pop checker
• Recorded finite verification scope

When can a small summary make forgetting local?

A finite summary can retain a distinction that raw erasure would lose. But there is a hidden cost: after a pop, the machine must recover the summary of the newly exposed tail. Reading that answer from the discarded concrete record would keep precisely the memory that the quotient was meant to forget.

The new characterization makes restoration part of the test. Supply a finite monoid observation of the raw stack, together with the existing control and label projections. For every reachable local situation, the test records the present monoid value and the value after deleting one raw top. It then asks whether acceptance and the complete set of projected next actions depend only on the retained finite control, monoid value and visible top.

This finite condition is necessary and sufficient for an exact one-top unit-stack quotient with the monoid value in finite control. Standard regular pushdown reachability decides all realizable cases. A passing quotient updates its summary from its own local rule table. It uses no concrete tail pointer, predecessor graph or historical oracle.

A parity example shows real pop restoration. Its raw stacks alternate private X and public A frames. Erasing X loses an acceptance-relevant parity bit; retaining the number of X frames modulo two repairs the quotient, and a private pop flips that bit while leaving the visible stack fixed. Conversely, the familiar summary "set of labels present" fails: X and XX have the same present summary, but one pop leaves different summaries.

This separates two established techniques. Stack-summary analyses can restore information by following matched paths in a computed pushdown graph. The quotient studied here must run in real time using only its retained local state. The result is an exact characterization for a supplied summary and interface, not a synthesis theorem for the best summary or a limitation on every representation of the language.

When projected stack-height spread is bounded, the earlier compiler applies unchanged: one logical allocation per input, degree two and native access distance two. The scaffold recognizes the source language; the corresponding PEG recognizes its reversal. The proof is written and the regular examples have exact finite-automaton certificates, but there is no proof-assistant verification and novelty is unestablished.

• Finite-summary characterization, restoration proof and boundary examples
• Regular-invariant and monoid certificate checker
• Verification scope and recorded certificates

What can memory safely forget?

Calling a stack frame private does not make it irrelevant. If we erase X, the stacks A and XA look identical when read from the top. But an ordinary pop leaves their visible stacks empty and A. The hidden frame has delayed an operation that future computation can observe.

There is now a finite criterion for safe erasure in a precise model. Supply a projection of the machine's controls and stack labels, allowing some labels to disappear. The criterion decides whether the projected computation can operate using only its projected control and top stack symbol, with one push, pop or no-op per input. It checks both acceptance and the complete set of projected next actions. Classical regular pushdown reachability makes the relevant local cases computable without bounding the stack depth.

When the check passes, every projected step can be lifted to a real source step, and every source step projects correctly. Future acceptance is preserved at every input cut. This is an exact characterization for the supplied projection and that particular local interface. A failed check does not exclude another encoding, a larger local view, or an extra retained summary.

This strengthens the bounded-spread construction. A complete source may have arbitrarily different raw stack heights while its useful projected stacks remain synchronized. For example, a recognizer can compare two blocks, then nondeterministically retain or discard private logging frames. Erasing those frames passes the criterion and leaves a deterministic recognizer for

The source's raw heights disagree without bound on the logging suffix. Its projected height spread is zero. The earlier compiler therefore applies to the useful memory, giving a degree-two, native-distance-two scaffold for the same language and a PEG for its reversal.

Access and forgetting remain separate. Even when erasure is semantically invalid, two saved pointers per immutable record can maintain both the full stack and its filtered view, with at most one allocation per update. This provides cheap access past private frames while retaining the information needed by the original controller.

The written proof specializes established bisimulation and abstract-interpretation ideas; novelty is unestablished. An executable finite-automaton check verifies the example's regular invariant and local criterion, while bounded trace tests corroborate the implementation. No proof-assistant verification is claimed. The finite-summary characterization now identifies exactly when a supplied small summary can recover local behavior without reading an erased tail.

• Exact quotient criterion, proof, persistent access and counterexamples
• Regular-invariant certificate checker and finite audits
• Verification scope and recorded evidence

Bounded disagreement and usable memory

Imagine several possible computations that push and pop at slightly different times. A reference computation keeps its own stack and uses the top symbol, or emptiness, to decide its next action. If every possible run stays within a fixed number of stack levels of that reference, can their future answers still be maintained with bounded work per input letter?

The new construction answers yes for normalized real-time pushdown sources: one unit push, pop or no-op per letter, initially empty, with finite control and stack alphabets. For a supplied complete deterministic stack observer and bound, a finite pushdown reachability construction checks every legal source prefix, including rejecting runs. When the check succeeds, a deterministic persistent stack preserves acceptance after every input prefix.

The mechanism is concrete. Keep the bounded disagreement in a finite buffer, determinize the synchronized summary using established visibly pushdown theory, and store the observer and summary symbols as pairs in one stack. Each input needs at most one new logical record. The reviewed compiler gives a degree-two, native-distance-two scaffold, with exactly one physical node per letter and no inserted initialization input. A scaffold for $L$ gives a PEG for $L^R$.

For a complete source, the reference can be chosen directly by selecting one legal rule for each local situation. Let $\Delta$ be the largest height difference between any two runs on the same input, and $R_D$ the largest difference from that selected reference. The triangle inequality gives

Thus bounded spread is a property of the source's runs, independent of which reference is selected. A supplied bound on that spread is itself decidable. This is a sufficient condition for cheap persistent realization of the given complete source; it does not characterize every representation of its accepted language.

There is also a precise local-observation estimate. If two configurations agree in control and their first $m+1$ stack cells, one update leaves them agreeing through $m$ cells. For the ordinary prefix metric on decoded stacks, this says

Agreement through $t$ cells therefore guarantees the same finite-control acceptance answers for every continuation of at most $t$ letters. The metric measures observations; the construction separately accounts for finding and maintaining the records that support them.

That separation matters. Complementing every bit of a stored word preserves prefix distance exactly. In a literal immutable chain of bit-labelled records, however, complementing an all-zero word requires a new record for every bit. An encoding with a shared polarity bit avoids that cost. Continuity alone cannot establish a bounded-allocation theorem, and a limitation of one encoding cannot exclude every encoding.

Exact stack synchronization and pushdown height advice are classical. The additional argument here absorbs bounded disagreement, checks its hypotheses, and accounts for stored feedback and scaffold resources. It is a written working proof with finite corroborating checks; novelty and formal verification are not established. The checked-erasure criterion now permits a specified class of irrelevant frames to be discarded before applying the height bound.

• Full theorem, triangle argument, observation metric and boundary examples
• Finite pairing and observation checks
• Exact verification scope
• Mahajan, Meyer and Nimbhorkar: established pushdown height advice

Stored answers and finite prediction

A nested document can leave behind a one-bit answer: should each later tick grow the stack, or leave it unchanged? A persistent stack reader can compute that answer as it reads. A controller that sees only the input and has finitely many states may be unable to recover the same answer.

A new reduction makes this distinction exact. Given two disjoint visibly pushdown document languages, build a deterministic source that permits a delimiter after either language and then grows or keeps its stack on every tick. A finite input clock tracks all legal prefixes within a constant exactly when a regular language separates the two document classes. Whenever tracking is possible, zero error is possible.

Kopczynski's established undecidability theorem for that separation problem therefore rules out a general clock-synthesis algorithm, even for these deterministic partial sources. This settles the unrestricted input-only clock question in the stated model. The source's partial delimiter rule matters; the result is not asserted for total sources by this argument.

Every source in the reduction still has a direct persistent implementation: one stack root, at most one new logical record per letter, and a degree-two, native-distance-two scaffold. The obstacle is recovering the stored decision using finite input-only control. It is not an impossibility of cheap memory, a lower bound on the accepted language, or a PEG pumping result.

A second comparison changes the role of the proposed block-input extension. Classical semilinear counter methods already give persistent recognizers for every context-free language restricted to any fixed sequence of distinct-letter blocks. The detailed construction accounts for local access, allocation and immediate prefix answers. Additional block-clock results would refine one representation method, rather than enlarge that language class.

These are written arguments with named classical dependencies and finite executable checks; their novelty is not established. The stored-feedback construction now allows a controller to consult its own persistent stack while directing the computation, with that memory's maintenance cost included.

• Clock-existence obstruction, exact reduction and examples
• Classical counter baseline and effective distance-one/two boundary
• Executable local and example checks
• Exact finite verification scope

Which future observations must be preserved?

Two stored graphs agree under every scaffold-testing context exactly when their labelled unfoldings agree. A single fixed controller can distinguish less: it may ignore graph differences that another controller can expose. Its future acceptance behavior is the language residual, not the full graph unfolding.

These are separate preservation guarantees. A compiler can preserve acceptance at every input prefix while changing the graph representation and its observable port vocabulary.

The consolidated foundations

A native finite view identifies base and missing at its outer frontier. One extra layer recovers that distinction. The consolidated statementsgive the models, bounds, initialization and preservation guarantees, incorporating the completed review obligations. Circulated paper editions are preserved.

Absorbing bounded timing disagreement

Hidden pushdown actions can disagree about when to push or pop. Unrestricted projection fibres permit unbounded disagreement. A source's legal runs can be much more constrained.

Fix an input partition into calls, returns and internal letters. Let $H(w)$ be its stack height, with returns at zero leaving it zero. Suppose a finite nondeterministic source takes one unit push, pop or no-op per letter, starts empty, and every finite run satisfies

The new argument converts this source into a visibly pushdown machine for the supplied partition. Keep the deeper part of the source stack on the synchronized stack, and retain at most$2B+1$ symbols in finite control. The extra cell makes the source top available even when the visible action cannot inspect the synchronized stack.

A finite transition can detect the first exit from the height bound. Visibly pushdown emptiness therefore decides whether a supplied bound and partition work. This checks the hypothesis directly; it does not assume a persistent implementation.

Established visibly pushdown determinization and the reviewed record compiler then give a degree-two, distance-two scaffold, with one physical node per input letter. If the source language is $L$, the PEG transfer gives$L^R$.

A nonzero-skew example and a failed certificate

On pairs ac, let the source choose an early or late push; on pairs bd, an early or late pop. Finite control enforces the pair structure. Heights agree between pairs and differ by at most one inside them. Empty-stack acceptance recognizes$\{(ac)^n(bd)^n:n\geq0\}$, a nonregular language. Its legal runs satisfy the bound even though hidden letter fibres mix action types.

By contrast, independent push-or-no-op choices on every x yield heights zero and$n$ after$x^n$. No fixed bound covers both. Yet all states could accept, making the language$x^*$. Failure of this presentation certificate is not a language impossibility result.

Deriving a clock from the source rules

A finite graph test removes the need to guess a clock and its bound within a precisely defined certificate class. A finite observer reads the input and proposes push, pop or keep actions. Compare those actions with the source rules in their finite product graph. If every reachable cycle has zero total discrepancy, signed discrepancies along all paths stay in a computable interval.

The implication accounts for returns at empty stack by reflecting each cumulative action sequence at its running minimum. Finite enumeration decides whether a certificate exists for a supplied observer-state budget and produces its bound. Annotating each letter with the observer state makes the clock visible, so the buffer construction still compiles with one step per original letter.

For example, a machine can push on a before # and pop on a afterwards. A two-state observer recovers this clock exactly and handles$\{a^n\#a^n:n\geq0\}$. A single action classification of a cannot certify these two phases. This is a classical height-deterministic example, used to check the construction.

The test is sufficient, not necessary. A source choosing only between pop and keep remains empty forever, but no finite observer passes the cycle test: the graph counts nominal pops that the bottom boundary absorbs. Stack guards can also make abstract cycles unrealizable. Failure therefore gives no language impossibility result.

• Clock-inference theorem, proof, examples and literature comparison
• Executable clock-certificate search
• Recorded verification scope and examples

Finite certificates that respect empty-stack guards

The bottom-boundary failure can now be resolved for one-counter machines, whose stack has just one kind of symbol. Instead of counting nominal actions alone, describe which source and clock heights can occur together. A source that only pops or keeps from empty needs the single pair $(0,0)$. A synchronized machine with unbounded height needs the whole diagonal $(z,z),\ z\geq0$.

The certificate lists finitely many differences$e$ and, for each pair of control states, an ultimately periodic set of allowed$z$ values. Its local checks handle the boundary exactly and verify closure under every enabled rule. Periodicity makes each infinite inclusion a finite decision.

For an initially empty, real-time nondeterministic one-counter source with unit actions and zero/positive guards, and a fixed finite input clock, a passing certificate exists if and only if all finite legal runs have uniformly bounded height disagreement. Soundness follows by induction. Completeness follows by encoding the bounded difference in finite control and applying classical regular reachability for pushdown systems to the remaining counter.

This covers an unbounded example too: ordinary balanced parentheses with neutral letters that may additionally perform a nominal pop only at empty stack. The old graph test fails, but the diagonal certificate proves exact synchronization. The earlier compiler then gives a degree-two, distance-two scaffold with one new node per letter, and a PEG for the reversed language.

The characterization concerns bounded synchronization of a specified source with a fixed clock. It supplies finite evidence for a persistent implementation; it does not characterize every such implementation. Enumerating certificates finds positive instances, but this proof gives no terminating negative search when the bound is unknown.

• Complete theorem, boundary formulas, proof and examples
• Executable certificate checker
• Example certificates and exact verification scope
• Schwoon: primary source for regular pushdown reachability, Theorem 3.3

Keeping the distinctions between stack symbols

The certificate theorem now extends to arbitrary finite stack alphabets. Height alone loses information: a rule enabled above an A may be disabled above a B. A finite automaton can describe the possible stack words in each control state, preserving the symbol relationships that later pops will expose.

For example, a source can maintain stacks in$(AB)^*$ in its main state, and $B(AB)^*$ between the two pushes or pops of a pair. A main-state rule requiring top B cannot execute. Erasing symbols makes that rule look available and can introduce unbounded height disagreement.

Each certificate row is a regular language of stack words, indexed by the source state, observer state and height difference. Check initialization, nonnegative clock height and closure under every enabled source rule. These are decidable finite-automaton checks, including the reflected clock's empty boundary.

For an initially empty, normalized real-time pushdown source and a fixed finite input clock, bounded height disagreement holds if and only if a finite regular certificate exists. To prove completeness, put the bounded difference in finite control. Clock emptiness then becomes a bounded stack-prefix test, allowing classical regular pushdown reachability to apply. The earlier real-time compiler supplies the scaffold resource guarantee; the offline reachability construction is kept separate.

This is a direct application of established automata methods with an explicit synchronization and compilation contract. Certificate enumeration by itself only guarantees finding a positive answer when one exists. The following reduction supplies the missing terminating decision for a fixed clock.

• Regular stack certificate theorem, proof and examples
• Exact finite-automaton certificate checker
• Certificate automata, counterexamples and verification scope

Deciding whether any finite bound exists

For the normalized pushdown sources and fixed reflected input clocks specified above, bounded height disagreement is decidable even when no bound is supplied. A positive answer also yields the least bound for that source and clock. The quantifier covers every finite legal run, including rejecting and stuck prefixes.

The proof treats the two directions separately. When the clock leads, marking a point in the history turns its lead into an additive weight on a context-free language. Constructive Parikh equivalence reduces unboundedness to a finite weighted-graph test. When the source leads, an auxiliary pushdown system with one nonnegative counter emits a unary word whose maximum possible length is exactly the source's maximum lead.

Bounded instances have the finite regular certificates already described. Unbounded instances have finite witnesses from the weighted test or established PVASS run-amalgamation theory. Running these searches together must terminate. A second route, using published one-dimensional PVASS reachability and effective downward closures, computes each one-sided maximum separately.

This resolves the apparent nontermination problem for checking a specified clock. It does not decide whether some finite clock exists with no state budget for arbitrary input patterns, nor whether every representation of the recognized language needs unbounded resources. For example, independent push-or-keep runs exclude every synchronizing input clock while their all-accepting language is simply$x^*$.

The argument composes credited results of Esparza, Ganty, Kiefer and Luttenberger; Anand, Schmitz, Schütze and Zetzsche; and Bizière and Czerwiński with the reductions given here. It is a written proof with finite checks of the elementary reductions. The full decision algorithms are not implemented or formally verified, and literature novelty has not been established.

• Decision theorem, both proof routes, hypotheses and primary sources
• Finite audit of the skew and drain reductions
• Recorded checks, negative controls and exact verification scope

Finding a clock without guessing its size

On inputs consisting of a block of a's followed by a block of b's, the synthesis question has a complete finite test. From a normalized pushdown source, compute the possible triples of a-count, b-count and stack height. Classical Parikh theory gives a finite semilinear description of these triples. Their periods determine finitely many rational slope constraints. Feasibility constructs a clock and a uniform error bound; infeasibility excludes every finite clock in the specified model.

The approximation means a uniformly bounded difference on all legal runs, with finitely many exceptional small values of n handled separately. The period M comes from the source's arithmetic description. Neither the observer's number of states nor the error bound is assumed in advance. The proof establishes why this finite family covers every possible clock.

A useful boundary is a stack that pushes on a, then pops on b until empty and starts growing again. Its height is$|n-m|$. Although its height is uniquely determined by the input, no finite reflected input clock stays uniformly close. The stack still has a direct persistent implementation. Thus failure of clock synthesis is not an impossibility of persistent computation. An absolute signed-sum clock can follow this example; the reflected-clock convention is essential.

The arithmetic stage is implemented with exact rational calculations and checkable positive and negative witnesses. The full proof uses established semilinearity and finite-state periodicity; the additional step derives a sufficient period from the source. Novelty remains unestablished, and no formal verification is claimed. The unrestricted question is now settled negatively by the separation reduction; this two-block theorem remains a positive subclass result.

• Complete synthesis criterion, proof, examples and literature comparison
• Exact arithmetic synthesis from semilinear height relations
• Input relations, rational witnesses and verification scope

What this establishes

The arguments now connect finite clock inference, bounded-skew normalization and persistent compilation. Regular stack certificates characterize bounded skew for normalized pushdown sources and a fixed clock, and the new reductions decide whether any such bound exists. For two input blocks, the arithmetic criterion also decides whether any finite clock exists and constructs one when possible. In the unrestricted partial-source model, that synthesis question is undecidable by the separation reduction. The earlier finite-cycle inference test is conservative. These results do not characterize all persistent realizations or find an optimal encoding.

Synchronization, determinization, weighted-graph cycle tests and one-sided reflection and regular pushdown reachability are established ingredients. The additional work here gives the boundary-aware certificate characterization and composes these methods with the buffer invariant and scaffold resource contract. Caucal's integer-sum clock and the reflected clock used here have different bottom conventions. A full comparison with his original construction remains open; literature novelty has not been established.

Finite executable checks cover the buffer updates, clock search, reflection estimate, periodic and regular inclusion checkers, and positive and negative examples. The proofs are written arguments, without proof-assistant or independent verification. The supplied-stack-observer theorem now extends the construction to stored feedback and gives a bounded-spread corollary for complete sources. Its observation estimate is separate from its allocation guarantee. The quotient criterion now decides when a specified erasure admits exact rules using only control and one stack top. The next question is how a supplied finite summary can enlarge this class, with its own maintenance and restoration costs included.

• Complete argument, dependencies, limits and primary sources
• Finite buffer audit
• Verification scope and recorded result
• Alur and Madhusudan: corrected nested-word and visibly pushdown theory
• Nowotka and Srba: height-deterministic pushdown automata