Claude Matter 3: a commentary

On the Sidis programme, Parts A to I, and the twelve chat transcripts that produced it. Written 18 August 2026, after reading every file in the folder and running the code. Revised twice the same day. Section 9 reports the controlled experiment proposed in section 8 and corrects section 4 on the clock. Section 10 covers three files recovered after the first draft. Sections 11 and 12 rebuild Parts G and H from scratch, both of which reproduce. Section 13 audits my own coverage per script and corrects section 3 on Part F. Section 14 rebuilds Parts E and F, so that every part now has code. Section 15 settles E2 against a third copy of Part E, which no version of that script ever computed. Section 16 chases the unstated switch in G1 and finds that one of the machine’s three self-modification channels is the identity map. Part F reproduces entire. Section 17 searches the last two gaps systematically and closes them as negatives.

1. What is in the folder

Seventy-three files of programme material, in three layers. The folder now shows forty-nine items at the top level, which is forty-two files and seven folders, with thirty-four more inside the folders, seventy-six in all once the three files I have added are counted. That is the seventy the earlier session left, plus the three recovered since. My first pass said forty-two files, which was a miscount of the top level, and on that pass I had not read nine of the bulk data files. All of it has now been read and every script in the folder has been run.

The source. One scanned PDF of W. J. Sidis, The Animate and the Inanimate, Gorham Press, 1925, from the sidis.net free-print edition. Eighteen chapters. The preface is dated 6 January 1920.

The dialogue. Twelve PDF transcripts of an earlier session with another assistant, running from a first reading of the book, through Chapter XVI, through the comparative literature, into a computational programme, and out the far end into the audit of self-modifying AI and then into the hard problem of consciousness. The last is a sign-off.

The programme. Nine parts, lettered Engine and A to I, with Python scripts, thirty-six CSVs and eight reports. Six of the reports are part-level, one is a synthesis monograph, and one is a README.

And four things the reports name that had not arrived. part_A_fluctuation_window_analysis.py, anchor_loss_report.pdf which is Part E’s own report, multibit_memories_report.pdf which is Part D’s, and every bundle zip. Three of the four have since been recovered and are now in the folder, which changes the verdict on Part A considerably and is dealt with in section 10. The zips have not, and the Part G and Part H scripts are byte-identical to the versions I first read, so those two remain stubs. Sections 11 and 12 rebuild both anyway.

The arc is worth stating plainly, because it is the most interesting thing here. A 1925 monograph claiming that life reverses the second law becomes an Ehrenfest urn model, becomes a reversible cellular automaton, becomes a sixteen-bit self-rewriting register machine, and ends as a set of constraints on whether you can audit a machine that rewrites its own code. Nobody planned that route. It was found by asking the next question each time.

2. The verdict, up front

The reading of Sidis is excellent and, where I could check it, accurate. Every quotation the transcripts attribute to the book is in the book, word for word. The historical placement is fair and the comparative essay on Schrödinger, Eddington, Price and Prigogine is the best short thing I have read on where this odd little work sits.

The computational programme is a different matter, and better than my first two drafts said. Seven of its eleven scripts regenerate their delivered data byte for byte, which I only established by running all of them and diffing every file. Section 13 has the table.

What does not survive contact is narrower and sharper than I thought. Two part-scripts contain no code at all, and I have since rebuilt both, on which see sections 11 and 12. Two more, Parts E and F, compute a fraction of what their reports table and export none of it. The master script that the synthesis says reproduced every number reproduces three of nine, and one of the three contradicts the index that ships beside it. Several headline findings are algebraic identities restated as discoveries. One flagship measurement compares two quantities that are not comparable. And the base model’s central claim is about a memory that the analysis never touches.

None of this is fraud. It is what happens when a session runs fast, each part cites the last, and nothing goes back to check. It is also the exact failure your own project has now logged three times: an audit inherits the blind spot of the list it iterates, and reports clean.

3. What holds

The reading of the book. I checked thirteen quotations against the scanned text. All thirteen are present and correctly transcribed, including the two the whole edifice rests on: “the second law of thermodynamics is to be interpreted as a mental law, as the law determining the direction in which a given mind will conceive of time as flowing,” and “they would appear to us merely as extremely well preserved corpses.” The chapter titles are right. The 6 January 1920 date is right. The checkerboard of bricks, the loom, the sinusoid, the conjugate relations and the i / −i argument are all there as described.

The refutation. The transcripts get the physics right and they get it right for the right reason. Sidis’s own Chapter XVIII states the fatal objection, that the end product of life is carbon dioxide, “the most exothermic compound of carbon,” and then declines to answer it. Szilárd’s 1929 result closes the gap Sidis left open. Saying that Sidis asked the right question and got the sign wrong is a fair judgement, not a flattering one.

Parts A, C and D. These are the substance, and section 13 is where I finally checked them properly rather than taking their printed output as proof. All three regenerate every one of their delivered CSVs byte for byte, as do both copies of the engine. Part D’s compressibility identity, that recording forward costs more than recording backward by exactly the entropy rise, checks to 8.9 × 10⁻¹⁶.

Part E, more carefully. It builds a sixteen-bit machine whose state is its own program, enumerates all 65,536 states exactly, and finds that the anchor is lost at the audit interface long before the log overflows. Every constant it prints matches its report. But it exports nothing, and E2’s overlap figures are not in the code at all. See section 13.

The RSI translation. The mapping from a toy urn to the auditing of a self-modifying system is the one genuinely new thing in the folder. Provenance decays, resolution binds before budget, the root of trust cannot live inside the audited system. These are not deep results, but they are honestly derived and they are stated with the caveats attached.

4. What does not hold

I ran the code. Each item below is something I checked rather than something I suspect.

Two parts have no code, though see sections 11 and 12. part_G_audit_vs_alignment.py and part_H_temporal_audit.py are a docstring, an import and a print statement that says to read the PDF. Sixty-nine lines and sixty-eight lines respectively, one executable statement each. Every number in the Part G and Part H reports, including the audit-separation law and the internal-root-of-trust result, arrives with no reproducible source in this bundle. The G and H CSVs exist, so something computed them. That something is not in the folder.

The master script does not do what the synthesis says. synthesis_report.pdf, line 48 of the extracted text, states: “Every number above was reproduced exactly by the master script (part_I_master.py) in this bundle.” The sentence sits directly under a nine-row table covering Engine and A to H. The script reproduces three of those rows. Line 79 reads hr("PARTS C-H: see the individual part scripts and the synthesis report.") and the file ends two lines later. Of the three it does run, the Engine and Part A check out against their delivered CSVs, and Part B does not, for the reasons below.

