Design 128 Noisy Shallow-Circuit Measurements for Anonymous Quantum States

Design a 128-shot measurement schedule for 300 weighted Pauli observables on anonymous 36-qubit states. The hidden states are drawn from a mixture of disordered 1D TFIM and disordered anisotropic 1D XYZ ground states. Their state representations, Hamiltonian parameters, family labels, and exact hidden expectations are never exposed to your code.

This is a measurement-design task. Your submission chooses physical measurements only. The trusted verifier owns the estimator and computes the final MSE, so prediction shrinkage, clipping, target lookup, and learned output substitution are outside the submission interface.

Measurement model

One shot is a shallow brickwork Clifford circuit, then a single-qubit basis rotation and a Z-readout on every qubit:

• gates: int array [D_MAX=3, N_BRICKS=18]. Even layers pair qubits (0,1),(2,3),...; odd layers pair (1,2),(3,4),... (their last column is ignored). Gate codes: 0 II, 1 CZ, 2 SWAP, 3 CNOT(left→right), 4 CNOT(right→left). All-zero rows mean unused depth; a fully zero gates array is an ordinary product-Pauli measurement.
• bases: int array [36], final measurement basis per qubit, 0:X 1:Y 2:Z.

With V = R U (U = entangling layers in order, R = basis rotations), qubit q reports the eigenvalue of V† Z_q V. An observable P is readable in a shot iff V P V† is a ±Z-string; its measured eigenvalue is the signed product of the readout bits on that string's support. Use data_utils.conjugate_pauli to work out what a given (gates, bases) shot reads.

Noise model (public, applied by the verifier)

• After every non-identity brick, with probability P2 = 0.01 a uniformly random non-identity two-qubit Pauli hits that pair (quantum-trajectory depolarizing).
• Every readout bit flips independently with probability P_RO = 0.015.
• Basis rotations are noiseless.

The fixed estimator does not correct for this noise. The public transcripts were sampled under exactly this model.

Required API

Modify /app/methods/main/solver.py. Keep a class named Solver with:

fit(
    train_ids,
    train_gates,        # [100, 128, 3, 18] transcript circuits
    train_bases,        # [100, 128, 36]
    train_outcomes,     # [100, 128, 36] readout bits (0 -> +1, 1 -> -1)
    train_targets,      # [100, 300] exact values of c_k * <P_k>
    observable_paulis,  # [300, 36] codes 0:I 1:X 2:Y 3:Z
    observable_coefficients,  # [300]
)

design(
    instance_ids,
    observable_paulis,
    observable_coefficients,
    n_shots,            # == 128
) -> (gates, bases)

fit() may be a no-op. design() must return integer arrays gates [n_states, S, 3, 18] and bases [n_states, S, 36] with 1 <= S <= n_shots. Schedules may be shared across states or state-specific. Return the actual gate/basis arrays — there is no catalog to index into. There is deliberately no predict(): outcomes are sampled only after your process has committed its design and exited, and are never sent back.

Fixed estimator and coverage

For each state and observable the verifier averages the measured eigenvalues over the shots where the observable is readable and multiplies by the coefficient. Every state-observable pair must be readable in at least one shot; a design leaving even one hidden pair unreadable is invalid. This prevents obtaining a low MSE by deliberately omitting an observable and falling back to zero. Re-check coverage after every edit to the shots, and verify readability with data_utils.conjugate_pauli rather than assuming qubit-wise matching.

Public data

• /app/data/observables.npz: pauli_strings, coefficients, weights, labels.
• /app/data/train.npz: 100 opaque states — transcript circuits (gates, bases), noisy readout outcomes, and exact targets.
• /app/data/visible.npz: 20 disjoint states with the same fields, for local evaluation.
• /app/data_utils.py: the exact compatibility rule, the verifier's estimator, design validation, and loaders — use it to evaluate candidate designs on the public transcripts.

python /app/selfcheck.py validates your API, enforces coverage on the visible IDs, and reports transcript diagnostics. It cannot measure any state in newly proposed circuits.

Hidden protocol

Scoring runs on sealed states you never see. Your process receives public data and fresh opaque hidden IDs, commits (gates, bases), and exits. Only after that are your circuits simulated under the noise model and the fixed estimator applied; outcomes are never sent back. Train, visible, and hidden splits are disjoint and drawn from the same N=36 distribution.

Opaque instance ids carry no information about family or Hamiltonian parameters.

Metric

For each hidden family and each Pauli weight in {2,3,4,5,6,8} the verifier computes one MSE cell; the score is the mean of the 12 cells (lower is better). Macro-averaging prevents the numerous weight-2 observables from dominating.