From a comparison article to a reproducible source benchmark

01Reproducibility begins before a numerical fit

A calculation is reproducible when another reader can identify its inputs, definitions and operations well enough to obtain the same output. Theoretical work does not need an experimental proposal at every stage to meet this standard. An explicit finite model, symbolic derivation or bounded numerical calculation can already remove ambiguity about what has been established.

For SMM/DTT, reproducibility is especially useful because words such as source, inner time, completion and readout can describe several different mathematical constructions. A benchmark fixes one construction and makes its consequences visible. It also prevents a successful numerical output from concealing independently chosen clocks, memory rules or normalization factors. ^[1]

02Benchmark one: a retained-record grammar

Set L₀ = 0 and define L_d = (2ᵈ−1)+qL_{d−1}. With q = 10 and depth three, direct iteration gives 1, 13 and 137. The input is not just the number ten: it is the rule for terminal branches, continuation labels, depth and stopping. A reader can change q or the empty-word convention and see which assumption controls the result.

This is the appropriate reproducibility target for the structural receiver calculation. It does not yet claim that the same recursion is selected by a source Hamiltonian. Reporting alternative q values is an independence test, not a statistical uncertainty on an experimentally measured coupling. ^[2]

03Benchmark two: geometry and clock choices

Choose B = 8 and r = 1/2 to obtain scaling exponent D = 3. Define the candidate activity and clock increments by a common logarithmic encoder and recover the ratio three. Then test the alternative clock T = u+τ, which gives ratio 3/4 with unchanged geometric data.

The numerical exercise does not invalidate the conditional logarithmic result. It shows that the geometry has not selected the physical clock class. A source construction that excludes the alternative through an independently justified mechanism would be a stronger model. Including this comparison in the reproducible calculation keeps the selection issue separate from the arithmetic.

04Benchmark three: a coupled response

For the positive response matrix K = [[2,1],[1,2]], the first-channel susceptibility is 2/3. If the off-diagonal coupling is set to zero while the diagonal entries remain two, it becomes 1/2. The dimension of the matrix did not change, but the physical response did.

This small calculation distinguishes receiver size from interaction law. A numerical constants model should expose the equivalent operator inputs and show what happens when allowed parameters vary. If the desired number survives because a source symmetry fixes the operator, that protection is the result worth proving. If it survives only after retuning parameters, the calculation has a different explanatory status. ^[3]

05What the included calculation records

The comparison package includes a small standard-library Python benchmark script. It reproduces these counts and ratios, checks simple probability normalization and records explicitly chosen inputs. Its outputs are toy-model values rather than claims about new measured constants. The file can be inspected and run without installing a numerical package.

The script is a companion to the derivations, not an independent proof of the physical interpretation. A calculation that reproduces its own chosen assumptions still needs a source argument for those assumptions. The value of the companion is that a reader can identify and alter them without reconstructing hidden implementation choices.

06A small result can rule out an overbroad inference

The two response matrices in the companion script have the same dimension and different susceptibilities. That is enough to disprove the unrestricted statement that dimension alone determines the displayed response within this model class. The example does not disprove a more specific source theory that allows only one of the matrices or derives their coupling from a symmetry. It identifies the additional restriction such a theory must actually provide.

This distinction gives counterexamples a constructive role. An exact finite calculation can separate a valid restricted claim from an unsupported generalization, then guide the design of the next source mechanism. The same approach applies to clocks: an alternative operational clock challenges universality only if that clock is admissible under the source principles being tested. A reproducible comparison therefore documents both the numerical inputs and the allowed class of models. The statement being assessed remains visible alongside the result.

07How this strengthens a theoretical programme

The most useful benchmark compares independently defined outputs of the same source law. It states the parameter family, resource budget and allowed interventions, includes unsuccessful completions where relevant, and reports the domain in which the approximation holds. A symbolic invariance proof can be more important than a large simulation if it removes a genuine freedom.

This approach supports the programme’s theoretical goal directly. It makes a smaller correct result portable between articles and manuscripts, allows counterexamples to be checked, and clarifies which new source mechanism would count as an advance. The programme becomes cumulative because each claimed bridge can be tested at the level of its explicit mathematics.

THE SAME QUESTION, DIFFERENT STARTING POINTS

The comparison at a glance

Reproducible Python examples