Three incompatible numbers for one experiment. The Loschmidt echo, one flipped bit at the reversal instant. master_index.csv line 5 says 137/256. part_I_master.py, in the same directory, prints 10/256, and its Part B has no random seed at all, so 10 is what it will always print. The Part B script’s own docstring says 17/32. The delivered B2_echo_sweep.csv says 14/32. My run of that script gave 16/32. So the index disagrees with the script beside it, the script disagrees with its own docstring, and neither reproduces. Note also what 10/256 means. It is a near-perfect return, four per cent of bits wrong, and the master prints it under the label “decorrelation.”

And 137 appears to have no source. I tried the obvious variants of the master’s Part B: flipping a mid-lattice cell rather than cell zero, and three random initial conditions with both choices of second slice. The results run from 10 to 68 out of 256. Nothing approaches 137, which is what you would expect if the number had been read off a chance calculation rather than a run.

The master’s Part B is not the programme’s Part B. They share a rule family and nothing else. part_B_reversible_CA_embedded_agent.py uses a ring of 40 cells, thirty-two of world and eight of agent, with a sensory override on cell 32, six hundred steps, and a random half-filled start. part_I_master.py uses 256 cells, no agent, no sensory rule, fifteen hundred steps, and a start of eight adjacent ones in an otherwise empty lattice. So the file offered as the reproduction of Part B runs a different experiment under the same name.

And that experiment does not mix. I tracked the density. The master’s lattice holds sixteen ones out of 256 at step 10 and still sixteen at step 1000. The initial block never spreads. What is being reversed is a small localised object drifting round a nearly empty ring, which is why disturbing one bit disturbs only ten. Sidis’s point about the reversibility of a full gas is not being tested there at all, and the forty-cell version, which does start at half density, is the one that mixes and returns a chance-level echo. The master reproduces the label and not the physics.

The base model measures a memory it never reads. pseudo_living_mind_model.py builds an eight-bit ring buffer, charges it Landauer cost, and then computes its correlations from mem_series = [r[1] for r in rows], which is the urn occupancy, not the memory. The buffer is written and discarded. So the headline of Sidimodel.txt, that memory-past correlation is +0.731 forward and +0.729 reversed and therefore indistinguishable, is a statement about the autocorrelation of a reversible Markov chain with itself. It is true. It is also guaranteed by reversibility before any agent is introduced. The ledger figure has the same character: landauer += math.log(2) fires unconditionally every step, so 2079.4 is 3000 × ln 2 and not a measurement. It is then reported as “2079.4 ln2-units,” which would make it 3000.

The eight-fold opacity penalty is a comparison of unlike things. In the engine, co-oriented mutual information is computed at lag one. Counter-oriented is computed at lags 1, 3, 5 … 49 and averaged. Mutual information decays with lag in any mixing chain, so the ratio measures decay, not orientation. I computed the like-for-like version. At lag one the counter-oriented figure is 1.0313, identical to the co-oriented figure to four decimals, which is exactly what reversibility demands. The penalty is zero. The reported quantity is also in nats and labelled bits, so 1.03 should read 1.49.

The world never reaches equilibrium. The engine reports KL(p_t‖ρ) decaying 27.73 → 0.69 and reads this as relaxation to equilibrium, the Past Hypothesis quantified. The Ehrenfest chain moves one ball a step, so parity of k alternates and the chain is periodic with period two. Starting at k = 40 it puts every particle of probability on even k, forever. I ran it to 400 steps. The residual is 0.693147180 nats, which is ln 2 to nine places, and the mass on even k is 1.000000 at every step checked. The floor is parity, not slow mixing. Average two consecutive steps and the KL falls to 8 × 10⁻¹³. Nobody in the programme noticed, and the same periodicity recurs at the end of Part C’s detector table, where the posterior ticks back up from 0.5000 to 0.5002.

Several findings are identities. The 2 × 2 contingency table, which the analysis calls “the whole book in one number,” has four cells containing +0.2204, −0.2204, −0.2204 and +0.2204. Reversing a sequence negates the slope of a straight line through it. There is one number in that table and its negative. Likewise A4_memory_symmetry.csv, and that one is worse than an identity, for which see section 10. Likewise B3_memory_direction.csv and record_correlations.csv, where the reversed-tape past column equals the forward-tape future column exactly, because reversing a list maps one onto the other. Likewise boundary_contrast.csv, where k₀ = 0 and k₀ = 40 give byte-identical rows, and k₀ = 10 and k₀ = 30 likewise, from binomial symmetry. And likewise the Part C detector, where the two agents’ confidences sum to exactly 1.000 at every row, because the code computes one posterior and reports its complement as the other agent’s belief. There are not two agents there.

The Anchored-Arrow Theorem is close to circular. Its flagship number is H(past | now) = 0.000 exactly at t = 10, d = 10. Retrodicting ten steps from step ten reaches step zero, which the model defines as a delta function at k = 40. The entropy of a certainty is zero. That the past is pinned at the anchor is an assumption entering as a conclusion. Part C’s docstring half-concedes this. The synthesis then promotes it to Theorem 2.

One deliverable is empty. pinning_horizon.csv has forty rows and every value in both columns is 0. The prediction column is not computed at all, it is written as a literal zero, and the retrodiction column breaks out of its loop at d = 1 every time. The report describes this as a finding with an honest caveat. It is a null artefact of a threshold set too tight.

The clock may explain more than self-modification does. In the Part E and F machine the opcode nibble is overwritten every step by (opcode + 1) mod 16. I measured it: on 65.7 per cent of states the opcode advances by exactly one, and the opcode marginal from the anchor has entropy of exactly zero for the first several steps and 3.545 bits of a possible 4 even at step 400. So an interface that reads the opcode is reading a partly deterministic counter, and Part F’s structural finding, that “the code remembers the anchor longest,” may be the clock remembering the step count. Part G reaches the same place from the other side: the clock, not self-modification, drives alignment loss. Section 9 tests this properly. The answer is not the one I expected, and it is worse for Part F than this paragraph is.

Part F’s script does not produce Part F’s data. part_F_phase_diagram.py builds the transition matrix, computes the nine K-profiles, prints two numbers per interface, and stops. It writes no files. The resolution scan, the detector decay, the phase diagram and the regime analysis, which are the four CSVs shipped as its artefacts and the four tables in its report, are not in it. So the count of stubbed parts is not two but two and a half.

Part G’s report understates its own peak. G3_ever_violated_visibility.csv shows the opcode view carrying 0.2409 at t = 10. The report says the quantity “peaks at 0.073 bits (t = 20)”, which is the second row, not the first. Section 11 shows it is worse than that, since the units are nats and the true peak in bits is 0.3475. The finding that the signal collapses to a floor of about 0.004 is right, and the delivered G3 and G4 data do corroborate every other number in that report, which is worth saying given the missing code. But at t = 10 the audit sees a good deal more than “almost nothing”.

