The Mala Knot Lab

Check it yourself

The quantum results on the findings page come with a replication package: a protocol that defines the model and four tests exactly and asks for specific numbers, a script that implements it, and the answer key. The protocol was written so that someone who has never seen our results can produce their own and then compare. One replication has been run this way, by a second AI system working from the protocol alone.

Method

How to run it blind

Give only the protocol to a person or a system: not this site, not the script, not the answer key. Ask for every quantity marked ▶, the software and method used, and one sentence per test on what the numbers show, written before any comparison. Then open the answer key and compare at the tolerances below. Implementing the model independently from the description is the stronger check; running our script is the quicker one.

If you are the replicator, do not open the answer key until you have your own numbers.

Files

The package

  • replication-protocol.md
    The protocol: the model and four tests, defined exactly. No results, no predictions.
  • replicate_mala_tests.py
    A script that implements the protocol (Python 3 and NumPy, about six seconds). It contains no expected values.
  • experiment-1-two-places.py
    The original Experiment 1 run, with its figure.
  • experiment-2-four-tests.py
    The original Experiment 2 run, which produced the answer key.
  • answer-key.json
    The answer key. A blind replicator should not open it until they have their own numbers. It was kept private during the blind run and is published now, unaltered.

To run the script: python3 replicate_mala_tests.py prints its results as JSON.

Tolerances

What counts as the same number

Test 1maximum of P_empty at each phasewithin 1 × 10⁻⁶
Test 2largest gap between F and F₄·F₂₇below 1 × 10⁻¹²
Test 3quantum and classical spreadswithin 1 × 10⁻⁶ (see the note below)
Test 4lowest P_start for each splitwithin 1 × 10⁻⁵
Test 4frequency counts for 54, 108, the 7-cycle and the 16-cycleequal
Test 4frequency count for the 9-cycle of 10087 or 9

The site checks itself against the same table: on every change, a test reruns the script and compares it with the answer key. The 9-cycle count is allowed to be 7 or 9 because the protocol leaves the weighting method open, and the one independent replication found 7 where our run finds 9.

One correction to the key. Its classical spread at t = 20, 6.3245414, was read off a 120-point time grid by linear interpolation; the exact value is √40 = 6.3245553, a difference of 1.4 × 10⁻⁵. A careful replication will disagree with the key there by that much, and should: the key is wrong in the fifth decimal place, not the replication. The key is published unaltered, and the site’s own test checks that spread against √40 instead.

The Protocol

Exactly what the replicator was given

Shown verbatim, as it was handed over.

# Replication protocol: quantum tests on the 108-bead (4, 27) network

This is a blind replication package. It defines a model and four tests exactly, and asks for
specific numbers. It deliberately contains **no results and no predictions**. Run it, report
the numbers, and compare against the answer key held separately.

You may run the attached script `replicate_mala_tests.py` (Python 3, NumPy only), or
implement the model independently from this description. Independent implementation is the
stronger check.

---

## 1. The model

**Sites.** N = 108 sites, indexed k = 0 … 107, arranged in a closed ring (site 107 is
adjacent to site 0). Sites are referred to as "beads"; bead number = k + 1.

**Hamiltonian.** A single particle hops between sites. The Hamiltonian is a real symmetric
108 × 108 matrix H built from up to three "hopping rules", each with a strength t ≥ 0:

- **thread** (step 1): connects k to k + 1 and k − 1 (mod 108)
- **squares** (step 27): connects k to k + 27 and k − 27 (mod 108)
- **rings** (step 4): connects k to k + 4 and k − 4 (mod 108)

For each active rule with strength t and step s: `H[k, (k+s) mod 108] -= t` and
`H[k, (k−s) mod 108] -= t` for every k. All diagonal entries are 0. (Note: if two rules map
to the same neighbour, contributions add.)

**Dynamics.** The state ψ is a complex vector of length 108, normalised to 1. It evolves by
the Schrödinger equation with ħ = 1:

    i dψ/dt = H ψ        ⇒        ψ(t) = exp(−i H t) ψ(0)

Use exact diagonalisation (H is real symmetric) or any integrator accurate to better than
1e-6 over the times below.

**Probability** at site k is |ψ_k|².

**Initial states used.** A "delta" at site k means ψ_k = 1, all others 0, then normalise.

---

## 2. The four tests

Report every quantity marked ▶ to at least 4 significant figures.

### Test 1 — Relative phase between two places

- Hopping: squares only, t = 1 (thread 0, rings 0).
- Initial state: ψ_0 = 1, ψ_54 = e^{iφ}, all others 0, then normalise.
- For each φ ∈ {0°, 45°, 90°, 135°, 180°}, evolve from t = 0 to t = 4.
- ▶ Report **max over t of P_empty(t)**, where P_empty(t) = |ψ_27(t)|² + |ψ_81(t)|².
- ▶ Also report, for φ = 0°, the time of the first maximum of P_empty and its value.

### Test 2 — Factorisation of the network