Save the source below as benchmarks.py and run python3 benchmarks.py. The examples require Python 3.9 or later and use only the standard library. All inputs are illustrative.

#!/usr/bin/env python3
"""Small exact and numerical examples accompanying C439–C462.

Run: python3 benchmarks.py
Python 3.9+; only the standard library is used. All inputs below are illustrative.
These calculations reproduce conditional model statements, not measured constants.
"""
import json
import math
from fractions import Fraction


def retained_records(continuation_labels, depth):
    if not isinstance(continuation_labels, int) or continuation_labels < 1:
        raise ValueError('continuation_labels must be a positive integer')
    if not isinstance(depth, int) or depth < 0:
        raise ValueError('depth must be a nonnegative integer')
    levels = [0]
    for d in range(1, depth + 1):
        levels.append((2**d - 1) + continuation_labels * levels[-1])
    return levels


def refinement(branching, contraction):
    if branching <= 1 or not 0 < contraction < 1:
        raise ValueError('Require branching > 1 and 0 < contraction < 1')
    activity = math.log(branching)
    clock = math.log(1 / contraction)
    return {'counting_exponent': activity / clock,
            'selected_clock_ratio': activity / clock,
            'alternative_clock_ratio': activity / (activity + clock)}


def susceptibility(a, b, d):
    a, b, d = map(Fraction, (a, b, d))
    if d <= 0 or a * d <= b * b:
        raise ValueError('The symmetric quadratic form must be positive definite')
    return 1 / (a - b * b / d)


def receiver_probabilities(dimension, probability):
    p = Fraction(probability)
    if not isinstance(dimension, int) or dimension < 2 or not 0 <= p <= 1:
        raise ValueError('Require integer dimension >= 2 and 0 <= probability <= 1')
    spectrum = [p] + [(1-p)/(dimension-1)] * (dimension-1)
    return {'dimension': dimension, 'probe_probability': str(spectrum[0]),
            'trace': str(sum(spectrum)), 'nonnegative': all(x >= 0 for x in spectrum)}


def main():
    counts10 = retained_records(10, 3)
    counts4 = retained_records(4, 3)
    geometry = refinement(8, 0.5)
    coupled = susceptibility(2, 1, 2)
    uncoupled = susceptibility(2, 0, 2)
    receivers = [receiver_probabilities(137, p) for p in (Fraction(1,137), Fraction(1,2), Fraction(9,10))]
    theta = math.pi / 6
    phase = math.pi / 2
    transition = math.sin(2 * theta)**2 * math.sin(phase)**2
    result = {
        'scope': 'Reproducible toy calculations with explicitly chosen inputs; no empirical fit or new physical constant is asserted.',
        'retention_grammar': {'depth':3, 'q10':counts10, 'q4':counts4},
        'geometry_and_clocks': {'branching':8, 'contraction':0.5, **geometry},
        'static_response': {'coupled_matrix':[[2,1],[1,2]], 'coupled_susceptibility':str(coupled), 'uncoupled_matrix':[[2,0],[0,2]], 'uncoupled_susceptibility':str(uncoupled)},
        'same_dimension_different_preparations': receivers,
        'two_flavour_phase_example': {'mixing_angle_radians':theta, 'oscillation_phase_radians':phase, 'transition_probability':transition, 'survival_probability':1-transition},
        'checks': {
            'grammar_counts': counts10 == [0,1,13,137] and counts4 == [0,1,7,35],
            'clock_ratios': math.isclose(geometry['counting_exponent'],3) and math.isclose(geometry['alternative_clock_ratio'],0.75),
            'response_values': coupled == Fraction(2,3) and uncoupled == Fraction(1,2),
            'normalized_receiver_states': all(r['trace']=='1' and r['nonnegative'] for r in receivers),
            'oscillation_probability': math.isclose(transition,0.75) and 0 <= transition <= 1,
        }
    }
    print(json.dumps(result,ensure_ascii=False,indent=2))
    if not all(result['checks'].values()): raise SystemExit('A benchmark check failed')


if __name__ == '__main__': main()

Continue on SMONAD

• Worked mathematical derivations →

  Read the site’s worked mathematical derivations.

• Geometry and clocks →

  Explore independently varied clock and geometric inputs.

• Receiver response →

  Compare structural counts with selected response operators.

• Open problems and research targets →

  Follow the remaining source-dynamics targets.