| {: , : , : , : , : [, , ], : null, : , : , : , : false, : 1800, : , : 3, : id\H1\statement\The best of the three quantum encodings (5-seed mean) achieves test_accuracy within 5 absolute percentage points of the BETTER of the two classical baselines (logistic_regression and mlp_classifier, 5-seed means) on synthetic_classification_6d.\measurable\id\H2\statement\The spread of test_accuracy across the three quantum encodings (max minus min of the 5-seed means) is at least 5 absolute percentage points, demonstrating that encoding choice produces a measurable effect rather than a wash.\measurable\id\H3\statement\zz_feature_map test_accuracy (5-seed mean) is at least as high as angle_encoding test_accuracy (within 2 absolute percentage points or higher), consistent with the conjecture that entanglement-rich input encoding does not hurt and may help on this task.\measurable\, : research_question\On a moderately difficult 6D binary classification task, does the choice of quantum data encoding (angle, amplitude, ZZ feature map) measurably change variational classifier accuracy, and does at least one encoding approach the classical baseline?\conditions\name\angle_encoding\description\qiskit.circuit.library.ZFeatureMap(feature_dimension=6, reps=1) as the data encoding circuit. Each feature x_i is loaded as H followed by RZ(x_i) on qubit i. No entangling gates in the feature map.\name\amplitude_encoding\description\qiskit.circuit.library.StatePreparation on the L2-normalized, zero-padded input vector (length 64 = 2**6) as the data encoding circuit. Implementation: x_normalized = x / ||x||; x_padded = np.concatenate([x_normalized, np.zeros(64 - 6)]); StatePreparation(x_padded). The padded state is unit norm by construction.\name\zz_feature_map\description\qiskit.circuit.library.ZZFeatureMap(feature_dimension=6, reps=2, entanglement='linear') as the data encoding circuit. Two repetitions of H + RZ(x_i) on each qubit + RZZ(x_i * x_j) on linear nearest-neighbor pairs.\baselines\logistic_regression: sklearn.linear_model.LogisticRegression(max_iter=1000) on the same 6D features.\mlp_classifier: sklearn.neural_network.MLPClassifier(hidden_layer_sizes=(16,), activation='relu', solver='adam', max_iter=500, random_state=seed) on the same 6D features.\Both baselines reported per seed; both contribute to the H1 comparison (the BETTER of the two is the reference). Neither contributes to the primary quantum_test_accuracy_mean metric.\metrics\name\quantum_test_accuracy_mean\direction\maximize\description\Primary metric. Mean of the 5-seed test_accuracy means across the THREE quantum encodings ONLY. The classical baseline is reported separately and does NOT contribute to this metric. This isolates the refinement signal from the baseline.\name\test_accuracy\direction\maximize\description\Per-condition mean accuracy on the 20% held-out test split, averaged over 5 random seeds. Reported per condition (angle, amplitude, zz_feature_map, logistic_regression).\name\best_baseline_accuracy\direction\maximize\description\max(logistic_regression_5seed_mean, mlp_classifier_5seed_mean). Used as the reference point in H1 (the stronger of the two classical baselines).\datasets\name\synthetic_classification_6d\source\sklearn.datasets.make_classification\description\make_classification(n_samples=400, n_features=6, n_informative=4, n_redundant=1, n_repeated=0, n_clusters_per_class=2, class_sep=0.4, flip_y=0.05, random_state=seed). class_sep is set to 0.4 (not 1.0) so the LogisticRegression baseline lands around 0.65-0.80 instead of saturating near 1.0, leaving headroom for the quantum encodings to differ. Apply StandardScaler fit on the train split only. 80/20 train/test split.\compute_requirements\gpu_required\estimated_wall_clock_sec\, : , : id\q01-root\requirements\A minimal pilot study comparing three quantum data encoding strategies (angle, amplitude, ZZ feature map) for a variational quantum classifier on ONE moderately difficult 6D binary classification dataset (synthetic_classification_6d with class_sep=0.4). The agent must (a) implement all three encodings as drop-in feature maps for a shared 6-qubit EfficientSU2 ansatz, (b) train each (encoding, seed) cell using qiskit_machine_learning.algorithms.VQC + COBYLA over 5 random seeds, (c) report test accuracy per quantum cell and a classical logistic_regression baseline on the same data, and (d) produce a writeup that assigns supported / refuted / inconclusive verdicts to H1, H2, H3 with numerical evidence.\judging_note\Quantum ML pilots are scored on (i) whether all three encodings are implemented per qiskit convention, (ii) whether ansatz / optimizer / simulator are held fixed across encodings so the encoding axis is isolated, (iii) whether the quantum cells produce non-trivial accuracy (not near 0.5 random for all 3 encodings, which would indicate a training bug rather than an encoding-specific effect), and (iv) whether per-hypothesis claims are backed by numerical evidence. Quantitative result leaves are scored on a graded scale: 100% if the hypothesis threshold is cleanly met, 67% if the trend is in the predicted direction but does not clear the numerical threshold, 33% if the trend is ambiguous, 0% if the result contradicts the hypothesis or evidence is missing.\weight\sub_tasks\id\q01-code\requirements\Code-development bucket: all 3 encodings implemented per qiskit convention, shared ansatz + optimizer + simulator + training framework are wired identically across cells, and per-cell metrics are logged in the expected METRIC_RESULT JSON format.\weight\sub_tasks\id\q01-code-encodings\requirements\All three encodings are implemented by IMPORTING and INSTANTIATING the canonical classes from qiskit.circuit.library by name, NOT by hand-writing the gate sequences. Concretely the agent's code MUST contain (grep-verifiable): 'from qiskit.circuit.library import' followed by at least the symbols ZFeatureMap, StatePreparation, and ZZFeatureMap; and the three encoding builders must instantiate exactly those classes (angle_encoding = ZFeatureMap(feature_dimension=6, reps=1); amplitude_encoding wraps StatePreparation on a 64D L2-normalized zero-padded vector; zz_feature_map = ZZFeatureMap(feature_dimension=6, reps=2, entanglement='linear')). Hand-written H/RZ/RZZ loops in place of these library classes FAIL this leaf. Additionally, a sanity check at runtime confirms that the three encodings produce DIFFERENT output statevectors for a fixed non-zero input (if they produce identical statevectors, the dispatch is broken and this leaf scores 0). Class bodies are non-trivial (not 'class X(Base): pass' shells).\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Method Implementation\"}, {\"id\": \"q01-code-shared-training\", \"requirements\": \"Training uses qiskit_machine_learning.algorithms.VQC with the reference Sampler primitive. The variational ansatz (EfficientSU2 num_qubits=6 reps=1 entanglement='linear'), the classical optimizer (COBYLA maxiter=200), and the simulator backend (AerSimulator method='statevector') are identical across the 3 quantum encoding cells. Only the feature_map argument is swapped. No hand-rolled training loop in place of VQC.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}, {\"id\": \"q01-code-metric-logging\", \"requirements\": \"Each per-(condition, seed) result is emitted to stdout as a single line beginning with METRIC_RESULT followed by a JSON object whose keys include at minimum: condition (one of angle_encoding / amplitude_encoding / zz_feature_map / logistic_regression / mlp_classifier), dataset (synthetic_classification_6d), seed (integer 0..4), test_accuracy (float in [0,1]). Both classical baselines (LogisticRegression and MLPClassifier) are logged in the same format.\", \"weight\": 6.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q01-exec\", \"requirements\": \"Execution-validity bucket: all cells ran and produced numerically valid outputs.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q01-exec-cells-ran\", \"requirements\": \"At least 25 cells out of 25 expected (5 conditions: 3 quantum encodings + LogisticRegression + MLPClassifier x 1 dataset x 5 seeds) completed without unhandled errors and produced an accuracy value. Missing more than 2 cells (10 percent) without documented justification fails this leaf.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q01-exec-numerical\", \"requirements\": \"Numerical validity: no NaN or Inf in test_accuracy. Every test_accuracy lies in [0, 1]. No quantum cell collapses to a degenerate single-class prediction. At least one quantum encoding achieves test_accuracy strictly greater than 0.55 on at least 1 of 5 seeds (rules out the failure mode where all quantum cells stay near 0.5 random-chance because optimization never actually ran). The 3 quantum encodings MUST NOT produce identical test_accuracy across all 5 seeds (this is the ABLATION FAILURE pattern observed in a prior failed run: if angle/amplitude/zz produce bit-for-bit identical accuracies on every seed, the feature_map argument is being silently ignored by the training code, and this leaf scores 0). Training takes nontrivial wall time per cell (at least a few seconds; sub-1s per cell means VQC.fit was not actually invoked).\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q01-results\", \"requirements\": \"Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\", \"weight\": 3, \"sub_tasks\": [{\"id\": \"q01-result-h1-quant\", \"requirements\": \"Quantitative test of H1. Does the best of the 3 quantum encodings (5-seed mean) achieve test_accuracy within 5 absolute percentage points of the BETTER classical baseline (max of LogisticRegression and MLPClassifier 5-seed means)? 100% if gap is <= 5pp, 67% if gap is <= 10pp, 33% if gap is <= 20pp, 0% if quantum is more than 20pp worse than the best baseline (or either baseline is missing).\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q01-result-h2-quant\", \"requirements\": \"Quantitative test of H2. Is max(encoding 5-seed mean) - min(encoding 5-seed mean) across the 3 quantum encodings at least 5 absolute percentage points? 100% if spread >= 5pp, 67% if spread >= 2pp, 33% if spread > 0, 0% if all three encodings produce identical means (suggests training did not actually depend on the encoding choice).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q01-result-h3-quant\", \"requirements\": \"Quantitative test of H3. Is zz_feature_map test_accuracy (5-seed mean) at least as high as angle_encoding test_accuracy (within 2 absolute pp lower, or higher)? 100% if zz >= angle - 2pp, 67% if zz is 2-5pp below angle, 33% if zz is 5-10pp below, 0% if zz is more than 10pp below angle.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q01-result-writeup\", \"requirements\": \"Writeup of at least 200 words (in submission/README.md ## Agent-produced writeup section) with explicit supported / refuted / inconclusive verdict for each of H1, H2, H3 backed by specific mean accuracies (per encoding plus baseline) and the gap / spread values. Identifies a dominant systematic uncertainty (seed variance, optimizer convergence on the simpler EfficientSU2 reps=1 ansatz, class_sep=0.4 difficulty level). Discusses whether the result would change at higher difficulty or with a deeper ansatz.\", \"weight\": 12.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Logging, Analysis & Presentation\"}], \"task_category\": null, \"finegrained_task_category\": null}], \"task_category\": null, \"finegrained_task_category\": null}", "rubric_num_leaves": 9, "manifest_file": "tasks/quantum/manifests/Q01.yaml", "rubric_file": "tasks/quantum/rubrics/Q01.json"} |
| {"id": "Q02", "domain": "quantum", "title": "Entangling-gate ablation in a variational quantum classifier", "topic": "Ablating entangling gates in a variational quantum classifier: how much classification accuracy is actually attributable to CNOTs versus single-qubit rotations", "domains": ["quantum-machine-learning", "entanglement", "ablation-study"], "arxiv_id": null, "venue": "ARC-Bench 2026", "metric_key": "test_accuracy", "metric_direction": "maximize", "gpu_required": false, "est_wall_clock_sec": 1200, "synthesis": "Quantum machine learning models routinely use parameterized circuits\nthat mix single-qubit rotations with entangling two-qubit gates,\ntypically CNOTs. The common narrative is that entanglement is the\nsource of quantum advantage. If a variational classifier with no\nentangling gates whatsoever can match the accuracy of one with full\nentanglement, that narrative breaks down for this task class. The\npurpose of this study is to measure the actual contribution of\nentanglement in a simple variational quantum classifier by cleanly\nremoving CNOTs in a controlled monotonic manner.\n\nThe design isolates entanglement to one source. The data encoding is\nfixed to angle encoding (single-qubit rotations only, no entangling\ngates). The variational ansatz template is EfficientSU2 with reps=3,\nwhich by default places a linear chain of CNOTs between each rotation\nblock (5 CNOTs per entangling layer, 3 layers, 15 CNOTs total for\n6 qubits). We ablate by replacing some or all of those CNOTs with\nidentity, while keeping every single-qubit rotation parameter intact.\nThis isolates the gain attributable to two-qubit entangling structure\nfrom the gain attributable to the trainable single-qubit basis change.\nhalf_entanglement uses an independent random Bernoulli(0.5) mask over\nthe 15 CNOT positions per cell, seeded deterministically so the\nablation is reproducible but not aligned with any fixed pattern.\n\nA parameter-matched classical baseline (sklearn MLPClassifier with a\nhidden layer sized so its total parameter count is within 10 percent\nof the VQC parameter count) tells us whether either quantum condition\nis competitive with a trivial classical alternative on the same data.\nIf the no-entanglement VQC underperforms the classical MLP, the\nconclusion is that on these tasks, entangling layers are not just\nhelpful but necessary for the variational quantum model to be a\nviable choice at all.\n\nDatasets are deliberately shared with Q01 (encoding comparison) so\nresults can be read across both studies. If the cross-topic story\nholds, the encoding family that benefits most from ansatz CNOTs in\nQ02 should also be the family that performed worst in Q01 (because\nthe ansatz CNOTs are compensating for the encoding's lack of input\nentanglement). The current manifest does not require that\ncross-comparison, but the writeup is encouraged to discuss it.\n\nResearch question: *In a variational quantum classifier on low\ndimensional binary classification, how much of the model's accuracy\nis actually due to ansatz entangling gates, and does the accuracy\ndegrade monotonically as CNOTs are removed?*", "num_hypotheses": 3, "hypotheses": "[{\"id\": \"H1\", \"statement\": \"full_entanglement achieves mean test_accuracy (averaged over 5 seeds) at least 5 absolute percentage points higher than no_entanglement on at least 2 of 3 datasets.\", \"measurable\": true}, {\"id\": \"H2\", \"statement\": \"half_entanglement mean test_accuracy lies strictly between full_entanglement and no_entanglement (within seed-mean noise of 1 absolute percentage point) on at least 2 of 3 datasets, demonstrating that the contribution of entangling layers is approximately monotonic in CNOT count.\", \"measurable\": true}, {\"id\": \"H3\", \"statement\": \"On at least 1 of 3 datasets, classical_baseline (parameter-matched MLPClassifier) achieves test_accuracy at least as high as no_entanglement (5-seed mean). This sanity check rules out a trivial-task explanation: if removing all entanglement leaves the VQC weaker than a tiny classical net, then 'no entanglement' is not a viable QML setting on these tasks.\", \"measurable\": true}]", "experiment_design": "{\"research_question\": \"In a variational quantum classifier on low dimensional binary classification, how much of the model's accuracy is actually due to ansatz entangling gates, and does the accuracy degrade monotonically as CNOTs are removed?\conditions\name\full_entanglement\description\Feature map: ZFeatureMap(feature_dimension=6, reps=1). Ansatz: EfficientSU2(num_qubits=6, reps=3, entanglement='linear'). All 15 CNOTs from the 3 entangling layers are kept. This is the baseline VQC.\name\half_entanglement\description\Same feature_map and ansatz template as full_entanglement, but each of the 15 CNOTs is independently dropped according to a random Bernoulli(0.5) mask. The mask is generated per cell using a derived random state: np.random.RandomState(seed + 10000).binomial(1, 0.5, size=15), where seed is the per-cell run seed. Dropped CNOTs are replaced with identity. Each cell records its realized cnot_count (expected ~7.5, variance per draw). Trainable parameters unchanged.\name\no_entanglement\description\Same feature_map and rotation blocks as full_entanglement, but EVERY entangling gate is replaced with identity. The circuit reduces to a tensor product of independent single-qubit gates. CNOT count is 0. Trainable parameters unchanged.\name\classical_baseline\description\sklearn.neural_network.MLPClassifier with hidden_layer_sizes chosen so the total trainable parameter count is within 10 percent of the VQC (EfficientSU2 reps=3 on 6 qubits has 48 rotation parameters; an MLP with one hidden layer of size 6 has 6*6 + 6 + 6*1 + 1 = 49 params). Use hidden_layer_sizes=(6,), activation='relu', max_iter=500, solver='lbfgs', random_state matched to the corresponding seed.\baselines\no_entanglement is the within-quantum ablation baseline\classical_baseline is the cross-paradigm sanity baseline\metrics\name\test_accuracy\direction\maximize\description\Mean over 5 seeds of held-out 20% test split accuracy.\name\convergence_iterations\direction\minimize\description\Number of COBYLA iterations (or MLP solver iterations for classical_baseline) until training loss change drops below 1e-4 across 5 consecutive evaluations.\name\cnot_count\direction\minimize\description\Number of CNOT gates remaining in the variational circuit (feature map + ansatz) after ablation. Informational metric. Expected: full=15, half=mean over draws (~7.5), no=0, classical_baseline=0.\datasets\name\synthetic_classification_6d\source\sklearn.datasets.make_classification\description\make_classification(n_samples=200, n_features=6, n_informative=4, n_redundant=1, n_repeated=0, n_clusters_per_class=2, class_sep=1.0, flip_y=0.05, random_state=seed). Binary classification, native 6D. Apply StandardScaler. 80/20 train/test split. Same configuration as Q01.\name\wine_binary_pca6\source\sklearn.datasets.load_wine + sklearn.decomposition.PCA\description\load_wine (178 samples, 13 features, 3 classes). Select classes 0 and 1 only (binary subset, ~130 samples). Apply StandardScaler then PCA(n_components=6). 80/20 train/test split. Same configuration as Q01.\name\breast_cancer_pca6\source\sklearn.datasets.load_breast_cancer + sklearn.decomposition.PCA\description\load_breast_cancer (569 samples, 30 features). Apply StandardScaler then PCA(n_components=6). 80/20 train/test split. Same configuration as Q01.\compute_requirements\gpu_required\estimated_wall_clock_sec\, : , : id\q02-root\requirements\A controlled ablation study of entangling gates in a variational quantum classifier. Holding encoding (angle), ansatz template (EfficientSU2 reps=2), optimizer (COBYLA), and datasets fixed (matching Q01), the agent must implement full / half / no entanglement variants by selectively replacing CNOTs with identity in the ansatz, plus a parameter-matched classical MLP baseline. Score H1 (full > no by >=5pp), H2 (half between full and no), H3 (classical >= no on at least 1 dataset) with numerical evidence.\judging_note\Ablation studies are scored on (i) whether the CNOT-removal mechanism actually changes the circuit as described (verified by inspecting cnot_count per condition), (ii) whether every other variable is held fixed (same encoding, same rotation parameters, same datasets, same optimizer, same seeds), and (iii) whether the H1/H2/H3 verdicts are backed by numerical evidence. The classical baseline must be parameter-matched (within 10 percent of the VQC's trainable parameter count) to be a meaningful sanity check.\", \"weight\": 1, \"sub_tasks\": [{\"id\": \"q02-code\", \"requirements\": \"Code-development bucket: the CNOT ablation mechanism is correctly implemented, the classical baseline is parameter-matched, and the evaluation loop holds all non-ablated variables fixed.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q02-code-ablation-mechanism\", \"requirements\": \"All three quantum conditions (full_entanglement, half_entanglement, no_entanglement) use the same ZFeatureMap and the same EfficientSU2(reps=3) rotation parameters. CNOTs are removed by replacing them with identity (not by re-parameterizing the ansatz). The resulting circuits have cnot_count = 15 for full, 0 for no, and a random Bernoulli(0.5) draw over 15 positions for half (mean ~7.5, verified by recording the realized count per cell). The half_entanglement mask is generated via np.random.RandomState(seed + 10000).binomial(1, 0.5, size=15) to be reproducible.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Method Implementation\"}, {\"id\": \"q02-code-classical-baseline\", \"requirements\": \"classical_baseline uses sklearn MLPClassifier with a hidden layer size chosen so the total parameter count is within 10 percent of the VQC's 48 trainable parameters (e.g. hidden_layer_sizes=(6,) gives 49 params for 6-dim input). max_iter, activation, solver, and random_state are specified explicitly. The MLP is trained and evaluated on the SAME train/test splits as the VQC conditions.\weight\sub_tasks\task_category\Code Development\finegrained_task_category\Experimental Setup\id\q02-code-pipeline\requirements\Nested loop over 4 conditions x 3 datasets x at least 5 seeds. Each cell records test_accuracy, convergence_iterations, and cnot_count. The same seed produces the same train/test split across the 4 conditions on each dataset (so the 4 conditions can be paired-compared).\weight\sub_tasks\task_category\Code Development\finegrained_task_category\Experimental Setup\task_category\finegrained_task_category\id\q02-exec\requirements\Execution-validity bucket: all cells ran and produced numerically valid outputs.\weight\sub_tasks\id\q02-exec-cells-ran\requirements\At least 60 cells out of 60 expected (4 conditions x 3 datasets x 5 seeds) completed and produced an accuracy value. Missing cells must be documented; missing more than 6 cells (10 percent) without justification fails this leaf.\weight\sub_tasks\task_category\Code Execution\finegrained_task_category\Evaluation, Metrics & Benchmarking\id\q02-exec-numerical\requirements\Numerical validity: no NaN or Inf in test_accuracy. Every test_accuracy in [0, 1]. cnot_count matches the manifest expectation per condition (full=15, half=Bernoulli draw mean ~7.5 with all values in [0,15], no=0, classical_baseline=0). At least one cell of each condition produces a non-degenerate classifier (not predicting a single class for all test samples).\weight\sub_tasks\task_category\Code Execution\finegrained_task_category\Evaluation, Metrics & Benchmarking\task_category\finegrained_task_category\id\q02-results\requirements\Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\weight\sub_tasks\id\q02-result-h1-quant\requirements\Quantitative test of H1. Does full_entanglement beat no_entanglement by at least 5 absolute percentage points (5-seed mean) on at least 2 of 3 datasets? 100% if cleanly met, 67% if gap >= 2pp on 2/3, 33% if full > no on 2/3 but gap <2pp, 0% if full does not consistently beat no.\weight\sub_tasks\task_category\Result Analysis\finegrained_task_category\Evaluation, Metrics & Benchmarking\id\q02-result-h2-quant\requirements\Quantitative test of H2. Does half_entanglement test_accuracy lie strictly between full and no (within 1pp seed-mean noise) on at least 2 of 3 datasets? 100% if cleanly monotonic on 2/3, 67% if monotonic on 1/3, 33% if half is non-monotonic but within 2pp of one of the endpoints, 0% otherwise.\weight\sub_tasks\task_category\Result Analysis\finegrained_task_category\Evaluation, Metrics & Benchmarking\id\q02-result-h3-quant\requirements\Quantitative test of H3. On at least 1 of 3 datasets, does classical_baseline achieve test_accuracy at least as high as no_entanglement (5-seed mean)? 100% if classical >= no on at least 1/3, 50% if classical is within 2pp of no on at least 1/3, 0% if classical never reaches no_entanglement minus 2pp.\weight\sub_tasks\task_category\Result Analysis\finegrained_task_category\Evaluation, Metrics & Benchmarking\id\q02-result-writeup\requirements\Writeup of at least 200 words (in submission/README.md ## Agent-produced writeup section) with explicit supported / refuted / inconclusive verdict for each of H1, H2, H3 with numerical evidence (specific mean accuracies for each condition x dataset, and the gap), a discussion of monotonicity, and an honest acknowledgment of whether the classical_baseline sanity check passes. The writeup is encouraged but not required to cross-reference Q01 (encoding) findings if available.\weight\sub_tasks\task_category\Result Analysis\finegrained_task_category\Logging, Analysis & Presentation\task_category\finegrained_task_category\task_category\finegrained_task_category\, : 9, : , : } |
| {: , : , : , : , : [, , ], : null, : , : , : , : false, : 1200, : did not converge\, : 3, : id\H1\statement\At 1024 shots per energy evaluation, SPSA reaches chemical accuracy (|E_running_mean - E_FCI| < 1.6 mHa for 5 consecutive 5-eval windows) using fewer cumulative shots than L-BFGS-B (3-seed median), on at least 1 of 2 H2 geometries.\measurable\id\H2\statement\At 1024 shots per energy evaluation, gradient-free methods (SPSA and COBYLA, 6 seed-runs combined across both geometries) achieve chemical accuracy with success rate at least 4/6, while gradient-based methods (L-BFGS-B and ADAM, 6 seed-runs combined) achieve it with success rate at most 3/6. This isolates the shot-noise sensitivity of finite-difference gradient estimation.\measurable\id\H3\statement\Optimizer ranking by shots_to_chemical_accuracy changes between H2 equilibrium and H2 stretched geometries: at least one optimizer pair (e.g. SPSA vs COBYLA, or SPSA vs L-BFGS-B) swaps relative ranking between the two geometries, indicating that Hamiltonian difficulty changes optimizer choice.\measurable\, : research_question\Under finite shot noise, which classical optimizer reaches VQE chemical accuracy in the fewest cumulative shots, and how does the answer depend on shot budget per evaluation and on Hamiltonian difficulty?\conditions\name\spsa\description\qiskit_algorithms.optimizers.SPSA(maxiter=200, learning_rate=0.05, perturbation=0.1). Fixed shot budget: 1024 shots per energy evaluation. Each iteration costs 2 energy evaluations.\name\cobyla\description\qiskit_algorithms.optimizers.COBYLA(maxiter=200, rhobeg=0.1, tol=1e-4). 1024 shots per energy evaluation. Each iteration costs 1 energy evaluation.\name\lbfgsb\description\qiskit_algorithms.optimizers.L_BFGS_B(maxiter=100, ftol=1e-6) with finite-difference gradients (epsilon=1e-3). 1024 shots per energy evaluation. Each iteration costs ~2*num_params energy evaluations for the gradient plus 1 for the function value (so ~25 evals per iter for EfficientSU2 reps=2 on 4 qubits).\name\adam\description\qiskit_algorithms.optimizers.ADAM(maxiter=200, lr=0.05, beta_1=0.9, beta_2=0.999) with finite-difference gradients (epsilon=1e-3). 1024 shots per energy evaluation. Same per-iter cost as L-BFGS-B.\baselines\Cumulative shots vs. FCI energy reference is the within-method benchmark\Hartree-Fock energy at each geometry is the trivial classical baseline below which any optimizer should clear\metrics\name\shots_to_chemical_accuracy\direction\minimize\description\Cumulative shots until |E_running_mean - E_FCI| stays below 1.6 mHa for 5 consecutive evaluations. If not reached within the maxiter budget, report the total cumulative shots used (sentinel = max-shots) and flag success=False.\name\final_energy_error_hartree\direction\minimize\description\|E_final - E_FCI| in Hartree at the end of optimization (after all maxiter iterations).\name\success_rate\direction\maximize\description\Fraction of seeds (out of 3 per condition x geometry) where the run reached chemical accuracy by the maxiter budget.\datasets\name\h2_equilibrium\source\qiskit_nature.second_q.drivers.PySCFDriver (REQUIRED dependency)\description\H2 in STO-3G basis at bond length 0.74 angstrom. Build the FermionicOp via PySCFDriver, apply ParityMapper with 2-qubit reduction to obtain a 4-qubit qubit Hamiltonian (alternatively JordanWignerMapper + tapering). FCI reference: E_FCI = -1.137283 Ha. Hardcoded Pauli strings are NOT an acceptable substitute for this benchmark; both qiskit_nature and pyscf must be installed and used.\name\h2_stretched\source\qiskit_nature.second_q.drivers.PySCFDriver (REQUIRED dependency)\description\H2 in STO-3G basis at bond length 1.5 angstrom (multireference / strong-correlation regime). 4 qubits via the same mapping pipeline as h2_equilibrium. FCI reference: E_FCI ~ -1.001 Ha. Hardcoded Pauli strings NOT accepted.\compute_requirements\gpu_required\estimated_wall_clock_sec\, : , : id\q03-root\requirements\A credible VQE optimizer comparison on H2 in STO-3G basis at two bond lengths (0.74 A equilibrium, 1.5 A stretched), at a fixed shot budget of 1024 shots per energy evaluation. The agent must (a) construct the 4-qubit H2 Hamiltonian at each geometry via qiskit_nature.PySCFDriver, (b) implement VQE via qiskit_algorithms.VQE.compute_minimum_eigenvalue() with a hardware-efficient EfficientSU2 reps=2 ansatz, (c) run 4 optimizers (SPSA, COBYLA, L-BFGS-B, ADAM) x 2 geometries x 3 seeds = 24 cells, (d) log cumulative shots and energy trajectories per cell, and (e) score H1/H2/H3 with numerical evidence keyed by (optimizer, geometry).\judging_note\Optimizer comparisons are scored on (i) correctness of the Hamiltonian (FCI reference within 1 mHa of -1.137 Ha for H2 equilibrium), (ii) consistent ansatz / initial parameters across cells so only the optimizer and shot budget vary, (iii) accurate accounting of cumulative shots including gradient evaluations for L-BFGS-B and ADAM, and (iv) numerical evidence backing H1/H2/H3. qiskit_nature.second_q.drivers.PySCFDriver MUST be used to build the Hamiltonian. Hardcoded Pauli strings are NOT acceptable and a submission that uses them fails q03-code-hamiltonians.\weight\sub_tasks\id\q03-code\requirements\Code-development bucket: VQE pipeline correctly implements 4 optimizers, both H2 geometries, and accurate cumulative-shot tracking.\weight\sub_tasks\id\q03-code-vqe\requirements\VQE is implemented using qiskit_algorithms.VQE or an equivalent custom loop. The ansatz is EfficientSU2(num_qubits=4, reps=2, entanglement='linear'). Initial parameters are sampled from N(0, 0.1) with the same seed across all 4 optimizers for a given (shot_budget, geometry, seed) triple. All 4 optimizers are correctly instantiated from qiskit_algorithms.optimizers (SPSA, COBYLA, L_BFGS_B, ADAM) with the maxiter and learning rates listed in the manifest.\weight\sub_tasks\task_category\Code Development\finegrained_task_category\Method Implementation\id\q03-code-hamiltonians\requirements\Both H2 Hamiltonians are constructed at the correct bond lengths (0.74 and 1.5 angstrom) in STO-3G basis using qiskit_nature.second_q.drivers.PySCFDriver (REQUIRED) and either ParityMapper with 2-qubit reduction or JordanWignerMapper with tapering. The diagonalized Hamiltonian (numpy eigvalsh of the matrix form) gives FCI energies within 1 mHa of -1.137 Ha (equilibrium) and -1.001 Ha (stretched). Hardcoded Pauli strings as a substitute for PySCFDriver are NOT accepted and fail this leaf.\weight\sub_tasks\task_category\Code Development\finegrained_task_category\Method Implementation\id\q03-code-shot-tracking\requirements\Cumulative shots is tracked correctly per run. For SPSA and COBYLA, each iteration adds shots_per_eval * num_evaluations_per_iter (2 for SPSA, 1 for COBYLA). For L-BFGS-B and ADAM with finite-difference gradients, each iteration adds shots_per_eval * (2 * num_params + 1) so the gradient evaluations are accounted for. The shots_to_chemical_accuracy metric is computed using the running mean energy (over the last 5 evaluations) and reports the cumulative shot count at the first evaluation where the mean stays within 1.6 mHa of E_FCI for 5 consecutive evaluations.\weight\sub_tasks\task_category\Code Development\finegrained_task_category\Evaluation, Metrics & Benchmarking\task_category\finegrained_task_category\id\q03-exec\requirements\Execution-validity bucket: all cells ran with valid energies and shot accounting.\weight\sub_tasks\id\q03-exec-cells-ran\requirements\At least 22 cells out of 24 expected (4 optimizers x 1 shot budget (1024) x 2 geometries x 3 seeds = 24) completed and produced a final_energy_error_hartree value. If any cells are omitted (e.g. ADAM ran out of budget), they must be documented with a recorded cause. Missing more than 2 cells (10 percent) without justification fails this leaf. The condition_summaries MUST be keyed by (optimizer, geometry) so each of the 8 condition cells has 3 seed entries — collapsing across the geometry axis (e.g. reporting only per-optimizer aggregates) fails this leaf because it makes H1 and H3 unevaluable.\weight\sub_tasks\task_category\Code Execution\finegrained_task_category\Evaluation, Metrics & Benchmarking\id\q03-exec-numerical\requirements\Numerical validity: every final energy is finite (no NaN/Inf), every final_energy_error_hartree >= 0, every success_rate in [0, 1], cumulative shots is monotone increasing within a run. At least one cell across the entire sweep reaches chemical accuracy (otherwise the rubric thresholds are uncalibrated for this setup).\weight\sub_tasks\task_category\Code Execution\finegrained_task_category\Evaluation, Metrics & Benchmarking\task_category\finegrained_task_category\id\q03-results\requirements\Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\weight\sub_tasks\id\q03-result-h1-quant\requirements\Quantitative test of H1. On at least 1 of 2 geometries at 1024 shots/eval, does SPSA reach chemical accuracy with fewer median cumulative shots than L-BFGS-B (over 3 seeds)? 100% if SPSA wins on at least 1/2 geometries with a >=20 percent shot reduction, 67% if SPSA wins on at least 1/2 with any margin, 33% if SPSA and L-BFGS-B are within 10 percent of each other, 0% if L-BFGS-B is consistently faster.\weight\sub_tasks\task_category\Result Analysis\finegrained_task_category\Evaluation, Metrics & Benchmarking\id\q03-result-h2-quant\requirements\Quantitative test of H2. At 1024 shots/eval, pooling across both geometries: do gradient-free methods (SPSA + COBYLA, total of 6 seed-runs = 2 methods x 3 seeds) have a combined chemical-accuracy success rate of at least 4/6, while gradient-based methods (L-BFGS-B + ADAM, 6 seed-runs) have at most 3/6? 100% if cleanly met, 67% if the gradient-free success rate exceeds gradient-based by at least 30 percent, 33% if gradient-free exceeds gradient-based at all, 0% if gradient-based methods are equal or better.\weight\sub_tasks\task_category\Result Analysis\finegrained_task_category\Evaluation, Metrics & Benchmarking\id\q03-result-h3-quant\requirements\Quantitative test of H3. Does the optimizer ranking by median shots_to_chemical_accuracy change between H2 equilibrium and H2 stretched geometries? Specifically: take the 4-element ranking of optimizers (by 3-seed-median shots) on each geometry; H3 is supported if at least one pair swaps relative order between the two rankings (Kendall tau distance >= 1 between the two rankings). 100% if at least one swap detected with clear evidence, 67% if one optimizer's rank differs by exactly 1 position, 33% if rankings are similar but values differ, 0% if rankings are identical or H3 is unevaluable (e.g. due to collapsed condition_summaries that drop the geometry axis).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q03-result-writeup\", \"requirements\": \"Writeup of at least 200 words (in submission/README.md ## Agent-produced writeup section) with explicit supported / refuted / inconclusive verdict for each of H1, H2, H3 with numerical evidence (specific median cumulative shots, success rates, and final energy errors per optimizer x shot budget). Identifies a dominant systematic uncertainty (seed variance, finite-difference epsilon, optimizer hyperparameter sensitivity, shot-noise variance at low budgets). Discusses the difference between equilibrium and stretched H2 in terms of optimizer ranking.\", \"weight\": 12.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Logging, Analysis & Presentation\"}], \"task_category\": null, \"finegrained_task_category\": null}], \"task_category\": null, \"finegrained_task_category\": null}", "rubric_num_leaves": 9, "manifest_file": "tasks/quantum/manifests/Q03.yaml", "rubric_file": "tasks/quantum/rubrics/Q03.json"} |
| {"id": "Q04", "domain": "quantum", "title": "Data re-uploading depth vs Fourier expressivity for variational quantum regression", "topic": "Data re-uploading depth vs Fourier expressivity for variational quantum regression: characterizing how the trainable bandwidth of a parameterized re-uploading circuit scales with re-uploading layers L on synthetic 1D regression targets", "domains": ["quantum-machine-learning", "data-reuploading", "expressivity"], "arxiv_id": null, "venue": "ARC-Bench 2026", "metric_key": "test_mse", "metric_direction": "minimize", "gpu_required": false, "est_wall_clock_sec": 900, "synthesis": "Data re-uploading is a variational quantum circuit pattern in which the\nclassical input x is loaded into the same qubits multiple times,\ninterleaved with trainable rotation layers: the circuit\nW(theta_L) U(x) W(theta_{L-1}) U(x) ... W(theta_1) U(x) |0> applies L\nencoding blocks U(x) and L trainable blocks W(theta). Perez-Salinas et al.\nproved in 2020 that a single qubit with sufficient re-uploading depth is\na universal function approximator on bounded intervals. Schuld, Sweke,\nand Meyer (PRA 2021) then proved the structural reason: a re-uploading\ncircuit's output function is a truncated Fourier series in the input x,\nwith the set of representable frequencies determined by the eigenvalue\nspectrum of the encoding generators and growing with L.\n\nThe practical question that follows is whether the theoretical\nexpressivity claim translates into empirical fit quality. As L grows we\nexpect (i) more representable frequencies (better fit on high-bandwidth\ntargets), and (ii) more parameters and more risk of overfitting on\nfinite-sample regression with discontinuous targets. Classical kernel\nregression (RBF) and polynomial regression provide the natural baselines\nbecause they too can be interpreted as choosing a basis of functions\n(Gaussian or polynomial) of fixed expressivity; comparing quantum\nre-uploading against these classical baselines is the cleanest way to\nask \\n\nImplementation guidance is provided by the quantum-qiskit skill, which\nis automatically injected at stage 10 and contains canonical code for\nbuilding re-uploading circuits using qiskit.circuit.ParameterVector and\nrotation gates. Training uses Adam through parameter-shift gradients\n(do NOT roll your own gradient finite-difference loop). The simulator\nis fixed to AerSimulator(method='statevector') for noiseless evaluation\nso the Fourier-spectrum probe is clean.\n\nExperimental protocol. Four quantum re-uploading depths (L=1, L=3, L=5,\nL=7) are compared against two classical baselines (RBF kernel ridge\nregression with bandwidth chosen by cross-validation; polynomial\nregression of degree 7). All six conditions are evaluated on two 1D\nregression targets: a sum-of-sinusoids signal with known frequency\ncontent, and a step function (tests handling of discontinuities).\nEach (condition, dataset) cell is averaged over 2 random seeds, giving\n6 conditions x 2 datasets x 2 seeds = 24 total cells.\n\nResearch question: *On 1D regression with known target bandwidth, does\nincreasing data re-uploading depth L produce monotonically lower test\nMSE on bandwidth-rich targets (sinusoid mixture), and does the\nrecovered Fourier spectrum overlap with the target spectrum scale\npredictably with L?*num_hypotheseshypotheses[{\: \, \: \, \: true}, {\: \, \: \, \: true}, {\: \, \: \, \: true}]experiment_design{\: \, \: [{\: \, \: \}, {\: \, \: \}, {\: \, \: \}, {\: \, \: \}], \: [\, \], \: [{\: \, \: \, \: \}, {\: \, \: \, \: \}, {\: \, \: \, \: \}], \: [{\: \, \: \, \: \}, {\: \, \: \, \: \}], \: {\: false, \: 900}}requirementsrubric{\: \, \: \, \: \, \: 1, \: [{\: \, \: \, \: 2, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 6.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 2, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 10.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 3, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 12.0, \: [], \: \, \: \}], \: null, \: null}], \: null, \: null}rubric_num_leavesmanifest_filetasks/quantum/manifests/Q04.yamlrubric_filetasks/quantum/rubrics/Q04.json |
| idQ05domainquantumtitleBarren plateau onset under cost-function localitytopicBarren plateau onset under cost-function locality: empirically measuring gradient variance of hardware-efficient ansatze under global vs local cost functions across depth, testing the Cerezo 2021 prediction that local costs avoid exponential gradient suppressiondomainsquantum-machine-learningbarren-plateaustrainabilityarxiv_idvenueARC-Bench 2026metric_keylog_gradient_variancemetric_directionmaximizegpu_requiredest_wall_clock_secsynthesisA barren plateau is the phenomenon, first identified by McClean et al.\nin 2018, that the gradient of a variational quantum circuit's loss\nbecomes exponentially small in the number of qubits when the ansatz is\ndrawn from a sufficiently random circuit ensemble. Concretely, for a\nloss L(theta) = <psi(theta)|H|psi(theta)> where the parameterized\nstate is generated by a random-ish unitary, the variance of the\ngradient dL/dtheta_k scales as O(1/2^n). For n = 20 qubits this\nvariance is below machine epsilon, and SGD or any gradient-based\noptimizer has effectively zero signal to follow. This is the central\ntrainability obstruction in variational quantum machine learning.\n\nCerezo et al. (\"Cost function dependent barren plateaus in shallow\nparametrized quantum neural networks\", Nature Communications 2021)\nshowed that the locality of the cost function matters. If the cost is\na sum of single-qubit Pauli expectations (a local cost), then the\ngradient variance can scale only polynomially in n even at moderate\nansatz depth. If the cost is a product or projection over all qubits\n(a global cost), the variance is exponentially suppressed at any\ndepth. The mechanism is that local-cost observables overlap with only\na constant-size subspace of the 2^n dimensional Hilbert space, while\nglobal-cost observables are spread thinly across the entire space and\nalmost always cancel.\n\nThe empirical question this topic addresses is whether the local-cost\nfree lunch holds at moderate depth on a CPU-feasible 6-qubit\nbenchmark. We fix n=6 qubits and the EfficientSU2 hardware-efficient\nansatz family (a standard choice in qiskit). We vary depth (number of\nansatz layers L) and cost-function locality, then directly probe the\ngradient distribution by sampling 100 random parameter vectors per\ncell, computing the parameter-shift gradient with respect to theta_0\nfor each, and reporting the empirical variance. A subsidiary check\ntrains each condition for 100 Adam iterations and reports the loss\nchange as a practical sanity probe of whether the gradient signal is\nlarge enough to drive optimization at all.\n\nImplementation guidance is provided by the quantum-qiskit skill,\nwhich is automatically injected at stage 10. Use qiskit.circuit.library\nEfficientSU2 verbatim; do NOT hand-write H/CNOT/RY gate stacks (a\nprior failed run produced an \"ablation failure\" where three nominally\ndifferent encodings collapsed to identical circuits because they\nwere hand-coded). Use qiskit_algorithms.utils.algorithm_globals\nrandom_seed for reproducibility. Gradients are computed via the\nparameter-shift rule on a statevector backend.\n\nExperimental protocol. Four conditions cover the cost x depth grid:\n(local_cost_L2) shallow + local, the trainable control; (local_cost_L10)\nmedium + local, the regime Cerezo's theorem predicts is still\ntrainable; (local_cost_L20) deep + local, stressing the prediction;\n(global_cost_L10) medium + global, the negative control where a barren\nplateau is expected. Each condition is run with 3 different random\nansatz-structure seeds (controlling which qubits are entangled in each\nEfficientSU2 layer) for variance estimation across architectures, and\n100 random parameter vectors per (condition, structure-seed) cell are\nused to estimate gradient variance. Total cells: 4 conditions x 3\nansatz seeds = 12 cells. No external dataset is required because this\nis a measurement experiment on the ansatz family itself.\n\nResearch question: *Does the local-cost trick avoid the barren plateau\non a 6-qubit EfficientSU2 ansatz at L=10 and L=20 ansatz depth, as\npredicted by Cerezo et al. 2021, when compared against the\nglobal-cost baseline at the same depth and against the shallow local-cost\ncontrol?*num_hypotheseshypotheses[{\: \, \: \, \: true}, {\: \, \: \, \: true}, {\: \, \: \, \: true}]experiment_design{\: \, \: [{\: \, \: \}, {\: \, \: \}], \: [\, \], \: [{\: \, \: \, \: \}, {\: \, \: \, \: \}, {\: \, \: \, \: \}], \: [{\: \, \: \, \: \}], \: {\: false, \: 600}}requirementsrubric{\: \, \: \, \: \, \: 1, \: [{\: \, \: \, \: 2, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 7.0, \: [], \: \, \: \}, {\: \, \: \, \: 7.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 2, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 10.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 3, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 12.0, \: [], \: \, \: \}], \: null, \: null}], \: null, \: null}rubric_num_leavesmanifest_filetasks/quantum/manifests/Q05.yamlrubric_filetasks/quantum/rubrics/Q05.json |
| idQ06domainquantumtitleNeural-network warm-start for QAOA-MaxCut initializationtopicNeural-network warm-start for QAOA-MaxCut: comparing MLP-predicted initial parameters against random and fixed initialization across in-distribution and out-of-distribution graph familiesdomainsai-for-quantumqaoameta-learningarxiv_idvenueARC-Bench 2026metric_keyiterations_to_target_ratiometric_directionminimizegpu_requiredest_wall_clock_secsynthesisThe Quantum Approximate Optimization Algorithm (QAOA) prepares a\nparameterized quantum state to approximate the maximum cut of a graph.\nAt depth p=1 the state depends on two real parameters (beta, gamma),\nand the algorithm proceeds by classical optimization of those two\nparameters against the average cut size sampled from measurements of\nthe prepared state. The bottleneck for practical QAOA is the initial\nparameter guess. Random initialization frequently falls into the\nbarren-plateau region or onto sub-optimal local minima, requiring many\nclassical iterations to escape. Brandao et al. 2018 showed\ntheoretically that the optimal (beta, gamma) values concentrate\naround a problem-independent point on certain graph ensembles, so a\nfixed initialization like (pi/4, pi/4) is a strong default.\n\nBeyond concentration, a richer strategy is to train a classical\nneural network offline to predict the optimal (beta, gamma) given\nfeatures of the input graph. Verdon et al. 2019 introduced the idea\nas quantum-aware meta-learning. Jain et al. (Quantum 2022, \) showed that a graph neural\nnetwork trained on a few thousand small graphs can predict initial\nparameters that reduce the number of subsequent classical\noptimization iterations by 5-10x compared to random initialization,\nwith measurable transfer to out-of-distribution graph families.\n\nThe empirical question this topic addresses is whether the MLP-warm-start\nstrategy actually generalizes off-distribution: a model trained on\nErdős-Rényi graphs of one density should ideally retain its advantage\non regular graphs of a different size. We also want to verify whether\nthe simpler \ baseline (from Brandao 2018)\nis competitive with the MLP-predicted init at p=1, since the\nconcentration result suggests that simple defaults may be hard to\nbeat in the low-depth regime.\n\nImplementation guidance is provided by the quantum-qiskit skill at\nstage 10. Implement QAOA on the qiskit AerSimulator statevector\nbackend; the small graph sizes (n=6 to n=8) make exact statevector\nsimulation cheap. The MLP is sklearn.neural_network.MLPRegressor\ntrained offline on a precomputed set of (graph_features, optimal_beta,\noptimal_gamma) tuples obtained by grid search on 200 training\ngraphs. Optimization at test time uses COBYLA with a hard cap of 20\niterations.\n\nExperimental protocol. Two graph families serve as the test bed.\nIn-distribution: Erdős-Rényi G(n=6, p=0.5) graphs (matched to the MLP\ntraining distribution). Out-of-distribution: 3-regular graphs at n=8\n(different size and edge density). Four conditions cover the\ninitialization strategies: random init, fixed init (beta=gamma=pi/4),\nMLP-init evaluated in-distribution, and MLP-init evaluated\nout-of-distribution. (MLP-init has 2 conditions because the model\ntrained on Erdős-Rényi G(n=6, p=0.5) is evaluated on both graph\nfamilies to test transfer.) Each (condition, graph family) cell is\naveraged over 3 different random graph instances drawn within that\nfamily. Total cells: 4 conditions x 2 graph families x 3 seeds = 24\ncells.\n\nResearch question: *Does a small MLP trained to predict QAOA-MaxCut\ninitial parameters from graph features (degree distribution, edge\ndensity, spectral gap) provide a faster warm-start than random\ninitialization or the Brandao 2018 fixed (pi/4, pi/4) initialization,\nand does the advantage transfer to graphs from a different\ndistribution than the MLP was trained on?*num_hypotheseshypotheses[{\: \, \: \, \: true}, {\: \, \: \, \: true}, {\: \, \: \, \: true}]experiment_design{\: \, \: [{\: \, \: \}, {\: \, \: \}], \: [\, \], \: [{\: \, \: \, \: \}, {\: \, \: \, \: \}, {\: \, \: \, \: \}], \: [{\: \, \: \, \: \}, {\: \, \: \, \: \}], \: {\: false, \: 1200}}requirementsrubric{\: \, \: \, \: \, \: 1, \: [{\: \, \: \, \: 2, \: [{\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 6.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 2, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 10.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 3, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 12.0, \: [], \: \, \: \}], \: null, \: null}], \: null, \: null}rubric_num_leavesmanifest_filetasks/quantum/manifests/Q06.yamlrubric_filetasks/quantum/rubrics/Q06.json |
| idQ07domainquantumtitleMatrix Product State classifier vs neural network at matched parameter counttopicMatrix Product State classifier vs neural network at matched parameter count on downsampled image classification, characterizing the bond-dimension scaling of tensor-network classifiers as a quantum-inspired classical baseline for QMLdomainsquantum-inspired-classicaltensor-networkssupervised-learningarxiv_idvenueARC-Bench 2026metric_keytest_accuracymetric_directionmaximizegpu_requiredest_wall_clock_secsynthesisA Matrix Product State (MPS) is a tensor network in which a target\ntensor of N indices is decomposed into a 1D chain of N small tensors,\neach connected to its neighbors by \ indices of dimension chi.\nMPS originated in condensed-matter physics as the representation\nunderlying the Density Matrix Renormalization Group (DMRG) for 1D\nground-state computation, and Schollwock's 2011 review remains the\ncanonical reference. Stoudenmire and Schwab (NeurIPS 2016, \"Supervised\nLearning with Tensor Networks\") repurposed the MPS as a classical\nsupervised classifier. The idea is simple: each input feature\n(pixel) is mapped to a small feature vector (e.g. cos(pi*x/2),\nsin(pi*x/2) for grayscale x in [0,1]), and the per-pixel feature\nvectors are contracted with a chain of MPS tensors to produce a\nclass-score vector. The MPS bond dimension chi controls how much\ncorrelation between distant pixels the classifier can capture,\ngiving an interpretable expressivity knob.\n\nCrucially, the MPS classifier runs entirely on classical hardware.\nThis makes it a \"quantum-inspired classical\" baseline: the same\nmathematical machinery as a low-entanglement quantum state, but\nimplemented as a NumPy tensor contraction. Glasser et al. (PRX 2018)\nextended the framework to richer tensor networks. More recent\nbenchmarks (Liu et al. 2022 Nature Communications Physics) have asked\nwhere the bond-dimension sweet spot is for image classification and\nwhether MPS classifiers can be competitive with CNNs at small\nparameter budgets.\n\nThis topic asks whether an MPS classifier matches a parameter-matched\nCNN baseline on a CPU-feasible image classification task. The\ncomparison is not \"does MPS beat CNN at large scale\" (it doesn't, on\nhigh-resolution images) but rather \ The\nquestion is timely because tensor-network ML is increasingly cited\nas the honest classical baseline against which to measure quantum\nmachine learning claims of advantage.\n\nImplementation guidance. Use pure NumPy or PyTorch for the MPS\ncontraction (no qiskit required for this topic; it is quantum-inspired\nclassical computation). The standard MPS classifier from Stoudenmire\n& Schwab 2016 stores N+1 tensors of shape (chi, d, chi) where N is\nthe number of pixels (64 for an 8x8 image), d=2 is the per-pixel\nfeature dimension (we use the cos/sin embedding), and chi is the\nbond dimension. The CNN baseline is a single 3x3 convolution layer\nwith K filters followed by a fully connected output layer; K is\nchosen so the total parameter count is within 10 percent of the MPS\nparameter count at each bond dimension.\n\nExperimental protocol. Three MPS bond dimensions (chi=4, chi=8,\nchi=16) are compared against two classical baselines (logistic\nregression on flattened 8x8 pixels; small CNN with parameter count\nmatched to the chi=8 MPS). All five conditions are evaluated on two\ndatasets: 8x8 downsampled MNIST (10 classes, 5000 train / 1000 test\nimages) and 8x8 downsampled Fashion-MNIST (10 classes, same\nsize). Each (condition, dataset) cell is averaged over 3 random\nseeds (controlling MPS / CNN initialization and the train / test\nsplit). Total cells: 5 conditions x 2 datasets x 3 seeds = 30 cells.\n\nResearch question: *On 8x8 downsampled MNIST and Fashion-MNIST, do\nMPS classifiers at moderate bond dimension chi reach the test\naccuracy of a parameter-matched CNN, and how does the accuracy\nscale with chi?*num_hypotheseshypotheses[{\: \, \: \, \: true}, {\: \, \: \, \: true}, {\: \, \: \, \: true}]experiment_design{\: \, \: [{\: \, \: \}, {\: \, \: \}, {\: \, \: \}], \: [\, \], \: [{\: \, \: \, \: \}, {\: \, \: \, \: \}, {\: \, \: \, \: \}], \: [{\: \, \: \, \: \}, {\: \, \: \, \: \}], \: {\: false, \: 1500}}requirementsrubric{\: \, \: \, \: \, \: 1, \: [{\: \, \: \, \: 2, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 7.0, \: [], \: \, \: \}, {\: \, \: \, \: 7.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 2, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 10.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 3, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 12.0, \: [], \: \, \: \}], \: null, \: null}], \: null, \: null}rubric_num_leavesmanifest_filetasks/quantum/manifests/Q07.yamlrubric_filetasks/quantum/rubrics/Q07.json |
| idQ08domainquantumtitleLayerwise learning vs end-to-end training for variational quantum classifierstopicLayerwise learning vs end-to-end training for variational quantum classifiers: testing the Skolik 2021 claim that incremental ansatz growth avoids barren plateaus on small UCI binary classification tasksdomainsquantum-machine-learningtraining-strategiesbarren-plateausarxiv_idvenueARC-Bench 2026metric_keytest_accuracymetric_directionmaximizegpu_requiredest_wall_clock_secsynthesisVariational quantum classifiers (VQCs) at moderate depth (reps >= 5)\nsuffer from barren plateaus: the gradient of the loss with respect to\nany single parameter is exponentially suppressed when the ansatz is\ninitialized randomly across all layers. Skolik et al. (Quantum 2021,\n\) proposed a training\nschedule that avoids this trap by adding ansatz layers incrementally.\nConcretely, the agent trains a reps=1 ansatz to convergence, freezes\nits parameters, prepends or appends a fresh reps=1 block initialized\nto identity, trains only the new block to convergence, and so on\nuntil the target depth is reached. Each layer of training sees a much\nsmaller parameter space, so the gradient signal stays well above the\nbarren-plateau floor at every step.\n\nThe empirical question this topic addresses is whether the layerwise\nschedule actually delivers higher final test accuracy AND faster\npractical convergence than naive end-to-end training of the full\nreps=5 ansatz on small UCI binary classification tasks. A\nparameter-matched classical baseline (sklearn MLPClassifier) and a\nlogistic regression baseline serve as the cross-paradigm controls\nrequired by the bench's PROCEED gate; they also calibrate the\ndifficulty of each dataset (logistic regression should fit linear\nseparable cases cleanly).\n\nImplementation guidance is provided by the quantum-qiskit skill,\nwhich is automatically injected at stage 10. Use\nqiskit.circuit.library.EfficientSU2(num_qubits=4, reps=5,\nentanglement='linear') as the underlying ansatz family, and use\nqiskit_machine_learning.algorithms.VQC for training (it works in\nqiskit 2.x; do NOT use qiskit_algorithms.VQE which is broken). For\nthe layerwise condition, the agent must implement the layer-freezing\nschedule manually: construct an ansatz with only the first k blocks\ntrainable and previous blocks bound to their converged parameters.\nThe classical baselines train on the same 80/20 train/test split\nusing the same per-seed random_state.\n\nExperimental protocol. Three quantum conditions compare training\nschedules at the same final depth (reps=5): layerwise growth from\nreps=1 to reps=5, end-to-end training of reps=5 from random\ninitialization, and a random-init control (no training, evaluate\nthe randomly initialized reps=5 ansatz). Two classical baselines\n(logistic regression, MLPClassifier with parameter count matched to\nthe VQC's 40-parameter count) provide the cross-paradigm reference.\nEach (condition, dataset) cell is averaged over 3 seeds. Total:\n5 conditions x 2 datasets x 3 seeds = 30 cells.\n\nResearch question: *Does layerwise incremental training of a VQC\nreach higher test accuracy or faster convergence than end-to-end\ntraining of the same final-depth ansatz, and does the layerwise\ngradient norm at each newly added layer remain above the\nbarren-plateau threshold?*num_hypotheseshypotheses[{\: \, \: \, \: true}, {\: \, \: \, \: true}, {\: \, \: \, \: true}]experiment_design{\: \, \: [{\: \, \: \}, {\: \, \: \}, {\: \, \: \}], \: [\, \], \: [{\: \, \: \, \: \}, {\: \, \: \, \: \}, {\: \, \: \, \: \}], \: [{\: \, \: \, \: \}, {\: \, \: \, \: \}], \: {\: false, \: 1500}}requirementsrubric{\: \, \: \, \: \, \: 1, \: [{\: \, \: \, \: 2, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 7.0, \: [], \: \, \: \}, {\: \, \: \, \: 6.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 2, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 10.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 3, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 12.0, \: [], \: \, \: \}], \: null, \: null}], \: null, \: null}rubric_num_leavesmanifest_filetasks/quantum/manifests/Q08.yamlrubric_filetasks/quantum/rubrics/Q08.json |
| idQ09domainquantumtitleNoise-aware variational quantum classifier trainingtopicNoise-aware variational quantum classifier training: comparing training under simulated depolarizing noise vs ideal-statevector training, evaluating both robustness to test-time noise and clean-test transferdomainsai-for-quantumnoisy-quantum-trainingrobustnessarxiv_idvenueARC-Bench 2026metric_keytest_accuracymetric_directionmaximizegpu_requiredest_wall_clock_secsynthesisReal quantum hardware exhibits gate errors, readout errors, and\ndecoherence at rates that vary across devices. A VQC trained on a\nnoiseless statevector simulator may converge to parameters that work\non the ideal training distribution but degrade sharply when deployed\non a noisy device. The noise-aware training strategy is to inject\nsimulated noise during training (e.g. a depolarizing channel after\neach two-qubit gate) so the optimizer can find parameters that are\nrobust to that noise model. The closest classical analog is\nadversarial training or training-time data augmentation.\n\nTwo open empirical questions follow. First, does noise-aware training\nproduce strictly more robust models on noisy test data than ideal\ntraining, and at what training noise rate is the robustness gain\nworth the loss of clean-test accuracy? Second, does training at high\nnoise (p=0.01) cause negative transfer to clean test data — i.e.\ndoes the model overfit to the noise statistics and underperform an\nideal-trained model on noise-free evaluation? Wang et al. (NeurIPS\n2022 \) and Sharma et al. (PRX Quantum 2022 \) explored\nthese tradeoffs at small scale, leaving the precise sweet-spot\nnoise rate as a benchmark question.\n\nImplementation guidance is provided by the quantum-qiskit skill at\nstage 10. Use qiskit_aer.AerSimulator with a custom NoiseModel that\napplies a single-qubit and two-qubit depolarizing channel after each\nparameterized gate. The training uses\nqiskit_machine_learning.algorithms.VQC with a custom\nqiskit.primitives.BackendSamplerV2 bound to the noisy AerSimulator\nfor noisy-train conditions, and the noiseless reference\nqiskit.primitives.StatevectorSampler for the ideal-train condition.\nEvaluation always runs on both an ideal statevector test set and a\nnoisy test set at p=0.01 (the \) so each cell\nproduces two test_accuracy values: clean and noisy. The primary\nmetric is the average across both.\n\nExperimental protocol. Four quantum training conditions vary the\ntraining noise rate: ideal (p=0), low noise (p=0.001), mid noise\n(p=0.005), high noise (p=0.01). Two baselines complete the bench\ngate: a no-training control (random initialization, no fit) and\nlogistic regression on the same 4D features. All six conditions\nare evaluated on a single synthetic binary classification dataset\n(make_classification with class_sep=0.5, 200 samples, 4 features),\naveraged over 3 seeds. Total: 6 conditions x 1 dataset x 3 seeds\n= 18 cells.\n\nResearch question: *On a synthetic 4D binary classification task,\ndoes noise-aware VQC training at a moderate training noise rate\n(p=0.005) produce a model that is more robust to test-time\ndepolarizing noise (p=0.01) than an ideal-trained VQC, and does\nhigh training noise (p=0.01) cause negative transfer to clean\ntest data?*num_hypotheseshypotheses[{\: \, \: \, \: true}, {\: \, \: \, \: true}, {\: \, \: \, \: true}]experiment_design{\: \, \: [{\: \, \: \}, {\: \, \: \}, {\: \, \: \}, {\: \, \: \}], \: [\, \], \: [{\: \, \: \, \: \}, {\: \, \: \, \: \}, {\: \, \: \, \: \}], \: [{\: \, \: \, \: \}], \: {\: false, \: 1500}}requirementsrubric{\: \, \: \, \: \, \: 1, \: [{\: \, \: \, \: 2, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 6.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 2, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 10.0, \: [], \: \, \: \}], \: null, \: null}, {\: \, \: \, \: 3, \: [{\: \, \: \, \: 10.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 8.0, \: [], \: \, \: \}, {\: \, \: \, \: 12.0, \: [], \: \, \: \}], \: null, \: null}], \: null, \: null}rubric_num_leavesmanifest_filetasks/quantum/manifests/Q09.yamlrubric_filetasks/quantum/rubrics/Q09.json |
| idQ10domainquantumtitleQuantum autoencoder for pure-state compressiontopicQuantum 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 ratiodomainsquantum-machine-learninggenerative-modelsautoencodersarxiv_idvenueARC-Bench 2026metric_keyreconstruction_fidelitymetric_directionmaximizegpu_requiredest_wall_clock_secsynthesisA quantum autoencoder takes an n-qubit quantum state, applies a\nparameterized circuit that disentangles the information onto a\nsmaller subset of m < n \ qubits, and traces out the\nremaining n - m \ qubits. The latent qubits are then expanded\nback to n qubits via a fresh ancilla register and a decoder circuit\n(typically the conjugate of the encoder). Training optimizes the\nencoder so the trash qubits end in the |0> state (verified via a\nSWAP test against fresh |0> ancillas), which is equivalent to\nmaximizing the fidelity between the reconstructed state and the\noriginal input state.\n\nThe training data is an ensemble of input states drawn from some\ndistribution. If the ensemble is concentrated in a low-dimensional\nmanifold of the 2^n Hilbert space, the autoencoder can in principle\nreach near-perfect reconstruction at significant compression (m <\nn). If the ensemble is Haar-random pure states, no compression is\nachievable in principle and the average reconstruction fidelity is\nupper bounded by 2^(m-n) (the latent space is too small to hold a\ngeneric state).\n\nThe empirical question this topic addresses is what compression\nfidelity is achievable on a small Haar-random ensemble at a few\ncompression ratios, and whether the trained autoencoder\nmeaningfully beats a random-unitary baseline (which represents the\nnull hypothesis: a random encoder cannot do better than chance).\nThis is the cleanest possible test of \ without confounding from structured ensembles.\n\nImplementation guidance is provided by the quantum-qiskit skill at\nstage 10. The encoder and decoder are EfficientSU2(num_qubits=n,\nreps=3, entanglement='linear') circuits built from\nqiskit.circuit.library. The SWAP-test loss is implemented manually\nvia auxiliary qubits and a Hadamard-controlled-SWAP-Hadamard pattern.\nUse qiskit.primitives.StatevectorSampler for the SWAP-test\nmeasurement and qiskit.primitives.StatevectorEstimator for the\nreconstruction-fidelity diagnostic. Training uses\nqiskit_algorithms.optimizers.COBYLA.minimize() over the SWAP-test\nloss (DO NOT use qiskit_algorithms.VQE — see the quantum-qiskit\nskill's note about qiskit 2.x compatibility).\n\nExperimental protocol. Three quantum compression conditions probe\nthe compression-fidelity tradeoff: compress 4 qubits -> 2 latent,\ncompress 4 -> 3, compress 6 -> 3. Two no-skill baselines establish\nthe floor: no_compression (identity encoder, m=n, fidelity should\nbe ~1.0) and random_unitary_compression (encoder parameters drawn\nrandomly and never trained). Test data is an ensemble of 20\nHaar-random pure states per seed. Each (condition, seed) cell\nreports the mean reconstruction fidelity over the 20 test states.\nTotal: 5 conditions x 1 ensemble x 3 seeds = 15 cells.\n\nResearch question: *On an ensemble of Haar-random pure states, what\nreconstruction fidelity does a trained quantum autoencoder achieve\nat compression ratios 4->2, 4->3, and 6->3, and how much better is\nit than an untrained (random-unitary) encoder at the same\ncompression ratio?*", "num_hypotheses": 3, "hypotheses": "[{\"id\": \"H1\", \"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.\", \"measurable\": true}, {\"id\": \"H2\", \"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.\", \"measurable\": true}, {\"id\": \"H3\", \"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.\", \"measurable\": true}]", "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\": false, \"estimated_wall_clock_sec\": 1200}}", "requirements": "", "rubric": "{\"id\": \"q10-root\", \"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).\", \"weight\": 1, \"sub_tasks\": [{\"id\": \"q10-code\", \"requirements\": \"Code-development bucket: encoder/decoder built from qiskit.circuit.library, SWAP-test or direct-fidelity loss implemented correctly, training pipeline runs.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q10-code-encoder-decoder\", \"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).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Method Implementation\"}, {\"id\": \"q10-code-loss-eval\", \"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).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Method Implementation\"}, {\"id\": \"q10-code-pipeline\", \"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.\", \"weight\": 6.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q10-exec\", \"requirements\": \"Execution-validity bucket: all 15 cells ran with valid outputs.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q10-exec-cells-ran\", \"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.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q10-exec-numerical\", \"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).\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q10-results\", \"requirements\": \"Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\", \"weight\": 3, \"sub_tasks\": [{\"id\": \"q10-result-h1-quant\", \"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.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q10-result-h2-quant\", \"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.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q10-result-h3-quant\", \"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.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q10-result-writeup\", \"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).\weight\sub_tasks\task_category\Result Analysis\finegrained_task_category\Logging, Analysis & Presentation\task_category\finegrained_task_category\task_category\finegrained_task_category\, : 9, : , : } |
|
|