Part G’s “never” is doing work it should not. The report prints an em dash for median first violation with the clock off, glossed as “never.” The CSV shows A(400) of 0.305 and 0.337. Thirty per cent of runs did violate. The median was not reached. Those are different claims.

5. On Sidis himself

Here the transcripts are on firmer ground, with one exception that matters.

The claim about Buckminster Fuller does not check out as quoted. The transcript says Fuller “wrote in 1976 of his ‘excitement and joy’ at finding the book ‘clearly predicts the black hole’.” The one accessible source the transcript itself cites, the Harvard Book Store listing, gives the sentence as “Imagine my surprise and delight when I was handed a xerox of Sidis’ 1925 book, in which he predicted the black hole,” and dates it to a letter to Gerard Piel on the 1979 rediscovery. Different year, different words, quotation marks around phrases that are not in the source. I could not find any 1976 version anywhere. Treat the Fuller anecdote as unverified until someone reads the letter. You have been here before with Bateson.

Two smaller things. Olbers is never named in the book. Sidis makes the dark-sky argument, that the black regions absorb the light of the white regions beyond, but the attribution of the paradox is the reader’s, not his. And “life is a reversal of the second law of thermodynamics” appears in the preface as Sidis’s summary of Kelvin’s suggestion. His own definition, in Chapter VII, is the blunter one: “Life consists of bodies with a mechanical efficiency of over 100%.”

The substantive reading is right. Sidis’s Chapter IV is Loschmidt’s objection independently reconstructed, his checkerboard is Boltzmann’s fluctuation cosmology, and his refusal of a low-entropy origin as “a mysterious creation which denies all physical laws” is precisely the Past Hypothesis, rejected. The essay on the later work is the most speculative thing in the folder and is honest about it: the perpetual calendar as two-directional time built in brass, the transfers book as classification under symmetry, The Tribes and the States as anti-creationism in politics. That is a reading of temperament rather than doctrine, and it says so.

6. Counter-arguments, since you will want them

Let me put the case against my own section 4, because parts of it are stronger than others.

Against the identity charge. That a result is an identity does not make it worthless. The whole point of a toy model is to make a structural claim visible in a form where it cannot be dodged. Sidis’s argument is that a mind and its time-reverse are internally indiscernible. If you build the model correctly, the demonstration should come out as an identity. A physicist would say the same of Noether’s theorem. Fair enough. But then the writing should say “this is an identity and here is why that is the point,” not “verified to machine precision,” which invites the reader to think a measurement was taken. The failure is one of presentation, and presentation is what the book will inherit.

Against the parity charge. Someone could say the ln 2 floor is harmless, since every downstream conditional entropy is computed on the same chain and the parity information cancels. Largely true. It does not touch Parts D, E or F, which use a different machine. What it does touch is the interpretation: the engine’s Part 3 is offered as “the second law here is nothing but approach to equilibrium from a special boundary, the Past Hypothesis quantified,” and the system it describes does not approach equilibrium. If you are going to build an argument about the arrow of time on a relaxation, the relaxation should be real.

Against the empty-scripts charge. The strongest reply is that Parts G and H were computed in a session whose environment wiped, and that the stubs are honest placeholders rather than pretence. Probably true, and both docstrings do carry full caveats. It still leaves the synthesis making a false claim about reproduction, in bold, in the same bundle. The programme’s own conclusion is that a system which certifies itself is not audited but merely consistent. The synthesis certifies itself.

Against my reading of the clock. I was overstating, and in the wrong direction. The experiment is now run and reported in section 9. Deleting the clock does not preserve the tail, which is the result I had predicted. It does something more damaging to Part F than that.

And the largest counter-argument of all. None of my objections touch the philosophical spine. Whether the exp(−ΔS) figure is derived or asserted by ansatz, the claim it stands for is independently true and was proved decades ago by Jarzynski and Crooks. Whether the eight-fold opacity is an artefact, Sidis’s chirality point still holds. The programme’s conclusions are mostly right. They are right because they were imported from the standing literature, not because these models established them. That is a different criticism from “wrong,” and a more awkward one, because a model that confirms what you already believed is the hardest kind to catch.

7. What this is worth to The Universe and Other Things

Four things, in descending order of value.

The arc itself is the chapter. A speculative monograph by a twenty-one-year-old in 1920, on whether a mind can face the other way in time, turns without a break into the question of whether you can verify that a machine which rewrites its own code still descends from the thing you trusted. That is your thesis executed rather than asserted. Cosmology to information theory to AI safety, no seams. I would put the route in and keep the destination modest.

Sidis is a better exhibit than a better-known figure would be. He is a case of the right question with the wrong sign, which is more useful to your argument than a case of someone being right. It also lets you make the point about priority honestly. His anticipations are real and his physics is wrong, and both facts belong in the same paragraph.

The context-window analogy is genuinely good. The line in SidiMulti-bitConclusion.docx, that a language model’s context window is a Part D register with its contents certain by storage and near-zero reliable inference past the far edge, and the first token playing the boundary state, is the sharpest connection in the folder. It is also testable, which most such analogies are not.

The audit results are usable if you cite them as toys. Resolution binds before budget, and the root of trust cannot live inside the audited system. Both are old truths in computer security. What the programme adds is a physical derivation of them, which is a nice thing to have, provided the chapter does not claim the derivation was needed.

What I would keep out until it is rebuilt: the eight-fold opacity penalty, the ln 2 relaxation, the 2 × 2 table as evidence rather than illustration, and the Fuller anecdote.

8. What I would do next

Four experiments, cheapest first.

Run the Part E and F machine with the clock rule removed. Done. Section 9.

Fix the engine’s opacity measurement to compare like lags, and report whatever it gives. If it gives zero, say so. A null result there would be more interesting than the current one, because it would say the mutual invisibility Sidis describes is not a property of the dynamics at all but of the assembly, which is Part 4’s territory and not Part 6’s.

Aggregate the urn chain over parity, or use a lazy chain, and re-run everything that depended on relaxation.

Rebuild Parts G and H as code. Their conclusions may well be right. At present they are the only two claims in the programme that cannot be checked by anyone, including their author, and they are the two the RSI argument leans on hardest.

9. The clock experiment, run

Section 4 accused the clock rule of manufacturing Part F’s long tail. Section 6 said the way to settle it was to rebuild the machine without the clock. That is now done, in clock_control.py, and the accusation was wrong in its stated form. What replaced it is a harder objection.