- Hopping: squares t = 1 AND rings t = 1 (thread 0).
- Initial state: delta at site 0.
- Compute the return probability F(t) = |⟨ψ(0)|ψ(t)⟩|² for t from 0 to 4π (use ≥ 1500
  evenly spaced samples).
- Separately, define two smaller systems:
  - a 4-site ring with nearest-neighbour hopping t = 1 (H4[k,(k±1) mod 4] = −1),
    delta start at site 0, return probability F4(t);
  - a 27-site ring with nearest-neighbour hopping t = 1, delta start at site 0,
    return probability F27(t).
- ▶ Report **max over t of |F(t) − F4(t)·F27(t)|**.
- ▶ Report F(t) at t = π, 2π, 3π, 4π.

### Test 3 — Quantum walk versus classical walk

- Hopping: thread only, t = 1.
- Quantum: delta at site 0; evolve to t = 25. Define the spread
  σ_q(t) = sqrt( Σ_k |ψ_k(t)|² · d_k² ), where d_k = min(k, 108 − k) is the ring distance
  from site 0.
- Classical: a continuous-time random walker on the same ring, starting at site 0, hopping
  to each neighbour at rate 1: dp/dt = L p with L[k,(k±1)] = +1, L[k,k] = −2. Define
  σ_c(t) the same way using p_k(t).
- ▶ Report σ_q and σ_c at t = 5, 10, 20.
- ▶ State whether σ_q grows linearly in t or as a square root, and the same for σ_c,
  and give the fitted constant (σ ≈ a·t or σ ≈ a·√t).

### Test 4 — Other bead counts

For each N ∈ {27, 54, 108, 1008}:

- List every way to write N = p × q with 2 ≤ p ≤ q and gcd(p, q) = 1 ("coprime splits").
- For each split, build an N-site ring with a single hopping rule of step q and strength 1
  (this joins the sites into p-cycles).
- Initial state: ψ_a = 1 at a = 0 and ψ_b = 1 at b = (⌊p/2⌋ · q) mod N, normalised. If
  b = a (which happens when p = 1 — not applicable here — or by coincidence), use the delta
  at a alone.
- Evolve from t = 0 to t = 12 with ≥ 1000 samples. Define P_start(t) = |ψ_a|² + |ψ_b|²
  (just |ψ_a|² if b = a).
- ▶ Report, per split: **min over t of P_start(t)**.
- ▶ Report, per split: **the number of distinct oscillation frequencies present in
  P_start(t)** that carry more than 1% of the total oscillating weight. (Any reasonable
  method is acceptable — e.g. from eigenvalue differences of H weighted by the initial-state
  overlaps, or a spectral analysis of P_start(t) with leakage handled. State your method.)
- If N has no coprime split, say so.

---

## 3. What to hand back

A table or JSON with every ▶ quantity, plus one sentence per test stating what the numbers
show, written before looking at any answer key. Please also state: the software used, the
integration method, and the time step or sample count.

## 4. Things that must NOT be in the report

- No numbers taken from any prior discussion of this model.
- No geometry: the 3D shape of the "thread" (torus, lotus, etc.) does not appear in the
  model and must not be used. Only the hopping rules above define H.

Hardware

Run it on a quantum computer

The square qubit on the findings page was also run on a real IBM quantum processor. This is a separate check from the protocol above: it writes one four-bead square as two qubits and tests the same prediction, cos²(φ/2)·sin²(2t), on a machine instead of in a simulation.

You need Python 3.10 or newer and pip install qiskit qiskit-ibm-runtime matplotlib numpy; our run used qiskit 2.5.2 and qiskit-ibm-runtime 0.49.0. Then:

  • python square_qubit_ibm.py --selfcheck
    Checks the two-qubit encoding with NumPy alone. The largest error should be near 10⁻¹⁶.
  • python square_qubit_ibm.py --ideal
    Runs the circuits on Qiskit's simulator. No account, no machine time.
  • python square_qubit_ibm.py --hardware
    Runs them on the least busy IBM machine your account can reach. Add --backend and a machine name to choose one.

An IBM Quantum Open plan account is free. Save your own key once, in your own terminal, as the script’s header shows. The whole run uses about 30 seconds of the plan’s 10 minutes of machine time a month. Each run writes a results file and a plot next to the script.

What to expect: perfect state transfer of roughly 0.90 to 0.98, depending on the machine and the day; the 0° curve peaking near t = π/4; and the 180° row a few hundredths above zero rather than at zero, which is the machine’s own error. Ours, on ibm_kingston, was 0.9815, at the top of that range, with a 0° peak of 0.9890 and a 180° mean of 0.0126. A result well outside that range is worth reporting to us at connect@dogma.guru.

The run above checks the square qubit on its own. The geometry question, whether the transfer survives on a real winding of the knot, is answered by a 108 × 108 computation instead: experiment-3-leak-geometry.py and its data, leak-test-geometry.json. No quantum hardware is needed for it.

Back to the findings or the lab.