Quantum autoencoder for pure-state compression
Domain: quantum (quantum-machine-learning, generative-models, autoencoders)
Topic: Quantum autoencoder for pure-state compression: training a parameterized circuit to compress n-qubit Haar-random states into m<n latent qubits via SWAP-test loss, measuring reconstruction fidelity vs compression ratio
Venue: ARC-Bench 2026
Headline metric: reconstruction_fidelity (maximize)

Research briefing:
A quantum autoencoder takes an n-qubit quantum state, applies a
parameterized circuit that disentangles the information onto a
smaller subset of m < n "latent" qubits, and traces out the
remaining n - m "trash" qubits. The latent qubits are then expanded
back to n qubits via a fresh ancilla register and a decoder circuit
(typically the conjugate of the encoder). Training optimizes the
encoder so the trash qubits end in the |0> state (verified via a
SWAP test against fresh |0> ancillas), which is equivalent to
maximizing the fidelity between the reconstructed state and the
original input state.

The training data is an ensemble of input states drawn from some
distribution. If the ensemble is concentrated in a low-dimensional
manifold of the 2^n Hilbert space, the autoencoder can in principle
reach near-perfect reconstruction at significant compression (m <
n). If the ensemble is Haar-random pure states, no compression is
achievable in principle and the average reconstruction fidelity is
upper bounded by 2^(m-n) (the latent space is too small to hold a
generic state).

The empirical question this topic addresses is what compression
fidelity is achievable on a small Haar-random ensemble at a few
compression ratios, and whether the trained autoencoder
meaningfully beats a random-unitary baseline (which represents the
null hypothesis: a random encoder cannot do better than chance).
This is the cleanest possible test of "does the autoencoder learn
anything" without confounding from structured ensembles.