The design. Four arms, identical in every other respect to part_F_phase_diagram.py: same sixteen rules, same noise channel, same nine interfaces, same anchor, same six hundred steps, same Cesàro-tail equilibrium. Arm A is the machine as shipped, where the rules write the opcode and the clock then increments whatever they left. Arm D is arm A minus one thing only: the rules are blocked from the top nibble, so the opcode becomes a counter carrying no self-modification whatever. Arm B deletes the clock. Arm C replaces it with a uniformly random opcode. The measure throughout is K(150), the anchor distinctiveness surviving a hundred and fifty steps, which is what “long tail” means in Part F.

Arm A reproduces the shipped output to three decimals across all nine interfaces, so the rig is right.

The result.

Detector horizon t_det, the first step at which anchor distinctiveness falls below one nat, on the same interfaces: baseline 20 and 30, arm D 20 and 30, arm A2 100 and 135, arm D2 never.

Arm B is unusable and I will not lean on it. Deleting the clock creates 8,801 states that map to themselves, against 512 in the baseline, so the machine acquires exactly the fixed points the clock was written to prevent, the reachable set falls from 29,052 to 10,105, and the equilibrium distribution goes to 1.3 × 10⁻²⁸¹ in the anchor’s own bin. Its K(0) of 646 is a logarithm of that, not a measurement.

What this says. My prediction was that stripping self-modification out of the opcode would leave the tail standing. It does the opposite. Arm D kills it, from 0.159 to 0.002, an eighty-fold collapse. So the tail is not simply the counter, and Part F’s claim looked, for about a minute, vindicated.

Then arm D2. Keep the rules blocked, so there is still no self-modification anywhere near the opcode, and also keep the noise channel off the top nibble, so the opcode is a perfect deterministic counter. The tail does not merely survive. It becomes 2.639 and it never decays at all, identical at step 150 and step 300, sixteen times the baseline and permanent. A field that does no self-modification whatever, and which the environment cannot touch, remembers the anchor better than the self-modifying code does, and remembers it forever.

Read the column again in that light. What sets the size of the tail is not whether the audited variable is code. It is how much unrandomised structure that variable retains. Rules writing it are structured, so it keeps a tail. Pure counting is maximally structured, so it keeps the largest possible tail. Noise reaching it is the only thing that destroys one, which is why arm D collapses and arm A2, the shipped machine with noise held off the opcode, runs at four times the shipped figure.

The detector horizons say the same thing more usefully. In the baseline the anchor becomes indistinct at the audit interface at step 20 to 30, depending on resolution. Hold the noise off the opcode and that moves to step 95 to 135, a fourfold to fivefold gain from one change that has nothing to do with logging or with bin counts. In arm D2 the horizon does not exist. K stays at 2.639 forever and the anchor is never lost at any distance, because a variable the environment cannot reach cannot forget.

So the correction is this. Part F is right that the opcode interfaces carry the tail in this machine, and right that resolution selects the regime. It is not entitled to the sentence it built on that, “interfaces that resolve the machine’s self-modifying opcode carry the long tail, the code remembers the anchor longest,” because the experiment that would isolate self-modification shows a non-self-modifying counter in the same field doing the job better. The variable that matters is noise exposure, not code. And the RSI corollary drawn from it, ask first whether the audit interface can see the self-modifying code, does not follow. What it should say is: ask which audited variables the environment is least able to randomise, because those are the ones that hold provenance, whether or not they are code.

That is a smaller claim than Part F’s and a more useful one, since noise exposure is something an engineer can actually design for.

10. The three recovered files

part_A_fluctuation_window_analysis.py, anchor_loss_report.pdf and multibit_memories_report.pdf were found and added after this commentary was first written. The zips were not. Nothing else in the folder changed, and I checked: the Part G and Part H scripts are the same files, to the byte and to the timestamp, so section 4’s finding about them stands.

Part A has the best reproduction record in the folder, and it is not close. I ran the recovered script. All four of its CSVs come out byte-identical to the delivered ones. A1_occupancy.csv, A2_valleys.csv, A3_depth_spectrum.csv and A4_memory_symmetry.csv, no differences at all. Nothing else here does that, and the part I had written off as data without code turns out to be the one part that reproduces exactly. That correction matters more than any of the faults below.

Its A2 result is sound and I want to say so plainly. Seventy-one valleys, mean fall 3.576 against mean rise 3.556, standard deviations 0.949 and 0.944, fall time 19.6 against rise time 18.7. The selection rule is min(fall, rise) >= 2.5, which is symmetric in the two arms, and the smoothing is a centred moving average, so neither can manufacture the agreement. With seventy-one valleys the standard error on the difference is about 0.16 and the difference is 0.020. This is a real test that could have failed and did not. It is also the most interesting negative result in the programme, and the docstring draws it correctly: if a valley is its own mirror, there is no local arrow inside a fluctuation for a pseudo-mind to ride. That is a genuine answer to Sidis’s Chapter V, and it is his answer refuted from inside his own model.

A4 is not a test. Lines 133 and 134 read cp = np.corrcoef(ns[lag:], ns[:-lag]) and cf = np.corrcoef(ns[:-lag], ns[lag:]). Those are the same expression with the arguments swapped, and correlation is symmetric in its arguments, so the two columns are one quantity computed twice. They agree to ten decimal places, and the CSV rounds to four. My earlier note called this an identity of stationary reversibility. It is weaker than that. A correlation test that cannot distinguish past from future cannot confirm that they are alike, and it could not have detected an asymmetry if the chain had one.

The underlying claim is nonetheless true, and it is worth having the real number. Computed properly, anchoring both directions on a common window of t, the forward and backward correlations differ by 8.6 × 10⁻⁹ at lag one and 3.4 × 10⁻⁴ at lag forty. That is finite-sample noise, the claim survives, and the honest version is stronger than the delivered one because it had a way of going wrong. This is the third time in the folder that a real result is supported by a check that cannot fail, and it is the same shape as your own G5.

A3’s exponential is anchored, not fitted. C0 = cnt[0] * math.exp(bins[0]) sets the Boltzmann prediction to pass exactly through the first bin, which is why 31 observed sits against 31.0 predicted. The rate itself is not fitted, being fixed at one per nat by the physics, so this is more defensible than it first looks. But the middle bins depart a good deal, 25 against 18.8 and 4 against 11.4, and χ² is 10.5 on six degrees of freedom. That is not a rejection. It is not the confirmation the docstring’s “counts decay ~ exp(-dS) as Boltzmann requires” implies either.

