@prefix this: . @prefix sub: . @prefix np: . @prefix rdf: . @prefix prov: . @prefix npx: . @prefix dc: . @prefix xsd: . sub:Head { this: a np:Nanopublication; np:hasAssertion sub:assertion; np:hasProvenance sub:provenance; np:hasPublicationInfo sub:pubinfo . } sub:assertion { a ; dc:description "analysis.py compiles each two-register machine (program length L) into a table of 6L branches (p, q, s), one per residue n mod 6L, of the form n -> (p*n + q)/s with p, s in {1, 2, 3}: increments multiply the 2^a 3^b part by 2 or 3, decrements of a nonzero register divide it by 2 or 3 (the residue mod 6L tells whether the register is nonzero), and the additive constant moves the program position. Register machine and arithmetic map were run side by side in exact Python integers: 200 random L = 5 programs (numpy seed 20261111) from two starting states each for 10000 steps, and three hand-written growth programs (L = 3, 5, 7; moduli 18, 30, 42) for 20000 steps. At every step the integer n was compared with the encoding i + L * 2^a * 3^b of the simulated machine state (equivalent to decoding, since the encoding is injective). A perturbed map with one additive constant changed by one was run as a check that the comparison can fail."; "Measured: 0 steps at which the arithmetic-system value differs from the encoding of the register-machine state (n = 4060000, exact integer arithmetic; none). Interpretation: Wolfram's 'system that takes a whole number, computes Mod[n, 30], and applies one of several arithmetic operations chosen by that remainder' is the family of generalised Collatz maps n -> (p*n + q)/s with the branch chosen by n mod M. The specific register machine of Wolfram's figure is not transcribed in the online text, so instead of checking his single example the test checks the general construction he describes (encoding n = i + L * 2^a * 3^b, modulus 6L; for L = 5 this is his modulus 30) on a random sample of register machines plus growth programs. Register-machine conventions follow NKS Chapter 3 (pp. 97-102): decrement of a zero register is a no-op that moves to the next instruction, and the program wraps around cyclically. The 'therefore universal' clause is a theorem of Minsky's and is outside what this computation establishes."; "Claim test of wolfram2002-ch11-11: supports, confidence 0.9"; ; prov:wasAttributedTo ; "Planned datasets: nks-ch11-11-register-machine-compiler"; "claim-test/0.1.0"; "computational"; "Pre-registered. 'refutes' if any run of the correctly compiled map disagrees with the register machine at any step. 'inconclusive' with reason 'other' if the perturbation check fails to produce a mismatch (the comparison would then be too weak to count)."; "Finite traces cannot prove the emulation for all time, but the branch table is derived symbolically from the instruction semantics, so the trace check is a consistency test of that derivation rather than a sample-based estimate.", "Register-machine conventions (cyclic program, decrement of zero is a no-op) follow NKS Chapter 3; a different convention would change the compiled table but not the construction.", "The 'therefore universal' clause rests on the universality of two-register machines (Minsky 1967), which is cited, not re-proved; the compiled maps inherit universality from it only if one accepts that theorem. The closing remark that universality in arithmetic is unsurprising is an opinion and was not tested.", "What was verified is the emulation half of the claim: the described class of arithmetic systems (remainder modulo 6L selects one of 6L affine-rational operations) tracks arbitrary two-register machines exactly, over 4.06 million compared steps with register values up to several thousand and integers up to 14695 bits. The construction is general (it works for every program in the family, with L = 5 giving Wolfram's modulus 30), not a transcription of the particular 5-instruction machine in Wolfram's figure, whose program is not in the online text."; "Pre-registered. analysis.py compiles each register machine into the remainder-selected arithmetic map, then runs machine and map side by side. Test set: (a) all 200 register machines drawn with numpy seed 20261111 from the family with L = 5 and two registers (instruction type, register and jump target uniform), each from the state (1, 0, 0) and from one random state with registers in [0, 20], for 10000 steps; (b) three hand-written programs with L in {3, 5, 7} that move or copy register contents so that the registers grow without bound, 20000 steps each. 'supports' if at every step of every run the decoded (i, a, b) equals the directly simulated register-machine state (0 mismatches out of all compared steps) and, as a check that the comparison can fail, a deliberately perturbed map (one branch's additive constant changed by 1) produces a mismatch within 10000 steps on at least one of the hand-written programs. Universality of the arithmetic systems then follows from the universality of two-register machines (Minsky 1967), which is cited, not tested."; "Pre-registered. 'refutes' if any run of the correctly compiled map disagrees with the register machine at any step. 'inconclusive' with reason 'other' if the perturbation check fails to produce a mismatch (the comparison would then be too weak to count)."; "0.9"^^xsd:double; ; "supports"; "For any two-register machine in Wolfram's sense (program of L instructions, each 'increment register r and go to the next instruction' or 'if register r is nonzero decrement it and jump to instruction j, else go to the next instruction', cyclic program), there is an arithmetic system n -> (p*n + q)/s whose branch is chosen by n mod 6L such that, with the state (i, a, b) encoded as n = i + L * 2^a * 3^b (Wolfram's encoding on p. 673 with L = 5 and modulus 30), the integer trajectory decodes step for step to the register machine's trajectory."; "analysis.py compiles each two-register machine (program length L) into a table of 6L branches (p, q, s), one per residue n mod 6L, of the form n -> (p*n + q)/s with p, s in {1, 2, 3}: increments multiply the 2^a 3^b part by 2 or 3, decrements of a nonzero register divide it by 2 or 3 (the residue mod 6L tells whether the register is nonzero), and the additive constant moves the program position. Register machine and arithmetic map were run side by side in exact Python integers: 200 random L = 5 programs (numpy seed 20261111) from two starting states each for 10000 steps, and three hand-written growth programs (L = 3, 5, 7; moduli 18, 30, 42) for 20000 steps. At every step the integer n was compared with the encoding i + L * 2^a * 3^b of the simulated machine state (equivalent to decoding, since the encoding is injective). A perturbed map with one additive constant changed by one was run as a check that the comparison can fail."; "Pre-registered. analysis.py compiles each register machine into the remainder-selected arithmetic map, then runs machine and map side by side. Test set: (a) all 200 register machines drawn with numpy seed 20261111 from the family with L = 5 and two registers (instruction type, register and jump target uniform), each from the state (1, 0, 0) and from one random state with registers in [0, 20], for 10000 steps; (b) three hand-written programs with L in {3, 5, 7} that move or copy register contents so that the registers grow without bound, 20000 steps each. 'supports' if at every step of every run the decoded (i, a, b) equals the directly simulated register-machine state (0 mismatches out of all compared steps) and, as a check that the comparison can fail, a deliberately perturbed map (one branch's additive constant changed by 1) produces a mismatch within 10000 steps on at least one of the hand-written programs. Universality of the arithmetic systems then follows from the universality of two-register machines (Minsky 1967), which is cited, not tested."; "false"^^xsd:boolean . . a ; dc:description "trajectories compared step by step between the register machine and the arithmetic system"; dc:license "generated"; "Dataset: Two-register machines (NKS Chapter 3 conventions) and their compiled remainder-selected arithmetic maps, generated by analysis.py: 200 random programs of length 5 (numpy seed 20261111), three hand-written growth programs of length 3, 5 and 7; 10000 or 20000 steps per run; exact Python integers"; prov:wasDerivedFrom . } sub:provenance { a prov:SoftwareAgent; "delphisci claim tester (claude-fable-5.1; cursor/claim-tests-wolfram-nks-e5f4)"; prov:actedOnBehalfOf ; . a ; dc:identifier "claude-fable-5.1" . sub:assertion prov:wasAttributedTo ; prov:wasDerivedFrom ; prov:wasGeneratedBy sub:test . sub:plan prov:hadPlan . sub:test a prov:Activity; prov:qualifiedAssociation sub:plan; prov:wasAssociatedWith . } sub:pubinfo { this: dc:created "2026-11-08T16:24:31.938Z"^^xsd:dateTime; dc:creator ; dc:license ; npx:hasNanopubType ; npx:introduces ; "Claim test of wolfram2002-ch11-11: supports, confidence 0.9"; . sub:sig npx:hasAlgorithm "RSA"; npx:hasPublicKey "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyFHtPB6p0mCjDozxlOY9CmO3nBm7Te3jFbXyLmM+G1tGe47Da0jYIbhkl9Oo1ZjxmCa3LCwlEqK8gj6hEIcL4ahW30JXh9HycfKVk1bugkzMEV15tJdTzAU3sGMFnbNsn43xY2LFLy45tApkRm5byEiM7oRRrooIdwoQKnP4Wzq/bfAoJ9qvW+MGkelyOTd1jbSt+KfmT7xKmDfWzAHddUlWwMX2QJOLxDaffOteTop6ZRgPiNmPJKA/S62Gac9XtSYT3oDkZ6/nr5cxxNLpOyxTf5FPISiCe11xYO/unYjY+mwnOfA8yhJIyx1l0O9I0vpOpn+E5TvyHJV+oSTrvwIDAQAB"; npx:hasSignature "CH42jxk+T/t2eI9yDqqoSXw+/tpcOrzdeSWVHeQP8Dwb79mGBcbwXeqo/sHFVpZFb+3iyuK+suX2ONY5QJ2Dp7Ev9ST5lao2rENYGN7yM7efKqx6Q3/MfsYq9q4xjDV5p4CbjQ5l6mjvcvjEx5tF5+wGdIXW1YSfs4hUXnackdcaRsoLq3Za3Csr17JBzdSCGXXDdiJU/AmDHpcB5dju3Oqu9l7GRn1vfmFEfPcDUnN+u9FQ9KvMYOHBECDQR/uQ5qsVAMit8YPjp0hfwZ7qPUqSOlgJVB/gBvLVCKt8tBUSi8X3EVzT3uG1BCSQJDZBQjjJ1YeqrnqM3AxuPLVUIQ=="; npx:hasSignatureTarget this:; npx:signedBy . }