# Quantum information: frozen numerical experiment

This browser experiment tests a specified implementation of a finite unitary system–environment model. It does not test whether fundamental physics destroys information. Pure initial states and unitary joint evolution are assumptions of the experiment.

## Run and decision

1. Select pairs, initial-state count, interaction-grid size, seed and control mode.
2. Freeze criteria. The complete protocol and SHA-256 are stored locally before calculation. Changed parameters require a new protocol record referencing the previous hash.
3. Run. A solver calculates the observations. A separate Worker receives the frozen inputs, compact state representation and numerical observations, without the solver's conclusion.
4. Inspect independent numerical checks. A disagreement blocks commitment. Failed or cancelled tasks remain diagnostics; they do not become supported claims.
5. Select **Commit evidence** to atomically save the signed result, verification and graph relationships. Export the signed bundle for retention and separate verification.

Local registration does not provide independently witnessed timing, blockchain registration or tamper-proof storage. Browser storage can be cleared. The signed lifecycle binds content and local event order; it does not attest a real-world identity, execution time or scientific truth. The generic Runtime also exposes this fixed recipe; there its normal automatic commit follows successful checks. The dedicated experiment page adds explicit review before commitment.

## Model and data representation

There are n independent pairs, with 1 ≤ n ≤ 6. Each pair consists of one system qubit and one environment qubit. Initially:

`|Psi_j> = (a_j|0> + b_j|1>)_S ⊗ |0>_E`.

The interaction is controlled-RY(theta):

`H_j = (hbar g / 2) |1><1|_S ⊗ Y_E`, `theta = g t`.

The environment is not reset. No cross-pair interaction is present. Theta is dimensionless; the interface does not infer calibrated seconds or a physical coupling rate. The default uses 32 initial states and 33 angles from 0 to 2π, for **1,056 calculated configurations**. These are not independent laboratory observations. The balanced initial state is an explicit calibration control; remaining states follow the frozen seeded generator.

Raw exports contain the initial complex amplitudes, binary64 rotation blocks and all observation rows in declared order. Pair vectors are reconstructed as:

`[a, 0, b cos(theta/2), b sin(theta/2)]`, in basis `|00>, |01>, |10>, |11>`.

Their tensor product specifies the full joint state. This compact factorization is explicit: it is not a stored arbitrary 12-qubit dense trajectory or an instrument measurement.

## Observables and information accounting

Von Neumann entropy uses base-2 logarithms:

`S(rho) = -Tr(rho log2 rho)`.

Reduced density matrices are obtained by partial trace. Mutual information is:

`I(S:E) = S(rho_S) + S(rho_E) - S(rho_SE)`.

For a pure joint state, `S(rho_SE)=0`, `S(rho_S)=S(rho_E)` and `I=2S(rho_S)`. Joint entropy zero follows from the pure-state representation; normalization and purity residuals test numerical consistency with it.

Define the entropy deficit `J_X=log2(dim X)-S(rho_X)`. The exact budget is:

`J_SE = J_S + J_E + I(S:E)`.

For six pairs: `12 = (6-S_S) + (6-S_E) + I`. Both local deficits can decrease while correlations increase. Mutual information is not equal to the loss of the system deficit alone and is not a universal measure of recoverable messages.

## Verification and controls

The solver constructs complex pair vectors, forms each reduced matrix separately, and calculates its 2×2 eigenvalues. The verifier uses an independent determinant-spectrum formulation and checks every raw observation, initial amplitude and rotation block against the frozen design. Both implementations share a specification and browser, so this is computational verification rather than independent laboratory replication.

Frozen criteria include normalization/purity, reduced-state positivity, entropy bounds, information budget, equality of marginal entropies, inverse evolution, zero-coupling and pointer-state controls, recurrence, agreement of implementations, gate subdivision and binary32 sensitivity. Exact thresholds and coverage are exported in the protocol. No probability of truth or p-value is assigned.

Splitting an exact gate into 2 or 8 substeps checks gate composition. It is not a convergence study for an ODE or a noncommuting many-body Hamiltonian.

At theta=2π the marginal entropies return to zero, but the system undergoes a local Z operation. The balanced input can be orthogonal to its initial state despite equal zero entropy. Full state recurrence occurs at 4π. The recorded initial-state fidelity and recurrence control distinguish these situations. Finite-environment revival should not be presented as universal monotonic Markov decoherence.

A successful coherent-mode result may be committed as `SUPPORTED_WITHIN_TESTED_MODEL`. Control modes produce `NO_DECOHERENCE_CONTROL`. A failed numerical check is diagnostic evidence; it is not experimental proof of a nonunitary law of nature.

## Separate full-state verifier

Download `/downloads/zeroexternal-quantum-verifier.zip`. The Python/NumPy verifier evolves the full statevector, forms reduced density matrices, and compares selected configurations against the exported observations. Its report states exact coverage; its default subset is not the entire sweep. Use the documented option for all configurations. The script validates the frozen protocol hash, but does not authenticate the browser's signature or witness its registration time.

No quantum device, external LLM, container or laboratory is automatically connected. The shared account gateway currently accepts the observer-projection recipe; quantum experiment bundles are exported separately.

## Primary references

- IBM Quantum information API: entropy, mutual information, purity and partial trace. https://quantum.cloud.ibm.com/docs/en/api/qiskit/quantum_info
- IBM Quantum Learning, multiple systems and reduced states. https://quantum.cloud.ibm.com/learning/en/courses/general-formulation-of-quantum-information/density-matrices/multiple-systems
- Breuer, Laine, Piilo and Vacchini, Non-Markovian dynamics in open quantum systems. https://arxiv.org/abs/1505.01385

The controlled-RY protocol, entropy-budget algebra and acceptance design here are calculations and implementation choices for this Runtime; they are not new experimental findings attributed to those sources.