Part D’s report checks out. D1’s cone table matches cone_by_length.csv row for row at t = 80. D2’s credit at s = 40, zero at 0.05 nats, zero at 0.5 and two at 1.0, matches inference_credit.csv. D4’s twenty-bit reach, L = 11 and 21 touching the boundary at t = 10 and 20 and then 19, 18, 18 and never again, matches reach_by_budget.csv. The compressibility identity is quoted at 9 × 10⁻¹⁶ and my run gives 8.9 × 10⁻¹⁶. One loose end: D3 gives the summed cost as 286.4 bits forward and 283.7 backward, while anchor_cost.csv runs only to t = 200 and sums to 188.20 and 185.49. The gap of 2.7 bits is the same in both, and 188.2 appears in the report’s own next paragraph, so the two figures are the same quantity over three hundred steps and over two hundred. The report changes horizon without saying so, and the delivered artefact covers the smaller one.

Part E’s report checks out too. Every constant in it matches my run of part_E_self_modifying_machine.py: h̄ coarse 2.086, t_mix 218, t* of 20 at confidence 0.75 and 100 at 0.55, the detector running 1.000 to 0.627 to 0.511. The reachable set of 29,052 states is the same number my clock-control rig counts. It does repeat the Part C detector construction, its co-oriented and counter-oriented columns summing to exactly 1.000 at every row, so the criticism in section 4 applies here as well.

What this round changes. Part A moves from “data without code” to the most reproducible thing in the folder, with one honest experiment and one that cannot fail. Parts D and E now have their reports, and both check against their data. The count of parts whose numbers have no reproducible source falls from Part A, G and H to G and H alone. That is a better folder than the one I first described, and the two stubs are now the whole of the reproducibility problem rather than a third of it.

11. Part G rebuilt from its own specification

The G and H folders were opened for inspection. No code arrived. I hashed both scripts against the copies I first read and they are identical, 965d6e4e… and 5bd14732…, and parsing them confirms what the byte count implied: Part G has four top-level statements, a docstring, two imports and a print, and Part H has three. Zero computation in either. The one new file is audit_vs_alignment_report (2).pdf, which is the same report re-rendered with the reference to the missing zip removed.

So rather than report the absence a third time, I rebuilt Part G from the specification in its own docstring and the machine definition in Part E. The result is more interesting than the complaint.

It reproduces. Every one of the 160 rows in G3_ever_violated_visibility.csv and G4_instantaneous_violation.csv matches my reconstruction to within 6 × 10⁻⁴. Both of G1_variants.csv’s self-modifying rows match to four decimal places on all four columns: τ = 9, A(50) = 0.9974, A(200) = 0.9981, A(400) = 0.9981, and for the clock-off variant τ never, 0.1748, 0.3048, 0.3051. That is not coincidence. Part G’s numbers are real. The script was lost, the results were not, and section 4’s finding should be read as a reproducibility failure rather than a doubt about the work.

But every number in G3 and G4 is in nats, in a column headed _bits. Each delivered value is exactly my figure times ln 2. This is the second confirmed instance of the same defect, the first being the engine’s opacity measurement, and it runs through the report and the synthesis, which both quote these as bits.

The units error understates the results. The report’s “I(audit view; ever violated) peaks at 0.073 bits (t = 20)” is wrong in two ways at once. The peak is at t = 10, not 20, and in bits it is 0.3475 rather than 0.073. Put beside the entropy of the thing being asked about, H(ever violated) = 0.896 bits at that moment, the coarse opcode interface is recovering thirty-nine per cent of everything there is to know about whether the machine has ever left spec. That is not “almost nothing”. G4 is understated the same way, at 0.82 bits rather than 0.57.

Which raised a real objection, so I tested it. Follow the ratio out in time and it does not decay: 39 per cent at t = 10, down to 7 at t = 30, then back up to 32 by t = 60 and still 27 at t = 400. The raw mutual information collapses to 0.005 bits, but so does the entropy of the question, because by step 40 the machine has violated on 99.5 per cent of trajectories and there is almost nothing left to be uncertain about. Those are different claims. “The record has evaporated” and “the question has stopped being uncertain” have quite different engineering consequences, and G3 as built cannot tell them apart.

The law survives the test. I chose the spec so that ever-violation stays maximally uncertain, which removes the saturation entirely, and re-ran. At popcount ≤ 12 the entropy of ever-violation is 0.986 bits at t = 200, near the theoretical ceiling, and the opcode audit recovers 0.008 bits of it. Eight tenths of one per cent. At popcount ≤ 13 it is four tenths. So where there is genuinely a great deal to know, the state-based audit sees almost none of it, and the thirty-one per cent at the original’s own threshold turns out to be a small number divided by a small number. My objection was wrong, and Part G is stronger at thresholds it never tried than at the one it did.

One thing I could not rebuild. The two rows with self-modification switched off. The original never says which opcodes that disables, and I tried three readings, turning off 5 and 6, turning off 5, 6 and 12, and turning off 12 alone. None gives the delivered 0.9925, though all three give τ = 9. This is exactly the row G1’s headline rests on, since “the clock, not self-modification, drives alignment loss” is the comparison between the two clock-on rows. The conclusion holds under every reading I tried. The number behind it depends on a choice the report never states.

part_G_rebuilt.py ships with this file. Part H is dealt with next.

12. Part H rebuilt, and the units problem named

Part H rebuilt the same way, from its docstring and the Part E machine. Thirty thousand sampled trajectories to step sixty, the safe region and the stealth defect as specified, the five accumulators as described. part_H_rebuilt.py ships with this file.

It reproduces, under two corrections. The first is that every delivered value is in nats, in columns headed bits, exactly as in Part G. The second is that in H1 “ever violated” means over the whole sixty steps, not by step twenty, although the table is headed “Audit (t=20)”. With both applied, H1 lands within sampling noise on every row, H3’s four accumulators come out at 0.379, 0.381, 0.376 and 0.376 against delivered 0.379, 0.378, 0.377 and 0.075, and H2 is closer still: I(MAC; ever stealth) at 0.3757 against a delivered 0.3761. My violated count is 29,943 against their 29,946, three trajectories apart in thirty thousand, which is what a different seed looks like. Part H’s numbers are real too.

The report’s claim that a strong accumulator carries “83% of the information-theoretic maximum” survives untouched, because it is a ratio of two nats figures and the units cancel. H(ever stealth) is 0.660 bits, which is 0.457 nats, against the report’s stated 0.456.

H4’s headline does not follow from H4’s experiment. The report says that a trusted accumulator gives “forgery rate 0.00000 at k = 8, 12, 16, for every accumulator type. Perfect tamper-evidence.” That is not tamper-evidence. It is what a bijection gives you for nothing.

