The State Is Not the History, the Source Is: Identity, Responsibility, and Minimal Revision in Processes

A question leaves a demand for a process to discharge; even when several readings agree, an answer must still say which run it belongs to. Through four levels of identity—same reading, same source object, same occurrence, same obligation—we construct a positive chain that the source walks by itself: the original occurrence hands over a complete source program, the program is actually executed and can be read back independently, the execution gives birth to its own responsibility row and pays it step by step, and after settlement the actual action asks the next question. The first link separates readings from sources. Any rooted tree and any constructor function generate a whole-tree program: the execution trace has exactly the budget generated by the tree’s syntax, and a syntax-only parser recovers the whole tree from the program; even when the constructor is constantly zero and every tree executes to the same value, the program still keeps the whole tree injectively. On top of this, the relations generated by derivations and module laws are exactly the evaluation kernel; two source words are the same in history iff at every tick their (old value, effect) difference is explained by that tick’s relations; and the evolution equation covers every element of the completion carrier. When implementations change, the common occurrence generates the unique comparison. The second link lets responsibility be born from the source. A complete environment and expression registered at the original occurrence generate a new mathematical responsibility row without any prior bearer: its budget is the number of remaining primitive computations, every actual execution step is a strict payment, local settlement is reached where the budget runs out, and the completed value equals the evaluation of the original expression; the paid trace is at once a relation receipt, and the whole old ledger is kept as a same-source remainder. For general responsibilities, given a master law covering every same-debt current, genuine payments likewise generate finite settlement histories and terminal receipts. The third link lets an answer ask the next question. After settlement, the actual action puts the paid relation back into the current actual environment: the value of the new request is exactly the effect of the original word under this update, its budget is strictly positive, and its first step is the birth of a new responsibility; the existing inquiry runtime runs through these recursive frames tick by tick, with no external table of future requests. When the old theory can neither express nor lawfully realize a demand, the rooted failure generates a minimal extension: on the ledger, incidence and claim coordinates, every admissible extension receives it through a unique faithful map; every typed revision sends this direction into the new root’s first write, and in a fixed two-tick instance the second tick is answered directly by the same new root. The next question does not set out empty-handed. The same source program folds the complete time of this visit while it executes the effect, and keeps both histories together with an inverse criterion for the action difference; the read-outs of all actors jointly recover the all-word model; the paid query of an arbitrary source program generates a new obligation admission at the same root and visit, and physical and low-level inventories of two types cross the admission and are read back item by item; the default run itself executes this source-generated request, together with its old and next subtrees, paying node by node. A question therefore does not merely wait for an answer: its execution, its settlement and its failure all ask the next question. The theorems and constructions are formalized in Lean 4; complete written proofs are given in the text and the Supplement, and the scope of the formalization is given in Appendix D.