Implementation guidance is provided by the quantum-qiskit skill at
stage 10. The encoder and decoder are EfficientSU2(num_qubits=n,
reps=3, entanglement='linear') circuits built from
qiskit.circuit.library. The SWAP-test loss is implemented manually
via auxiliary qubits and a Hadamard-controlled-SWAP-Hadamard pattern.
Use qiskit.primitives.StatevectorSampler for the SWAP-test
measurement and qiskit.primitives.StatevectorEstimator for the
reconstruction-fidelity diagnostic. Training uses
qiskit_algorithms.optimizers.COBYLA.minimize() over the SWAP-test
loss (DO NOT use qiskit_algorithms.VQE — see the quantum-qiskit
skill's note about qiskit 2.x compatibility).

Experimental protocol. Three quantum compression conditions probe
the compression-fidelity tradeoff: compress 4 qubits -> 2 latent,
compress 4 -> 3, compress 6 -> 3. Two no-skill baselines establish
the floor: no_compression (identity encoder, m=n, fidelity should
be ~1.0) and random_unitary_compression (encoder parameters drawn
randomly and never trained). Test data is an ensemble of 20
Haar-random pure states per seed. Each (condition, seed) cell
reports the mean reconstruction fidelity over the 20 test states.
Total: 5 conditions x 1 ensemble x 3 seeds = 15 cells.

Research question: *On an ensemble of Haar-random pure states, what
reconstruction fidelity does a trained quantum autoencoder achieve
at compression ratios 4->2, 4->3, and 6->3, and how much better is
it than an untrained (random-unitary) encoder at the same
compression ratio?*

Hypotheses:
statement: The trained autoencoder achieves reconstruction fidelity at least 0.2 absolute higher than a random-unitary encoder at the same compression ratio (3-seed mean across the 20 Haar test states), on at least 2 of 3 compression-ratio conditions, confirming that training extracts non-trivial structure from the Haar ensemble., statement: Trained reconstruction fidelity is strictly monotone in latent dimension: the 4->3 condition achieves fidelity at least 0.15 higher than the 4->2 condition (3-seed mean), as expected from the Hilbert-space capacity argument 2^m / 2^n., statement: The no_compression baseline (identity encoder, m=n) achieves reconstruction fidelity at least 0.95 (3-seed mean), confirming the experimental setup is correctly implemented — the trash-qubit register is non-functional when m=n and the test pipeline should report near-perfect fidelity.

Experiment design:
research_question: On an ensemble of Haar-random pure states, what reconstruction fidelity does a trained quantum autoencoder achieve at compression ratios 4->2, 4->3, 6->3, and how much better is it than an untrained encoder at the same compression?
conditions: name: compress_4_to_2
description: Encoder: EfficientSU2(num_qubits=4, reps=3, entanglement='linear'). After applying the encoder, qubits 2 and 3 are the 'trash' register and the SWAP test against fresh |0> ancillas is summed into the loss. Latent qubits: 0, 1. Decoder is the inverse encoder. Training: 100 iterations of qiskit_algorithms.optimizers.COBYLA(maxiter=100).minimize() on a fixed batch of 5 Haar-random states drawn once per seed., name: compress_4_to_3
description: Same as compress_4_to_2 but with 1 trash qubit (qubit 3) and 3 latent qubits (0, 1, 2). Easier compression task., name: compress_6_to_3
description: Encoder: EfficientSU2(num_qubits=6, reps=3, entanglement='linear'). 3 trash qubits (3, 4, 5) and 3 latent qubits (0, 1, 2). Harder compression task (50 percent compression on a larger Hilbert space).
baselines: no_compression: Encoder is the identity circuit (no parameters). All qubits are latent (m=n); no trash qubits. The SWAP test trivially passes and reconstruction fidelity equals 1.0 exactly. Sanity check on the eval pipeline., random_unitary_compression: Same EfficientSU2 ansatz as the trained conditions, but parameters drawn randomly from Uniform[-pi, pi] once per seed and NEVER trained. Establishes the no-skill floor — represents 'what if the encoder is just random noise'.
metrics: name: reconstruction_fidelity
direction: maximize
description: Mean of |<psi_input|psi_reconstructed>|^2 over the 20 Haar-random test states, 3-seed mean. Primary metric. Computed as 1 - SWAP_test_probability_of_outcome_1 averaged over the trash qubits, OR via direct Statevector inner product when running on the noiseless simulator., name: swap_test_loss
direction: minimize
description: Training loss at the final iteration. Sum over the m trash qubits of P(SWAP_test_outcome=1) on each. Equivalent to 1 - average_trash_qubit_fidelity_with_|0>., name: training_time_sec
direction: minimize
description: Wall-clock seconds for the 100 COBYLA iterations of training. Reported for context — the compression task should fit well under 60 seconds per cell.
datasets: name: haar_random_states_n4
source: qiskit.quantum_info.random_statevector(2**4, seed=ensemble_seed) — generate 20 Haar-random 4-qubit pure states with a fixed per-seed ensemble seed
description: An ensemble of 20 Haar-random 4-qubit pure states (for compress_4_to_2 and compress_4_to_3 conditions). A separate Haar ensemble of 20 6-qubit states is generated for the compress_6_to_3 condition. Training uses a fixed batch of 5 of these states; testing uses all 20. The ensemble is fully unstructured by construction, so any non-trivial reconstruction fidelity above the random-unitary baseline reflects the autoencoder learning a structured compression rule on Haar states.
compute_requirements: gpu_required: no
estimated_wall_clock_sec: 1200

Requirements:

Scoring rubric:
requirements: An empirical study of a quantum autoencoder on Haar-random pure states. The agent must (a) construct encoder + decoder circuits as EfficientSU2(reps=3) from qiskit.circuit.library, (b) implement the SWAP-test loss via auxiliary qubits + Hadamard-controlled-SWAP-Hadamard or compute trash-qubit fidelity-to-|0> directly via Statevector, (c) train each compression-ratio condition by qiskit_algorithms.optimizers.COBYLA.minimize() on a fixed batch of 5 Haar states per seed, (d) evaluate on 20 unseen Haar states reporting reconstruction_fidelity, and (e) score H1/H2/H3 with numerical evidence.
judging_note: Quantum autoencoder studies are scored on (i) correctness of the SWAP-test or fidelity computation (verifiable: no_compression baseline must report fidelity ~1.0, otherwise the eval pipeline is broken), (ii) the random_unitary_compression baseline producing fidelity in the expected range for that compression ratio (theoretical floor is 2^(m-n) per Page formula, e.g. for 4->2 the random baseline fidelity is around 0.0625), (iii) the trained conditions being measurably above the random baseline (otherwise no learning), and (iv) numerical evidence for the latent-dimension capacity effect (4->3 better than 4->2).
sub_tasks: requirements: Code-development bucket: encoder/decoder built from qiskit.circuit.library, SWAP-test or direct-fidelity loss implemented correctly, training pipeline runs.
sub_tasks: requirements: Encoder is qiskit.circuit.library.EfficientSU2(num_qubits=n, reps=3, entanglement='linear'). Decoder is the inverse of the encoder (via QuantumCircuit.inverse()) sharing the same parameters but acting in reverse, applied after fresh |0> ancillas have replaced the trash qubits. Both encoder and decoder are built once from qiskit.circuit.library — NOT hand-coded as H/RY/RZ + CNOT stacks (the quantum-qiskit skill warns against this anti-pattern).
task_category: Code Development
finegrained_task_category: Method Implementation, requirements: Training loss is implemented as either (a) a SWAP-test circuit using auxiliary qubits and the standard Hadamard-controlled-SWAP-Hadamard pattern, OR (b) a direct Statevector computation: trace out the trash register, compute its partial-trace overlap with |0><0|, and sum across trash qubits. Both implementations are valid. The reconstruction_fidelity metric on the test set uses |<psi_input|psi_reconstructed>|^2 computed via qiskit.quantum_info.Statevector inner product (no SWAP test needed at evaluation since we have access to both states).
task_category: Code Development
finegrained_task_category: Method Implementation, requirements: Training: 100 iterations of qiskit_algorithms.optimizers.COBYLA.minimize() over the SWAP-test loss, summed over a fixed batch of 5 Haar-random states drawn once per (condition, seed) pair via qiskit.quantum_info.random_statevector. Evaluation: 20 fresh Haar-random states drawn from a different RNG stream than the training batch. Each cell logs METRIC_RESULT JSON with condition, seed, reconstruction_fidelity_mean (over 20 test states), swap_test_loss_final, training_time_sec.
task_category: Code Development
finegrained_task_category: Experimental Setup, requirements: Execution-validity bucket: all 15 cells ran with valid outputs.
sub_tasks: requirements: At least 14 cells out of 15 expected (5 conditions x 1 ensemble x 3 seeds) completed without unhandled errors and produced a reconstruction_fidelity_mean value. Missing more than 1 cell without documented justification fails this leaf.
task_category: Code Execution
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: Numerical validity: reconstruction_fidelity is in [0, 1] for every cell; the no_compression baseline reports fidelity in [0.95, 1.0] (else eval pipeline is broken); the random_unitary_compression baseline for 4->2 reports fidelity in [0.04, 0.15] (matching the theoretical 2^(m-n) = 0.0625 average for Haar states); no cell reports identical fidelity across all 3 seeds (would indicate the Haar sampler is not actually randomizing per seed).
task_category: Code Execution
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.
sub_tasks: requirements: Quantitative test of H1. On at least 2 of 3 compression-ratio conditions, is trained reconstruction_fidelity >= random_unitary_compression reconstruction_fidelity + 0.2 absolute (3-seed mean)? 100% if gap >= 0.2 on at least 2/3 conditions, 67% if gap >= 0.1 on at least 2/3, 33% if any positive gap on at least 1, 0% if random unitary equals or beats trained on all 3.
task_category: Result Analysis
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: Quantitative test of H2. Is reconstruction_fidelity(compress_4_to_3) - reconstruction_fidelity(compress_4_to_2) >= 0.15 absolute (3-seed mean)? 100% if gap >= 0.15, 67% if 0.05-0.15, 33% if any positive gap (capacity effect at least directionally correct), 0% otherwise.
task_category: Result Analysis
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: Quantitative test of H3. Does no_compression baseline report reconstruction_fidelity >= 0.95 (3-seed mean)? 100% if >= 0.95, 67% if >= 0.85, 33% if >= 0.70, 0% otherwise — failure of this sanity check means the eval pipeline is misconstructed.
task_category: Result Analysis
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: Writeup of at least 200 words (submission/README.md ## Agent-produced writeup section) with explicit supported / refuted / inconclusive verdict for each of H1/H2/H3 backed by 3-seed mean reconstruction_fidelity per condition. References Romero, Olson, Aspuru-Guzik Quantum Sci Tech 2017 and discusses whether the trained autoencoder's advantage over random_unitary_compression on Haar-random data is consistent with the Page-formula expectation (Haar states have no exploitable structure, so any improvement reflects the optimizer finding a non-trivial subspace).
task_category: Result Analysis
finegrained_task_category: Logging, Analysis & Presentation