Take each accumulator’s step map, h to some function of h and the symbol, and enumerate it over all 2ᵏ values of h. I did, for all five, at all three widths. Every one is a bijection: 256 distinct outputs of 256, 4096 of 4096, 65536 of 65536, without exception. It follows algebraically that a single-symbol edit can never produce a collision, at any width, for any of them. Two different running values at the moment of the edit stay different for the rest of the run. The forgery rate is zero by construction and the choice of hash is irrelevant.

The delivered H4_forgery.csv contains the tell and nobody looked at it. It lists sum at 0.0 beside mac3 and strong at every width. A plain eight-bit running sum is not a cryptographic object. If it achieves perfect tamper-evidence in your experiment, the experiment is not measuring tamper-evidence.

And the real number is not zero. Give the adversary the edit the scenario actually calls for, hiding every violating step rather than one, and the collisions come back at exactly the rate a k-bit accumulator must give: I measure 0.00397 at k = 8 against a floor of 2⁻⁸ = 0.00391, and 0.0001 to 0.0003 at k = 12 against 0.00024. An eight-bit accumulator forges about one time in two hundred and fifty. The report’s “perfect” holds only at sixteen bits, where thirty thousand trials expect half a collision and finding none proves nothing.

What survives is the part that matters and was never in doubt: an internal root forges at rate 1.000, because a system hashing its own edited log agrees with itself by definition. That needs no experiment, and the programme’s conclusion, that the root of trust cannot live inside the audited system, stands on it.

The units problem, now that it can be counted. Six measurements across three parts are natural logarithms presented as bits: the engine’s mutual opacity, G3, G4, H1, H2 and H3. The pattern is systematic rather than a slip, and it runs into the synthesis, which quotes several of them. Every affected figure is understated by a factor of 1.443. Two consequences worth carrying into the book. The audit results are stronger than reported, since G4’s popcount view sees 0.82 bits rather than 0.57. And every ratio and every comparison in those parts is unaffected, because the units cancel, so no conclusion changes. It is a labelling fault with real numbers underneath, which is the most recoverable kind.

Where that leaves the programme. Every one of the nine parts now has code that runs, two of them mine. Of the results, the great majority reproduce. What does not survive contact is narrower than I first thought and sharper. The Loschmidt echo, which has four values and no source for the one in the index. The eightfold opacity penalty, which compares unlike lags. The parity floor read as relaxation. A handful of identities offered as measurements. A4’s null test. Part F’s attribution of the tail to code rather than to noise exposure. And H4’s attribution of injectivity to cryptographic strength. Seven faults in a body of work that got the physics, the history and the philosophy right, and that reached a real destination by asking the next question thirty times running. I would take that trade.

13. Coverage, checked rather than claimed

You asked whether I had thoroughly checked A to I for code and for sense. I had not, and finding that out was worth more than the reassurance would have been. Three scripts I had never executed, one I had never opened, and for four more I had checked only the numbers they print rather than the numbers they claim. Two of those gaps changed a verdict. Here is the whole of it, per script.

The good news first, because it is larger than I had said. Part C regenerates every one of its four CSVs byte for byte, which I had never tested. So do Part D’s four, which I had only spot-checked against the report. So do both engines’ three, and Part B’s B1 and B3. Counting properly, seven of the eleven scripts regenerate their delivered data exactly, and the base model regenerates its values exactly with the delivered file merely rounded to four places. That is a considerably better record than “Part A is the only one that manages it”, which is what I told you two rounds ago.

One script I had never opened. sidis_pseudoliving_engine.py is a stripped copy of the recovered engine, 118 lines against 293, and it runs and reproduces all three of its CSVs byte for byte. But its output path is hardcoded to /home/user/output, the earlier session’s sandbox. Run it anywhere else and it silently writes outside the folder, so it appears to have produced nothing. A portability fault rather than a scientific one, trivially fixed, and it would waste an afternoon of anyone who tried.

And I had over-credited Part F. I wrote in section 3 that it “scans nine interfaces against six budgets and separates two regimes”, and that it reproduces. It does neither. part_F_phase_diagram.py builds the transition matrix, computes nine K-profiles, prints K(0) and K(150) for each, and stops. The equilibrium record cost, the critical window and the false-anchor rate of table F1, the entire budget axis of the phase diagram in F3, and the spike-against-long-tail classification of F4 are nowhere in the code. They appear only in the docstring. Three of Part F’s four tables have no source, and the sentence the part is remembered for, that resolution binds before budget, rests on a phase diagram that is not computed anywhere in the folder. Part E is the same fault in a milder form: it exports nothing, and E2’s overlap figures of 0.943 and 0.981 exist only as prose.

So the count of parts whose headline numbers have no code behind them was never two. Before I rebuilt G and H it was four, and I had been calling E and F real reproducible work on the strength of the numbers they happen to print. That is exactly the error this commentary keeps naming in the folder. I checked the output against what the script produced rather than against what the report claimed, which is an audit keyed on the wrong list, and I made it while writing the section that warns about it.

What I have and have not verified, plainly. I have read every file and executed every script. I have regenerated and compared, byte for byte, twenty of the delivered CSVs. I have rebuilt Parts G and H from their specifications and reproduced them. I have checked thirteen Sidis quotations against the scanned source, and three external claims against primary or near-primary sources. I had not verified the eight CSVs of Parts E and F against any code, because no code for them existed. Section 14 is that job, done. Section 16 narrows what “self-modification off” means in G1 without settling it, and F4’s tail fit is now closed. And the Fuller attribution stays open until somebody reads the letter.

That is the boundary. Everything inside it I watched happen.

14. Parts E and F rebuilt

Both are now done, in part_E_rebuilt.py and part_F_rebuilt.py. Sixteen of the seventeen missing quantities reproduce.

Part F, which was the larger hole. Three of its four tables had no code. All three are now recovered, and every column of every one of them matches the delivered data.

Three of F1’s columns had to be worked out rather than read off. The record cost h̄R is the equilibrium conditional entropy H(m{s+1} given m_s) under that interface, in bits. The critical window W_c is the last grid step whose detector confidence still clears the threshold, with a sentinel of −5 when even step zero fails, which is why parity carries a negative number. And the false-anchor rate is simply the equilibrium mass sitting in whichever bin contains the anchor, which is why it is 0.497 for parity and 1.02 × 10⁻⁴ for anything that separates the anchor’s own state.

F3’s horizon rule was the one real puzzle, and it resolved cleanly. The report gives the composite law as S_R(t,W) ≥ Θ without ever saying what Θ is or how t* is read off it. I searched the space of rules against the 54 delivered values. Summing K over the window and taking the last step that still clears the threshold gets 17 of 54 at best. Taking the first step at which the sum falls below it, with the window running from t−W rather than t−W+1, gets 48, and every one of the eight non-parity interfaces comes out 6 for 6. The remaining six are parity, where the sum never reaches the threshold at all and the original reports one grid step rather than zero. Add that floor and it is 54 of 54. And the threshold is not a free parameter after all: it is exactly 1.0 nat, the same value the original uses for t_det. One threshold throughout, which is the sort of thing a report should say and this one does not.

The tail constant took a third parameter nobody mentions. F4 gives a decay time for each interface and the report says only that it is fitted to the tail. Ordinary least squares on the logarithm of K over steps 40 to 300 gets six of the eight exactly, to the tenth of a step the file is quoted to: 144.17 against 144.2, 141.66 against 141.7, and so on down to full_state at 135.20 against 135.20. The two that missed were the two coarse interfaces, and badly, popcount out by fifteen steps.

The reason is that those two decay to almost nothing. By step 150 the popcount profile is down to 0.0097 nats and still falling, so most of the points in the window are numerical dust and they drag the slope wherever they like. Discard the grid points where K has fallen below 0.01 nats and both come back: 152.53 against a delivered 152.5, and 171.13 against 171.1. All nine rows then reproduce, and so does every other column in the table. Parity gives no fit under any reading, which is what the file records.

So the definition is least squares on log K over steps 40 to 300, keeping only points above a hundredth of a nat. Three parameters, a window and a floor, none of them written down anywhere, and the floor is the one that matters because without it the two spike interfaces are fitting noise. Recovering it took a search over window, method and threshold against the eight delivered values. That is a lot of machinery to reconstruct for one column, and it is the last thing in Parts E and F that was not simply missing its export.

One column is misnamed. F4’s K0_peak_nats is not the peak. It is K at step zero. For eight interfaces those coincide, but for the opcode view the true maximum is 3.311 nats at a later step, thirty-eight per cent above the 2.405 reported. Which is worth noticing, because the opcode interface is the one Part F builds its whole structural claim on, and its anchor signal does not peak where the table implies.

Part E. Three of the four CSVs reproduce exactly: E1 across all 301 rows and both columns, E3 across all 41 rows and both columns, and E4 across all five rows and three columns. E4 is the satisfying one, since its record budgets had to be reverse-engineered. Logging everything costs log₂ 272 bits a step, so an eight-state provenance chain needs 64.7 bits and buys exactly 8 steps. Logging only changes costs the binary entropy of the noise, 0.881 bits a step over nine states, so 7.9 bits, and against the coarse record cost of 2.086 that buys 3.8. Both land on the delivered figures to the decimal.

E2 is the one thing I could not rebuild, and section 15 establishes that it was never computed by any surviving version of the script. Its two overlap figures, 0.9433 and 0.9813, appear only as prose in the docstring. I tried the obvious readings, hit rates on the noiseless forecast, distributional overlaps, Bhattacharyya coefficients between successive marginals, forward and backward. Nothing lands near either number. I did notice that 1 − p/16 is 0.98125, which agrees with the reversed figure to four places, and that 1 − 3p/16 sits a third of a standard error from the forward one at twenty thousand samples. That would be a tidy story about the sixteen possible noise positions, and it is wrong, because the noise index is not uniform over those positions. It runs from 0.053 to 0.118 across the sixteen. So the agreement is a coincidence and I will not dress it up as a reconstruction.

Where the programme now stands. Every part has code. Seven scripts were always there and reproduce their own data. Four tables of Part F, four of Part E, and the whole of Parts G and H are mine, and between them they reproduce all but two of the delivered values I could test. What remains without any source is two numbers in E2 and an unstated choice in G1. That is a different programme from the one I described in section 4, and the difference is not that the work got better. It is that I kept checking.

17. The last two, searched properly

Both remaining gaps have now had a systematic pass rather than a handful of guesses. Neither closed, but both are better understood, and in one case the negative result is itself worth something.

G1, exhaustively. The violation tag is absorbing, so instead of carrying a 131,072-state tagged chain I can propagate only the mass that has never left spec, zeroing the violating states each step. That is about ten times faster and made a real search affordable. I tried every single opcode disabled, all 120 pairs, all 240 single-rule substitutions where one opcode’s rule is replaced by another’s, three structural maskings of the code fields, and six variants of which string picks the vulnerable bit. Three hundred and eighty-five variants, each on both clock settings, scored against all six delivered numbers at once.

None satisfies both rows. The space is not empty in the relevant direction: seventy-nine of the variants do raise the clock-off violation rate above the baseline, which is the constraint that ruled out every subtractive reading. So an answer of this shape could have existed. It simply is not there.

The closest is odd enough to record. Replacing opcode 6’s rule with opcode 9’s reproduces the clock-off row’s endpoint exactly, 0.3367 against a delivered 0.3367, with 0.3364 against 0.3361 beside it. But it leaves the clock-on row sitting at the baseline, 0.9981 where the table wants 0.9925. Every substitution into opcode 6 does that, which tells you something about how little opcode 6 matters once the clock is running, and nothing about the switch.

So the reading is not a rule edit and not a change to the noise channel. It is either a structural change I have not thought of, or the two rows differ from the baseline in more than one respect at once. I would not guess further without something to check against.

E2, by battery rather than by guess. Rather than proposing definitions one at a time, I built several hundred scalars from the machine and asked which land near 0.9433 or 0.9813. Bayes accuracy of prediction and of retrodiction, at the microstate level and on three audit interfaces. Uncertainty coefficients in both directions. Total-variation overlaps and Bhattacharyya coefficients, between successive marginals, between marginals at lag, and between the noiseless push-forward and the true next distribution. All at a spread of times from the anchor out to equilibrium.

Nine scalars land within 0.0015 of one target or the other. That sounds encouraging until you count what chance predicts: a tolerance of three thousandths either side of two targets is six thousandths of the unit interval, so a battery of five hundred should throw about three by luck, and these quantities cluster near one, which inflates it. Nine is what noise looks like.

And the test that matters fails cleanly. Eight of the nine sit near 0.9813 and only one near 0.9433, so no single measure supplies both. I checked the most promising family directly, the uncertainty coefficient run forward and backward across four interfaces and eleven times, since that is the natural home for a forward-and-reverse pair. The best pairing anywhere in the sweep is 0.9307 and 0.9379, out by 0.056.

That changes the character of the conclusion. E2 is not a definition I have failed to guess. Within the space of ordinary information-theoretic and overlap measures on this machine’s marginals and one-step joints, the pair does not exist. It could still be something outside that space, a sampled trajectory-level reconstruction accuracy of some kind. But set beside the fact that no surviving version of the script computes it, the reasonable position is that the two numbers are unsupported and should not be quoted.

Where that leaves the ledger. Every number in the programme is now either reproduced, corrected, or positively established as having no source. Two figures in E2, in the third category. One definition in G1, narrowed and searched but open. The bundle zips, still missing and of no consequence, since everything they would have held has been rebuilt.

15. The third Part E, and why E2 stays open

A folder called sidis_part_E_complete(1) arrived after section 14 was written. It does not close E2, and it is worth saying exactly why, because the answer is now about as definite as this kind of question gets.

Its four CSVs are byte-identical to the ones already in the bundle. Its report differs from the copy in the root by a single line, a companion pointer naming Part C where the other names Part F. What is new is the script, a compressed variant at 3,204 bytes against the bundle’s 7,138. It runs, prints h̄ = 2.0859 and t_mix = 218, and regenerates E1 byte for byte.

But it is less complete than the file it replaces, not more. The bundle’s version at least computes the anchor detector and the horizon. This one drops both. It contains exactly one file-writing statement and it writes E1. Its docstring says “It writes E1_hbar_profile.csv through E4_horizon.csv”, which is not true of the code beneath it, and its headline reproduction lists “forward/reverse record overlap = 0.943 / 0.981”, which the code never computes. I stripped the docstring and parsed what was left: no overlap, no 0.943, no 0.981, no detector, no horizon, no reference to E2, E3 or E4 at all.

I then searched every Python file in the folder. The strings 0.943 and 0.981 occur in exactly two places, and both are docstrings, in the two copies of Part E. No line of code anywhere in the programme produces them.

So E2 is not a lost script. That is what Parts G and H were, and the distinction matters: their code was missing and their numbers reproduce exactly once you rebuild it. E2 is different. Three versions of the Part E script survive and not one of them ever computed the quantity, while three separate documents assert it. Either it was worked out in a scratch cell that was never saved, or it was never worked out. I cannot tell those apart from here, and I am not going to guess.

For what it is worth, I tried supplying the quantity rather than recovering it. Taking the natural reading, best-guess prediction of the next macrostate against best-guess retrodiction of the previous one, computed exactly at the Cesàro equilibrium on the same 272-bin interface, gives 0.509 forward and 0.505 backward. Not close to 0.943 and 0.981, and it does not even reproduce the direction of the asymmetry the report rests on, since prediction edges out retrodiction rather than the reverse. So my substitute does not support the E2 claim either.

The claim E2 carries is that retrodiction beats prediction in this machine, which the report reads as Sidis’s time-mirror surviving in record space. That is a good sentence and it may well be true. It has no evidence behind it in this folder, and mine points the other way.

16. The unstated choice in G1, and what looking for it found

G1 crosses two switches, self-modification and the clock, and reports four rows. My rebuild reproduces both self-modifying rows to four decimal places on all four columns. Neither of the other two comes out, and the reason is that the programme never says what turning self-modification off actually does to the machine. Which opcodes stop working, and what they do instead. Part E names three channels by which the machine rewrites itself, ops 5 and 6 letting data write code and op 12 letting code write data, but no file anywhere says which of them the switch touches or what replaces them.

I tried twelve readings: turning off 5 and 6, all three, each singly, the data-writing pair, all five, every rule that can reach the top nibble, masking the rules out of the opcode, masking them out of the top byte, and two variants where the noise stops being steered by the string. None reproduces the delivered numbers.

But the delivered numbers constrain the answer more than anyone noticed, and they rule out the obvious reading. With the clock running, switching self-modification off makes the machine violate its specification slightly less often, 0.9925 against my baseline’s 0.9981. With the clock stopped it makes it violate rather more often, 0.3367 against 0.3051. That second figure is the awkward one. Turning rules into no-ops can only add fixed points and reduce spreading, so every subtractive reading pushes the clock-off number down. Mine land between 0.05 and 0.30, all below the baseline, where the delivered value sits above it. Whatever the switch does, it makes the machine mix more rather than less, so it is not “switch the code-writing rules off”. That is a real narrowing and it is the most I can honestly say.

And looking for it turned up something worse than the missing definition. Opcode 12, which both Part E docstrings name as the channel by which code rewrites data, is the identity map. Not approximately, not on most states. On all 65,536.

The rule is (x & 0xFF00) | (((x >> 4) & 15) << 4) | (x & 15). The middle term is exactly x & 0x00F0 and the last is exactly x & 0x000F, so the three terms reassemble the state they came from. It does nothing, by construction rather than by accident, and I confirmed it over the whole state space.

That matters beyond G1. The Sidis Machine is presented throughout Parts E, F and G as a register whose state is its own program, with three documented self-modification channels. One of the three is a no-op. What remains is ops 5 and 6, which write the top two nibbles from the bottom two, plus whatever the shift, rotate and complement rules incidentally spill into the opcode. It is still a self-modifying machine. It is a third less self-modifying than every document in the folder says, and the finding sharpens section 9 rather than contradicting it: when I blocked the rules from writing the opcode and the anchor signal collapsed, I was blocking two channels, not three.

What none of this costs. G1’s conclusion is that the clock, not self-modification, drives alignment loss, and that survives everything above. Every one of my twelve readings gives a median first violation of nine steps with the clock on, the same as the self-modifying case, which is exactly the comparison the claim rests on. The conclusion is safe. Two of the four numbers under it are not reproducible, and the machine has one fewer moving part than advertised.

Sidis published his objections and refused to answer them, so that the reader could weigh the thing himself. The folder repeats the gesture in the caveats sections of every report, and those caveats are good ones, carefully written and mostly correct. What went unexamined was not the physics but the arithmetic underneath it. A programme that ends by proving no system can audit its own past turns out not to have audited its own. Though sections 11 to 13 are the fairer last word. Most of what it claimed was true, and recoverable by anyone willing to rebuild it.

Files read: all 73 programme files in Claude Matter 3. Code executed: firstsidis_pseudoliving_engine.py, part_B_reversible_CA_embedded_agent.py, part_D_multibit_memories.py, part_E_self_modifying_machine.py, part_F_phase_diagram.py, part_I_master.py, part_A_fluctuation_window_analysis.py, part_C_informational_arrow_analysis.py, pseudo_living_mind_model.py, sidis_pseudoliving_engine.py, and clock_control.py, part_E_rebuilt.py, part_F_rebuilt.py, part_G_rebuilt.py and part_H_rebuilt.py, all five new, which ship beside this file with clock_control_results.csv. That is every script in the folder. Twenty delivered CSVs regenerated and compared byte for byte. Quotations checked against the Gorham Press scan by string search. External claims checked against HathiTrust and the cited bookseller listing.