data/quantum.jsonl

{"id": "Q01", "domain": "quantum", "title": "Comparing quantum data encoding strategies for variational classifiers", "topic": "Comparing quantum data encoding strategies (angle, amplitude, IQP, ZZ feature map) for variational quantum classifiers on small low-dimensional binary classification tasks", "domains": ["quantum-machine-learning", "data-encoding", "feature-maps"], "arxiv_id": null, "venue": "ARC-Bench 2026", "metric_key": "test_accuracy", "metric_direction": "maximize", "gpu_required": false, "est_wall_clock_sec": 1800, "synthesis": "Quantum data encoding is widely regarded as the bottleneck of variational\nquantum machine learning. The way classical features are loaded into a\nquantum state determines what functions the subsequent variational ansatz\ncan express. Three encoding families are compared here: angle encoding\n(single-qubit rotations only, no input entanglement), amplitude encoding\n(information-dense state preparation that loads the classical vector as\nstate amplitudes), and the ZZ feature map (Hadamards plus diagonal\npairwise phase rotations, injecting entanglement at the input layer).\n\nThe research question is direct. Holding the variational ansatz, the\nclassical optimizer, the simulator backend, and the dataset preprocessing\nfixed, which encoding produces the best test accuracy on a moderately\ndifficult 6D binary classification task, and does at least one quantum\nencoding approach the better of two classical baselines (logistic\nregression and a small MLP)?\n\nImplementation guidance is provided by the `quantum-qiskit` skill, which\nis automatically injected into the stage-10 code generation prompt for\nthis topic. Use the skill's reference patterns verbatim: import\n`ZFeatureMap`, `StatePreparation`, and `ZZFeatureMap` from\n`qiskit.circuit.library`; use `qiskit_machine_learning.algorithms.VQC`\nwith the reference Sampler primitive for training; never roll a custom\noptimization loop. Hand-written gate sequences in place of these\nlibrary classes have been observed to produce degenerate ablations\n(three encodings collapsing to nearly identical computations) and will\nfail the rubric.\n\nExperimental protocol. All three quantum encodings share EfficientSU2\nreps=1 linear entanglement as the variational ansatz, COBYLA maxiter=200\nas the optimizer, and the noiseless statevector backend as the simulator.\nTwo classical baselines (LogisticRegression and MLPClassifier) run on\nthe same 6D features. Five random seeds per cell across 5 conditions\nyields 25 total cells. Each per-seed result is logged to stdout as a\nsingle line with the prefix `METRIC_RESULT` followed by a JSON object\ncontaining `condition`, `dataset`, `seed`, and `test_accuracy` keys so\nthe autoclaw sandbox parser can collect structured metrics.\n\nResearch question: *On a moderately difficult 6D binary classification\ntask (LogisticRegression baseline expected around 0.65 to 0.80), does\nthe choice of quantum encoding (angle, amplitude, ZZ) measurably change\nvariational classifier accuracy, and does at least one quantum encoding\napproach the better classical baseline?*", "num_hypotheses": 3, "hypotheses": "[{\"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\": true}, {\"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\": true}, {\"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\": true}]", "experiment_design": "{\"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\": false, \"estimated_wall_clock_sec\": 1800}}", "requirements": "", "rubric": "{\"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\": 1, \"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\": 2, \"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\": false, \"estimated_wall_clock_sec\": 1200}}", "requirements": "", "rubric": "{\"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\": 6.0, \"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\": 6.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q02-exec\", \"requirements\": \"Execution-validity bucket: all cells ran and produced numerically valid outputs.\", \"weight\": 2, \"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\": 10.0, \"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\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q02-results\", \"requirements\": \"Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\", \"weight\": 3, \"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\": 10.0, \"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\": 8.0, \"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\": 8.0, \"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\": 14.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/Q02.yaml", "rubric_file": "tasks/quantum/rubrics/Q02.json"}
{"id": "Q03", "domain": "quantum", "title": "Classical optimizer comparison for VQE on H2 under finite shot noise", "topic": "Benchmarking classical optimizers (SPSA, COBYLA, L-BFGS-B, ADAM) for VQE convergence on H2 under finite shot noise across multiple shot budgets and bond lengths", "domains": ["variational-quantum-eigensolver", "quantum-chemistry", "classical-optimization"], "arxiv_id": null, "venue": "ARC-Bench 2026", "metric_key": "shots_to_chemical_accuracy", "metric_direction": "minimize", "gpu_required": false, "est_wall_clock_sec": 1200, "synthesis": "The Variational Quantum Eigensolver (VQE) is the canonical algorithm\nfor near-term quantum chemistry. The quality of a VQE result depends\non the ansatz, but it also critically depends on the classical\noptimizer that updates variational parameters using noisy energy\nestimates from shot-based measurement. Different optimizers exploit\ngradient information very differently. Gradient-free methods such as\nCOBYLA and Nelder-Mead do not need explicit gradients and may be\nrobust to shot noise but converge slowly in high dimensions.\nSimultaneous Perturbation Stochastic Approximation (SPSA) approximates\nthe gradient using just two function evaluations regardless of\nparameter count, trading gradient quality for evaluation count and\noften dominating in low-shot regimes. Gradient-based methods such as\nL-BFGS-B and ADAM need explicit or finite-difference gradients, which\nare expensive under shot noise because each partial derivative is\nestimated from a noisy function value.\n\nThe choice of optimizer is rarely studied head-to-head under a fixed\nshot budget. Most VQE papers fix the optimizer and tune everything\nelse around it. Here we hold ansatz (hardware-efficient EfficientSU2\nreps=2), Hamiltonian (H2 in STO-3G basis), and initial parameters\n(small random Gaussian) fixed, and vary only the optimizer and the\nshot budget per energy evaluation. The diagnostic question is which\noptimizer reaches chemical accuracy (within 1.6 mHa of the FCI\nreference) using the fewest cumulative shots.\n\nA credible study uses at least two molecular geometries to avoid\noverfitting to a single energy landscape. We use H2 at two bond\nlengths: the equilibrium distance (0.74 angstrom) where the ground\nstate is near Hartree-Fock and the optimization landscape is well\nbehaved, and a stretched geometry (1.5 angstrom) where multireference\ncharacter makes the landscape harder and tests optimizer robustness.\nEach optimizer is run at a SINGLE fixed shot budget of 1024 shots per\nenergy evaluation. This is chosen as a representative middle-ground\nvalue: low enough that shot noise is non-trivial (per-eval std ~15 mHa,\nwell above the 1.6 mHa chemical accuracy threshold, so the running-mean\nconvergence criterion matters), but high enough that some optimizers\ncan plausibly converge within their iteration budgets. All cells use\n3 random seeds per (optimizer, geometry) cell, giving 4 optimizers x\n1 shot budget x 2 geometries x 3 seeds = 24 total cells. Cumulative\nshots is the sum of shots used across all energy evaluations\n(including finite-difference gradient evaluations where applicable).\nThe Hamiltonian itself is constructed via\nqiskit_nature.second_q.drivers.PySCFDriver (qiskit_nature and pyscf\nare required dependencies for this topic; hardcoded Pauli string\nfallbacks are NOT accepted).\n\nImplementation contract (see quantum-qiskit skill for the reference\ncode). In qiskit 2.x, `qiskit_algorithms.VQE` and\n`qiskit_nature.second_q.algorithms` are NOT importable (they depend on\nthe removed `qiskit.primitives.BaseEstimator` V1 interface). VQE MUST\nbe implemented as a manual optimization loop:\nenergy(theta) = estimator.run([(bound_ansatz, qubit_op)]).result()[0].data.evs + e_nuclear,\nusing `qiskit.primitives.StatevectorEstimator` (the V2 primitive that\nworks in qiskit 2.x) for the energy evaluation, and one of the four\noptimizer classes from `qiskit_algorithms.optimizers` (SPSA, COBYLA,\nL_BFGS_B, ADAM) for the parameter update, called via\n`optimizer.minimize(energy, initial_point)`. Each call to `energy`\ncounts as one evaluation; cumulative shots is\n`n_evaluations * shots_per_eval`. The Hamiltonian itself is constructed\nvia qiskit_nature.second_q.drivers.PySCFDriver +\nqiskit_nature.second_q.mappers.ParityMapper (these submodules ARE safe\nto import in qiskit 2.x — only the qiskit_nature.second_q.algorithms\nmodule is broken). With ParityMapper and 2-qubit reduction\n(num_particles=(1,1)), the H2/STO-3G Hamiltonian is 2 qubits, not 4.\nImplement shot noise by adding Gaussian noise to each energy value\nwith sigma = ||H||_1 / sqrt(shots_per_eval). The convergence criterion\nfor shots_to_chemical_accuracy is the cumulative shots when a 5-eval\nrunning mean energy stays within 1.6 mHa of E_FCI for 5 consecutive\nevaluations; if not reached, report None or a sentinel distinct from\nthe upper bound so analysis can flag the cell as \"did not converge\"\nrather than treating the budget cap as a measurement.\n\nResearch question: *Under finite shot noise, which classical optimizer\n(SPSA, COBYLA, L-BFGS-B, ADAM) reaches VQE chemical accuracy using the\nfewest cumulative shots, and how does the answer depend on shot budget\nper evaluation and on Hamiltonian difficulty (equilibrium vs stretched\nH2)?*", "num_hypotheses": 3, "hypotheses": "[{\"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\": true}, {\"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\": true}, {\"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\": true}]", "experiment_design": "{\"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\": false, \"estimated_wall_clock_sec\": 1200}}", "requirements": "", "rubric": "{\"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\": 1, \"sub_tasks\": [{\"id\": \"q03-code\", \"requirements\": \"Code-development bucket: VQE pipeline correctly implements 4 optimizers, both H2 geometries, and accurate cumulative-shot tracking.\", \"weight\": 2, \"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\": 8.0, \"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\": 6.0, \"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\": 6.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q03-exec\", \"requirements\": \"Execution-validity bucket: all cells ran with valid energies and shot accounting.\", \"weight\": 2, \"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\": 10.0, \"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\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q03-results\", \"requirements\": \"Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\", \"weight\": 3, \"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\": 10.0, \"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\": 10.0, \"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 \"does the Fourier structure imposed by re-uploading give a useful\ninductive bias on these targets, or do classical models with comparable\ncapacity match it?\"\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_hypotheses": 3, "hypotheses": "[{\"id\": \"H1\", \"statement\": \"On the sinusoid-mixture target, the L=5 re-uploading model achieves test MSE at least 4 times lower than the L=1 re-uploading model (2-seed mean), demonstrating that increasing re-uploading depth improves regression accuracy on bandwidth-rich targets.\", \"measurable\": true}, {\"id\": \"H2\", \"statement\": \"On the step-function target, the L=7 re-uploading model exhibits overfitting compared to L=5: L=7 test MSE is at least 15 percent higher than L=5 test MSE (2-seed mean), even though L=7 has more parameters and lower training MSE.\", \"measurable\": true}, {\"id\": \"H3\", \"statement\": \"At L=7 on the sinusoid-mixture target, the recovered Fourier spectrum (FFT of the trained circuit's output sampled on a uniform 256-point grid) has cosine similarity at least 0.7 with the target Fourier spectrum, restricted to the lowest 5 nonzero frequencies.\", \"measurable\": true}]", "experiment_design": "{\"research_question\": \"On 1D regression with known target bandwidth, does increasing data re-uploading depth L produce monotonically lower test MSE on bandwidth-rich targets, and does the recovered Fourier spectrum overlap with the target spectrum scale predictably with L?\", \"conditions\": [{\"name\": \"reuploading_L1\", \"description\": \"Single-qubit re-uploading circuit with L=1 encoding block. Encoding: U(x) = RZ(x). Trainable block: W(theta) = RY(theta_0) RZ(theta_1). Output: <Z>. 2 trainable parameters total.\"}, {\"name\": \"reuploading_L3\", \"description\": \"Same single-qubit re-uploading template with L=3 encoding blocks. 6 trainable parameters.\"}, {\"name\": \"reuploading_L5\", \"description\": \"Same template with L=5 encoding blocks. 10 trainable parameters.\"}, {\"name\": \"reuploading_L7\", \"description\": \"Same template with L=7 encoding blocks. 14 trainable parameters.\"}], \"baselines\": [\"rbf_kernel_ridge: sklearn.kernel_ridge.KernelRidge(kernel='rbf', alpha=1e-3, gamma=tuned_via_grid_search). Strong nonparametric regression baseline.\", \"polynomial_regression: sklearn.pipeline.make_pipeline(PolynomialFeatures(degree=7), Ridge(alpha=1e-3)). Matched-capacity polynomial basis baseline.\"], \"metrics\": [{\"name\": \"test_mse\", \"direction\": \"minimize\", \"description\": \"Mean squared error on a 200-point held-out test set, averaged over 2 random seeds per (condition, dataset) cell. Primary metric.\"}, {\"name\": \"train_mse\", \"direction\": \"minimize\", \"description\": \"Mean squared error on the 200-point training set after training completes.\"}, {\"name\": \"fourier_spectrum_cosine\", \"direction\": \"maximize\", \"description\": \"Cosine similarity between the FFT of the trained model's output sampled on a uniform 256-point grid over [0, 1] and the FFT of the target function on the same grid, restricted to the lowest 5 nonzero frequency bins. Higher means the model has learned the target's Fourier content.\"}], \"datasets\": [{\"name\": \"sinusoid_mixture_1d\", \"source\": \"Synthetic generator\", \"description\": \"Target function f(x) = sum_k a_k * sin(2*pi*k*x) for k in {1, 2, 3, 5, 7} with random amplitudes a_k drawn from Uniform[0.5, 1.0] using a fixed dataset-generation seed (independent of per-cell training seeds). 200 training x-values + 200 test x-values uniformly sampled on [0, 1]. Targets are observed with Gaussian noise N(0, 0.05).\"}, {\"name\": \"step_function_1d\", \"source\": \"Synthetic generator\", \"description\": \"Target function f(x) = 1.0 if x > 0.5 else 0.0, plus Gaussian noise N(0, 0.05). Tests how the re-uploading model handles a discontinuity (its Fourier series will exhibit Gibbs ringing). 200 training + 200 test samples.\"}], \"compute_requirements\": {\"gpu_required\": false, \"estimated_wall_clock_sec\": 900}}", "requirements": "", "rubric": "{\"id\": \"q04-root\", \"requirements\": \"A credible empirical study of data re-uploading depth vs Fourier expressivity in variational quantum regression. The agent must (a) implement 4 re-uploading circuits at L in {1, 3, 5, 7} using qiskit ParameterVector + RY/RZ rotation gates, (b) train each with parameter-shift Adam on 200 samples of two 1D regression targets (sinusoid mixture and step function), (c) compare against two classical baselines (RBF kernel ridge regression, polynomial regression degree 7) on the same data, (d) measure test MSE per cell and the recovered Fourier spectrum of the trained quantum model, and (e) score H1/H2/H3 with numerical evidence.\", \"judging_note\": \"Re-uploading topics are scored on (i) whether the 4 quantum circuits actually differ by depth (sanity check: parameter counts must be 2/6/10/14), (ii) whether training was real and produced different outputs across L levels (3 quantum cells producing bit-identical MSE would indicate dispatch failure, same anti-pattern as Q01 ablation failure), (iii) whether classical baselines are computed on the exact same data as quantum cells, and (iv) whether H1/H2/H3 are supported by reported MSE and Fourier-spectrum numbers. Quantitative result leaves use a graded scale: 100% if hypothesis threshold cleanly met, 67% if trend in predicted direction without clearing threshold, 33% if ambiguous, 0% if contradicted or evidence missing.\", \"weight\": 1, \"sub_tasks\": [{\"id\": \"q04-code\", \"requirements\": \"Code-development bucket: 4 re-uploading circuits + 2 classical baselines are implemented correctly with shared training pipeline and reproducible per-cell seed control.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q04-code-circuits\", \"requirements\": \"All four re-uploading circuits use qiskit.QuantumCircuit + qiskit.circuit.ParameterVector. The encoding gate is RZ(x) and the trainable block is RY(theta_2k) RZ(theta_2k+1). Output is the expectation <Z> on the single qubit (via qiskit.quantum_info.Statevector or the reference Estimator primitive). Parameter counts match: L=1 has 2 params, L=3 has 6, L=5 has 10, L=7 has 14. A sanity check asserts that the four circuits produce different output values for a fixed nonzero input x=0.3 with a fixed random parameter vector.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Method Implementation\"}, {\"id\": \"q04-code-training-pipeline\", \"requirements\": \"Training uses Adam with parameter-shift gradients computed via the qiskit parameter-shift rule (NOT scipy finite differences). Loss is mean squared error on the 200 training samples. Same optimizer hyperparameters across all four L levels (Adam lr=0.05, 300 steps). Both classical baselines use sklearn (KernelRidge with grid-searched gamma, and a Pipeline of PolynomialFeatures+Ridge).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}, {\"id\": \"q04-code-metric-logging\", \"requirements\": \"Each per-(condition, dataset, seed) result is emitted to stdout as a single line starting with METRIC_RESULT followed by JSON containing condition, dataset, seed, test_mse, train_mse, and fourier_spectrum_cosine. The FFT is computed on the trained model's output sampled on a uniform 256-point grid over [0, 1].\", \"weight\": 6.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q04-exec\", \"requirements\": \"Execution-validity bucket: all 24 cells ran and produced numerically valid outputs.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q04-exec-cells-ran\", \"requirements\": \"At least 22 cells out of 24 expected (6 conditions x 2 datasets x 2 seeds) completed without unhandled errors and produced a test_mse 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\": \"q04-exec-numerical\", \"requirements\": \"Numerical validity: no NaN or Inf in test_mse; train_mse <= test_mse * 1.5 across conditions (otherwise model is broken); the 4 quantum L levels produce different test MSEs (max - min across the 4 quantum conditions on the sinusoid-mixture dataset is at least 0.005). Fourier spectrum values are real, finite, and the cosine similarity is in [-1, 1].\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q04-results\", \"requirements\": \"Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\", \"weight\": 3, \"sub_tasks\": [{\"id\": \"q04-result-h1-quant\", \"requirements\": \"Quantitative test of H1. On the sinusoid-mixture dataset, is test_mse(L=5) <= test_mse(L=1) / 4 (2-seed mean)? 100% if ratio >= 4, 67% if 2 <= ratio < 4, 33% if 1 < ratio < 2, 0% if L=5 is not better than L=1.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q04-result-h2-quant\", \"requirements\": \"Quantitative test of H2. On the step function dataset, is test_mse(L=7) >= test_mse(L=5) * 1.15 (2-seed mean)? 100% if overshoot is >= 15 percent, 67% if 5-15 percent, 33% if any small overshoot (0-5 percent), 0% if L=7 still has lower MSE.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q04-result-h3-quant\", \"requirements\": \"Quantitative test of H3. On the sinusoid-mixture dataset at L=7, does the recovered Fourier spectrum cosine similarity (restricted to lowest 5 nonzero frequencies) reach 0.7? 100% if >= 0.7, 67% if >= 0.5, 33% if >= 0.3, 0% otherwise.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Logging, Analysis & Presentation\"}, {\"id\": \"q04-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 specific test MSE values per (L, dataset) and Fourier spectrum cosine values. Discusses how the Fourier-series view (Schuld, Sweke, Meyer 2021) predicts the observed trend, and identifies a dominant systematic uncertainty (seed variance, optimizer convergence, parameter-shift gradient noise).\", \"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/Q04.yaml", "rubric_file": "tasks/quantum/rubrics/Q04.json"}
{"id": "Q05", "domain": "quantum", "title": "Barren plateau onset under cost-function locality", "topic": "Barren 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 suppression", "domains": ["quantum-machine-learning", "barren-plateaus", "trainability"], "arxiv_id": null, "venue": "ARC-Bench 2026", "metric_key": "log_gradient_variance", "metric_direction": "maximize", "gpu_required": false, "est_wall_clock_sec": 600, "synthesis": "A 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_hypotheses": 3, "hypotheses": "[{\"id\": \"H1\", \"statement\": \"At ansatz depth L=10, the empirical variance of the gradient under local cost is at least 20 times larger than under global cost (3-seed mean of variance per condition), confirming Cerezo et al. 2021's prediction that locality changes the barren-plateau scaling.\", \"measurable\": true}, {\"id\": \"H2\", \"statement\": \"Under local cost, the gradient variance at L=20 is at least 1/100 of the gradient variance at L=2, i.e. the polynomial (sub-exponential) decay regime is maintained even at deep ansatz, with log10(var_L20) - log10(var_L2) > -2.0 (3-seed mean).\", \"measurable\": true}, {\"id\": \"H3\", \"statement\": \"When trained with Adam for 100 gradient steps starting from random initialization, the global-cost-L10 condition produces a loss change of at most 1 percent of the initial loss (3-seed mean), demonstrating that the predicted barren plateau actively prevents practical training, while the local-cost-L10 condition produces a loss change of at least 10 percent.\", \"measurable\": true}]", "experiment_design": "{\"research_question\": \"Does the local-cost trick avoid the barren plateau on a 6-qubit EfficientSU2 ansatz at L=10 and L=20, as predicted by Cerezo et al. 2021, when compared against the global-cost baseline and a shallow local-cost control?\", \"conditions\": [{\"name\": \"local_cost_L10\", \"description\": \"Proposed-method core. EfficientSU2(num_qubits=6, reps=10, entanglement='linear') ansatz. Cost function: <Z_0> (expectation of Pauli Z on qubit 0 only). 100 random parameter vectors theta drawn from Uniform[-pi, pi]^{n_params}. For each theta, compute parameter-shift gradient dL/dtheta_0 by evaluating L at theta + (pi/2) * e_0 and theta - (pi/2) * e_0. Report variance of these 100 gradient values.\"}, {\"name\": \"local_cost_L20\", \"description\": \"Proposed-method stress test. EfficientSU2 reps=20, same local cost <Z_0>. Tests whether the polynomial-decay prediction holds at deeper ansatz.\"}], \"baselines\": [\"local_cost_L2: trainable-control baseline. EfficientSU2 reps=2, local cost <Z_0>. Known to have non-vanishing gradient because the ansatz is too shallow to enter the barren-plateau regime.\", \"global_cost_L10: barren-plateau negative-control baseline. EfficientSU2 reps=10, global cost <Z_0 Z_1 Z_2 Z_3 Z_4 Z_5> (product of Z on all 6 qubits). Known from Cerezo 2021 to exhibit exponentially small gradient variance even though the ansatz depth matches local_cost_L10.\"], \"metrics\": [{\"name\": \"log_gradient_variance\", \"direction\": \"maximize\", \"description\": \"log10 of the empirical variance of dL/dtheta_0 over 100 random parameter samples. Higher means more trainable gradient signal. Primary metric. Less negative numbers are better (closer to 0).\"}, {\"name\": \"mean_absolute_gradient\", \"direction\": \"maximize\", \"description\": \"Mean of |dL/dtheta_0| over the 100 random samples.\"}, {\"name\": \"training_loss_change_fraction\", \"direction\": \"maximize\", \"description\": \"Relative loss change after 100 Adam steps starting from a random initialization: (L_initial - L_after_100_steps) / |L_initial|. Practical training-feasibility probe. Larger positive means training actually moved the loss.\"}], \"datasets\": [{\"name\": \"random_parameter_samples\", \"source\": \"Synthetic, generated in-script via numpy.random.RandomState(ansatz_structure_seed).uniform(-pi, pi, size=(100, n_params))\", \"description\": \"Each cell samples 100 random parameter vectors in the parameter space of EfficientSU2 at the given (num_qubits, reps). These are the inputs over which gradient variance is estimated. No external data is involved; this is a measurement experiment on the ansatz family.\"}], \"compute_requirements\": {\"gpu_required\": false, \"estimated_wall_clock_sec\": 600}}", "requirements": "", "rubric": "{\"id\": \"q05-root\", \"requirements\": \"An empirical study of barren plateau onset on a 6-qubit EfficientSU2 ansatz under local vs global cost functions and shallow vs deep ansatz. The agent must (a) build the EfficientSU2 ansatz with reps in {2, 10, 20} via qiskit.circuit.library, (b) for each (cost, depth) condition sample 100 random parameter vectors and compute parameter-shift gradient dL/dtheta_0, (c) report the empirical variance of those 100 gradient values per cell, (d) run a 100-step Adam training as a practical sanity probe of trainability, and (e) score H1/H2/H3 with numerical evidence.\", \"judging_note\": \"Barren plateau studies are scored on (i) correctness of the EfficientSU2 / cost construction (using qiskit.circuit.library, not hand-rolled), (ii) whether the 100-sample gradient distribution actually captures the variance (cells reporting std=0 across 100 samples indicate a broken sampler), (iii) the local_cost_L10 vs global_cost_L10 contrast being clean (these have IDENTICAL ansatz, only cost differs, so any large variance gap directly tests Cerezo 2021), and (iv) the training-feasibility probe correlating with the gradient-variance prediction (BP cell should not train; trainable cell should train). Quantitative result leaves use a graded scale: 100% if cleanly met, 67% if in predicted direction without clearing threshold, 33% if ambiguous, 0% if contradicted.\", \"weight\": 1, \"sub_tasks\": [{\"id\": \"q05-code\", \"requirements\": \"Code-development bucket: EfficientSU2 ansatz built correctly via qiskit.circuit.library, parameter-shift gradient implemented correctly, and the 100-sample gradient distribution actually populated per cell.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q05-code-ansatz-and-gradient\", \"requirements\": \"EfficientSU2(num_qubits=6, reps=reps_value, entanglement='linear') from qiskit.circuit.library used directly (NOT hand-coded H/CNOT/RY stacks). Parameter-shift gradient of <O>(theta) with respect to theta_0 computed via the qiskit standard pattern: dL/dtheta_0 = (L(theta + (pi/2)*e_0) - L(theta - (pi/2)*e_0)) / 2. Cost observable for local_cost is Pauli Z on qubit 0; for global_cost is the product Z_0 Z_1 Z_2 Z_3 Z_4 Z_5 (a SparsePauliOp). A sanity check confirms that the gradient is nonzero for at least one random parameter sample at L=2 local cost.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Method Implementation\"}, {\"id\": \"q05-code-sampling\", \"requirements\": \"For each (condition, ansatz-structure seed) cell, 100 independent random parameter vectors are drawn from Uniform[-pi, pi]^{n_params} using a per-cell seeded RNG. For each parameter vector, the gradient dL/dtheta_0 is computed. The 100 gradient values are stored and the empirical variance is reported. Reusing the same parameter vector across conditions in the same cell is allowed (paired comparison) but NOT required.\", \"weight\": 7.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}, {\"id\": \"q05-code-training-probe\", \"requirements\": \"After the gradient-variance measurement, each cell runs a 100-step Adam optimization (qiskit_algorithms.optimizers.ADAM or pytorch Adam wrapping a parameter-shift gradient closure) starting from a random initialization. The initial loss and the loss after step 100 are recorded; the training_loss_change_fraction = (L_initial - L_final) / |L_initial| is computed per cell.\", \"weight\": 7.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q05-exec\", \"requirements\": \"Execution-validity bucket: all 12 cells ran and produced numerically valid outputs.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q05-exec-cells-ran\", \"requirements\": \"At least 11 cells out of 12 expected (4 conditions x 3 ansatz-structure seeds) completed and produced a non-null log_gradient_variance 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\": \"q05-exec-numerical\", \"requirements\": \"Numerical validity: no NaN or Inf in gradient values; empirical std of the 100 gradients is strictly > 0 in every cell (cells reporting std=0 indicate a broken sampler and fail this leaf); log10(variance) values are finite. The training_loss_change_fraction is in the range [-1.0, 1.0] (otherwise loss diverged or wasn't properly normalized).\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q05-results\", \"requirements\": \"Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\", \"weight\": 3, \"sub_tasks\": [{\"id\": \"q05-result-h1-quant\", \"requirements\": \"Quantitative test of H1. Is var(local_cost_L10) / var(global_cost_L10) >= 20 (3-seed mean of variances)? 100% if ratio >= 20, 67% if 5 <= ratio < 20, 33% if 1 < ratio < 5, 0% if global cost has equal or larger variance.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q05-result-h2-quant\", \"requirements\": \"Quantitative test of H2. Is log10(var_local_L20) - log10(var_local_L2) > -2.0 (3-seed mean)? 100% if difference > -2.0 (polynomial decay), 67% if difference > -3.0, 33% if difference > -4.0, 0% otherwise (exponential decay observed).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q05-result-h3-quant\", \"requirements\": \"Quantitative test of H3. Is global_cost_L10 training_loss_change_fraction <= 0.01 AND local_cost_L10 training_loss_change_fraction >= 0.10 (3-seed mean)? 100% if both conditions hold cleanly, 67% if local trains but global change is 1-5 percent, 33% if local trains but global has any change, 0% if global cost also trains (would contradict the BP prediction).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q05-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 specific variance values per (condition, seed) and training_loss_change_fraction values. Explicitly references Cerezo et al. 2021 'Cost function dependent barren plateaus' and discusses whether the observed variance ratio matches their theoretical prediction. Identifies dominant uncertainty (ansatz-structure seed variance, finite-sample variance estimate from 100 gradient samples).\", \"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/Q05.yaml", "rubric_file": "tasks/quantum/rubrics/Q05.json"}
{"id": "Q06", "domain": "quantum", "title": "Neural-network warm-start for QAOA-MaxCut initialization", "topic": "Neural-network warm-start for QAOA-MaxCut: comparing MLP-predicted initial parameters against random and fixed initialization across in-distribution and out-of-distribution graph families", "domains": ["ai-for-quantum", "qaoa", "meta-learning"], "arxiv_id": null, "venue": "ARC-Bench 2026", "metric_key": "iterations_to_target_ratio", "metric_direction": "minimize", "gpu_required": false, "est_wall_clock_sec": 1200, "synthesis": "The 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, \"Graph\nneural network initialisation of QAOA\") 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 \"fixed init at (pi/4, pi/4)\" 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_hypotheses": 3, "hypotheses": "[{\"id\": \"H1\", \"statement\": \"On in-distribution Erdős-Rényi graphs at n=6, the MLP-predicted initialization reaches approximation ratio 0.9 in at most 10 COBYLA iterations on average (3-graph mean), while random initialization requires at least 18 iterations to reach the same target.\", \"measurable\": true}, {\"id\": \"H2\", \"statement\": \"On out-of-distribution 3-regular graphs at n=8, MLP-predicted initialization still beats random initialization by at least 20 percent in iteration count (3-graph median), demonstrating partial transfer of the learned initialization heuristic.\", \"measurable\": true}, {\"id\": \"H3\", \"statement\": \"At p=1 the fixed initialization (beta=gamma=pi/4) is competitive with MLP-predicted initialization: the gap in 3-graph-median iteration count between fixed init and MLP-init is at most 30 percent on in-distribution graphs, consistent with the Brandao 2018 concentration prediction that QAOA-1 parameters concentrate around a problem-independent point.\", \"measurable\": true}]", "experiment_design": "{\"research_question\": \"Does an MLP trained on small Erdős-Rényi graph features predict QAOA-MaxCut initial parameters that reduce COBYLA iteration count compared to random and fixed init, and does the advantage transfer to graphs of a different distribution than the MLP was trained on?\", \"conditions\": [{\"name\": \"mlp_init_in_distribution\", \"description\": \"Proposed method evaluated in-distribution. sklearn.neural_network.MLPRegressor(hidden_layer_sizes=(32, 16), activation='relu', max_iter=2000, random_state=seed) trained offline on 200 Erdős-Rényi G(n=6, p=0.5) graphs with (degree_mean, degree_var, edge_density, n_edges) as features and grid-searched (beta_optimal, gamma_optimal) as targets. At test time, predict initial (beta, gamma) for a fresh in-distribution graph, then run COBYLA QAOA optimization starting from that initialization.\"}, {\"name\": \"mlp_init_out_of_distribution\", \"description\": \"Proposed method evaluated out-of-distribution. Same MLP as mlp_init_in_distribution (trained on Erdős-Rényi G(n=6, p=0.5)). At test time, evaluated on 3-regular graphs at n=8: predict initial (beta, gamma) using the same feature extractor, then run COBYLA QAOA optimization.\"}], \"baselines\": [\"random_init: classical baseline. Initial (beta, gamma) drawn from Uniform[0, pi/2] x Uniform[0, pi/2] using a per-graph seed independent of optimization seed. Then COBYLA QAOA from that point.\", \"fixed_init_pi_over_4: classical baseline from Brandao 2018. Initial (beta, gamma) = (pi/4, pi/4). Then COBYLA QAOA. Tests whether the concentration prediction holds in practice at p=1.\"], \"metrics\": [{\"name\": \"iterations_to_target_ratio\", \"direction\": \"minimize\", \"description\": \"Number of COBYLA iterations required to reach approximation ratio (cut_size / optimal_cut_size) >= 0.9 on each graph, with a hard cap at 20 iterations (cells that don't reach 0.9 within 20 iterations report 20 and success=False). Primary metric. 3-graph median per condition x graph_family cell.\"}, {\"name\": \"final_approximation_ratio\", \"direction\": \"maximize\", \"description\": \"approximation ratio (cut_size / optimal_cut_size) achieved after exactly 20 COBYLA iterations, regardless of whether the target threshold was met. 3-graph mean.\"}, {\"name\": \"success_rate\", \"direction\": \"maximize\", \"description\": \"Fraction of the 3 random graph instances in a cell that reached approximation ratio 0.9 within the 20-iteration budget.\"}], \"datasets\": [{\"name\": \"erdos_renyi_n6_p05\", \"source\": \"networkx.erdos_renyi_graph(n=6, p=0.5, seed=graph_instance_seed)\", \"description\": \"In-distribution test set. 3 fresh random Erdős-Rényi graphs G(n=6, p=0.5), distinct from the 200 graphs used for MLP training. Optimal MaxCut value computed by brute-force enumeration over the 2^6 cuts. QAOA p=1 on AerSimulator statevector backend.\"}, {\"name\": \"regular_3_n8\", \"source\": \"networkx.random_regular_graph(d=3, n=8, seed=graph_instance_seed)\", \"description\": \"Out-of-distribution test set. 3 random 3-regular graphs at n=8 (different size and edge density than the n=6 ER training distribution). Optimal MaxCut value by brute-force enumeration over 2^8 cuts. QAOA p=1 on AerSimulator statevector backend.\"}], \"compute_requirements\": {\"gpu_required\": false, \"estimated_wall_clock_sec\": 1200}}", "requirements": "", "rubric": "{\"id\": \"q06-root\", \"requirements\": \"An empirical study of neural-network warm-start for QAOA-MaxCut at p=1. The agent must (a) precompute 200 Erdős-Rényi G(n=6, p=0.5) training graphs with their optimal (beta, gamma) via grid search to label the MLP training set, (b) train sklearn.MLPRegressor to predict (beta, gamma) from graph features, (c) at test time, predict (beta, gamma) and run COBYLA QAOA optimization starting from that init for up to 20 iterations, (d) compare against random and fixed (pi/4, pi/4) initialization baselines on both in-distribution (ER G(n=6, p=0.5)) and out-of-distribution (3-regular n=8) test graphs, and (e) score H1/H2/H3 with numerical evidence.\", \"judging_note\": \"QAOA warm-start studies are scored on (i) whether the MLP is actually trained offline (cells reporting identical MLP predictions across different graph instances indicate the model is broken or untrained), (ii) whether the 4 initialization strategies actually produce different starting (beta, gamma) points (must be verified by sanity check), (iii) whether COBYLA is run from each init for exactly 20 iterations and the approximation_ratio trajectory is recorded, and (iv) whether H1/H2/H3 are supported by 3-graph-median numerical evidence keyed by (condition, graph_family). Quantitative result leaves use a graded scale.\", \"weight\": 1, \"sub_tasks\": [{\"id\": \"q06-code\", \"requirements\": \"Code-development bucket: QAOA p=1 circuit built via qiskit.circuit.library or hand-coded RX/RZ + CNOT correctly, MLP trained offline on graph features, and 4 initialization conditions actually produce different starting points.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q06-code-qaoa-circuit\", \"requirements\": \"QAOA p=1 circuit for MaxCut implemented correctly: H^{otimes n} initial state, then U_C(gamma) = product over edges of exp(-i * gamma * Z_i Z_j), then U_B(beta) = product over qubits of exp(-i * beta * X_i). Run on qiskit AerSimulator statevector backend; observable is the cut Hamiltonian sum_{(i,j) in E} (1 - Z_i Z_j) / 2. Optimization via qiskit_algorithms.optimizers.COBYLA(maxiter=20).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Method Implementation\"}, {\"id\": \"q06-code-mlp-training\", \"requirements\": \"Offline phase: generate 200 random ER G(n=6, p=0.5) graphs with a different RNG than the test set. For each, compute the optimal (beta_optimal, gamma_optimal) via a 20x20 grid search on (beta, gamma) in [0, pi/2]^2 maximizing the QAOA p=1 expected cut size. Extract 4 graph features (degree_mean, degree_var, edge_density, n_edges) and fit sklearn.neural_network.MLPRegressor(hidden_layer_sizes=(32, 16), max_iter=2000) to map features -> (beta_optimal, gamma_optimal). The trained MLP is reused for both in-distribution and out-of-distribution test conditions.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Method Implementation\"}, {\"id\": \"q06-code-init-conditions\", \"requirements\": \"The 4 initialization strategies produce different starting (beta, gamma) per test graph. Sanity check: for 3 test graphs, log the initial (beta, gamma) for each of the 4 conditions and verify they are not all equal. Each condition's COBYLA optimization is run for exactly 20 iterations, and the cut size at each iteration is recorded so the iterations_to_target_ratio can be computed by replaying the trajectory.\", \"weight\": 6.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q06-exec\", \"requirements\": \"Execution-validity bucket: all cells ran and produced numerically valid outputs.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q06-exec-cells-ran\", \"requirements\": \"At least 22 cells out of 24 expected (4 conditions x 2 graph families x 3 seeds) completed and produced an iterations_to_target_ratio value (clamped to 20 if not reached). 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\": \"q06-exec-numerical\", \"requirements\": \"Numerical validity: iterations_to_target_ratio is in [1, 20] (integer-valued, since COBYLA budget is 20); final_approximation_ratio is in [0, 1]; success_rate is in [0, 1]. At least one cell across the entire 24-cell sweep reaches AR >= 0.9 within 20 iterations (otherwise threshold is uncalibrated).\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q06-results\", \"requirements\": \"Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\", \"weight\": 3, \"sub_tasks\": [{\"id\": \"q06-result-h1-quant\", \"requirements\": \"Quantitative test of H1. On in-distribution ER G(n=6, p=0.5) graphs, does mlp_init_in_distribution reach AR>=0.9 in <= 10 COBYLA iterations on 3-graph mean, while random_init requires >= 18? 100% if MLP <= 10 AND random >= 18, 67% if MLP at least 30 percent better than random, 33% if MLP marginally better than random, 0% if random equals or beats MLP.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q06-result-h2-quant\", \"requirements\": \"Quantitative test of H2. On out-of-distribution 3-regular n=8 graphs, does mlp_init_out_of_distribution beat random_init by at least 20 percent in 3-graph-median iterations_to_target_ratio? 100% if mlp gain >= 20 percent, 67% if mlp gain 10-20 percent, 33% if mlp marginally faster, 0% if no transfer (random matches or beats MLP).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q06-result-h3-quant\", \"requirements\": \"Quantitative test of H3. On in-distribution graphs, is the 3-graph-median iteration-count gap between fixed_init_pi_over_4 and mlp_init_in_distribution <= 30 percent (i.e. fixed init is competitive with MLP at p=1, consistent with Brandao 2018 concentration)? 100% if gap <= 30 percent, 67% if 30-60 percent, 33% if 60-100 percent, 0% if MLP is more than 2x better than fixed init (would refute the concentration interpretation).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q06-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 per-(condition, graph_family) median iteration counts and approximation ratios. References Brandao et al. 2018 concentration result and Jain et al. Quantum 2022 GNN-init paper. Discusses whether the observed out-of-distribution transfer rate is high enough that MLP-init is worth the offline training cost compared to fixed init.\", \"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/Q06.yaml", "rubric_file": "tasks/quantum/rubrics/Q06.json"}
{"id": "Q07", "domain": "quantum", "title": "Matrix Product State classifier vs neural network at matched parameter count", "topic": "Matrix 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 QML", "domains": ["quantum-inspired-classical", "tensor-networks", "supervised-learning"], "arxiv_id": null, "venue": "ARC-Bench 2026", "metric_key": "test_accuracy", "metric_direction": "maximize", "gpu_required": false, "est_wall_clock_sec": 1500, "synthesis": "A 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 \"bond\" 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 \"at matched small parameter\ncounts, is the MPS inductive bias competitive with a small CNN's\nspatial bias on 8x8 downsampled MNIST and Fashion-MNIST?\" 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_hypotheses": 3, "hypotheses": "[{\"id\": \"H1\", \"statement\": \"On 8x8 downsampled MNIST, the MPS classifier at bond dimension chi=16 reaches at least 92 percent test accuracy (3-seed mean), matching the Stoudenmire & Schwab 2016 result scaled to this image size.\", \"measurable\": true}, {\"id\": \"H2\", \"statement\": \"On 8x8 downsampled Fashion-MNIST, the parameter-matched CNN beats the chi=16 MPS classifier by at least 5 absolute percentage points (3-seed mean), reflecting the CNN's stronger inductive bias for spatial texture features that are more important on Fashion-MNIST than on plain digits.\", \"measurable\": true}, {\"id\": \"H3\", \"statement\": \"Test accuracy of the MPS classifier scales log-linearly with bond dimension: on 8x8 MNIST the chi=4 to chi=8 gain in 3-seed mean accuracy is greater than the chi=8 to chi=16 gain (consistent with saturating expressivity at moderate chi).\", \"measurable\": true}]", "experiment_design": "{\"research_question\": \"On 8x8 downsampled MNIST and Fashion-MNIST, do MPS classifiers at moderate bond dimension chi reach the test accuracy of a parameter-matched CNN, and how does accuracy scale with chi?\", \"conditions\": [{\"name\": \"mps_chi4\", \"description\": \"Matrix Product State classifier with bond dimension chi=4. 64 pixels x 2-dim per-pixel feature embedding x chi=4 bonds, with a per-class output index. Approximate parameter count: 64 * 2 * 4 * 4 = 2048 parameters. Trained with Adam on cross-entropy for 50 epochs.\"}, {\"name\": \"mps_chi8\", \"description\": \"MPS classifier with chi=8. Approximate parameter count: 64 * 2 * 8 * 8 = 8192. Trained with Adam on cross-entropy for 50 epochs.\"}, {\"name\": \"mps_chi16\", \"description\": \"MPS classifier with chi=16. Approximate parameter count: 64 * 2 * 16 * 16 = 32768. Trained with Adam on cross-entropy for 50 epochs.\"}], \"baselines\": [\"logistic_regression: sklearn.linear_model.LogisticRegression(C=1.0, max_iter=1000, multi_class='multinomial') on flattened 8x8 pixels. Classical linear baseline, ~640 parameters.\", \"small_cnn_matched: PyTorch CNN with a single 3x3 conv layer of K=12 filters followed by an FC(K*6*6, 10) output, chosen so total parameter count is within 10 percent of the chi=8 MPS (target ~8200 parameters). Trained with Adam for 50 epochs.\"], \"metrics\": [{\"name\": \"test_accuracy\", \"direction\": \"maximize\", \"description\": \"Top-1 classification accuracy on the 1000-image held-out test set, 3-seed mean. Primary metric.\"}, {\"name\": \"trainable_parameter_count\", \"direction\": \"minimize\", \"description\": \"Total number of trainable parameters in the model. Reported for parity validation across conditions: matched-parameter comparisons require this to be within 10 percent across the relevant condition pair.\"}, {\"name\": \"training_time_sec\", \"direction\": \"minimize\", \"description\": \"Wall-clock seconds for 50 epochs of training, measured per cell. Tests the practical compute cost of each method at matched accuracy.\"}], \"datasets\": [{\"name\": \"mnist_8x8_downsampled\", \"source\": \"sklearn.datasets.fetch_openml('mnist_784') downsampled to 8x8 via skimage.transform.resize\", \"description\": \"MNIST handwritten digits 0-9, downsampled from 28x28 to 8x8 grayscale, normalized to [0, 1]. 5000 training images, 1000 test images (stratified split, fixed random_state=seed). The 8x8 resolution is small enough for CPU MPS contraction but large enough to retain class structure (LogReg should reach ~85 percent here).\"}, {\"name\": \"fashion_mnist_8x8_downsampled\", \"source\": \"sklearn.datasets.fetch_openml('Fashion-MNIST') downsampled to 8x8\", \"description\": \"Fashion-MNIST clothing items (T-shirt, trouser, pullover, etc.) downsampled from 28x28 to 8x8. Tests model performance on texture-rich images where CNN inductive bias should be more important than for handwritten digits.\"}], \"compute_requirements\": {\"gpu_required\": false, \"estimated_wall_clock_sec\": 1500}}", "requirements": "", "rubric": "{\"id\": \"q07-root\", \"requirements\": \"An empirical study of Matrix Product State (MPS) classifiers vs neural network baselines at matched parameter count on 8x8 downsampled image classification. The agent must (a) build an MPS classifier following Stoudenmire and Schwab 2016 with cos/sin per-pixel feature embedding and bond dimensions chi in {4, 8, 16}, (b) train each MPS via Adam for 50 epochs on 5000 training images, (c) compare against sklearn LogisticRegression and a small PyTorch CNN whose parameter count is within 10 percent of the chi=8 MPS, (d) evaluate test accuracy on a 1000-image held-out set, and (e) score H1/H2/H3 with numerical evidence.\", \"judging_note\": \"MPS classifier studies are scored on (i) correctness of the MPS contraction (the per-pixel features cos(pi*x/2), sin(pi*x/2) must enter as a rank-2 tensor at each site, NOT collapsed to a single scalar), (ii) the parameter-count parity between chi=8 MPS and small_cnn_matched within 10 percent (deviation > 10 percent fails q11-code-cnn-parity), (iii) the same train/test split being used across all conditions for a given seed, and (iv) accuracy values being in [0, 1] with non-degenerate predictions. Quantitative result leaves use a graded scale.\", \"weight\": 1, \"sub_tasks\": [{\"id\": \"q07-code\", \"requirements\": \"Code-development bucket: MPS classifier implemented correctly with proper per-pixel feature embedding, CNN baseline parameter-matched, and training pipeline shared across conditions.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q07-code-mps\", \"requirements\": \"MPS classifier uses pure NumPy or PyTorch tensor contractions. Per-pixel feature embedding is phi(x) = [cos(pi*x/2), sin(pi*x/2)] for grayscale x in [0,1] (Stoudenmire and Schwab 2016 standard). The MPS is a chain of 64 tensors of shape (chi, 2, chi) (interior sites) plus 2 boundary tensors with one chi leg removed, with one site carrying an additional class index of size 10. Trained with Adam (lr=0.01, 50 epochs, batch_size=64). A sanity check confirms that MPS at chi=4 has approximately 64 * 2 * 16 = 2048 trainable parameters within 20 percent.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Method Implementation\"}, {\"id\": \"q07-code-cnn-parity\", \"requirements\": \"small_cnn_matched is implemented in PyTorch as Conv2d(1, K, kernel_size=3, padding=1) + ReLU + Flatten + Linear(K*8*8, 10) with K chosen so total parameter count is within 10 percent of the chi=8 MPS parameter count. K is calculated explicitly and the parameter counts are logged for both. Trained with Adam (same hyperparams as MPS) for 50 epochs.\", \"weight\": 7.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}, {\"id\": \"q07-code-pipeline\", \"requirements\": \"Nested loop over 5 conditions x 2 datasets x 3 seeds = 30 cells. Each cell uses the same train/test split given a fixed seed (i.e. the per-seed split is computed once and shared across the 5 conditions). MNIST is downsampled to 8x8 via skimage.transform.resize. Per-cell results are logged to stdout as METRIC_RESULT JSON lines containing condition, dataset, seed, test_accuracy, trainable_parameter_count, training_time_sec.\", \"weight\": 7.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q07-exec\", \"requirements\": \"Execution-validity bucket: all 30 cells ran with valid outputs.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q07-exec-cells-ran\", \"requirements\": \"At least 27 cells out of 30 expected (5 conditions x 2 datasets x 3 seeds) completed without unhandled errors and produced a test_accuracy value. Missing more than 3 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\": \"q07-exec-numerical\", \"requirements\": \"Numerical validity: test_accuracy values are in [0, 1], not equal to 1/n_classes (would mean random predictions, model didn't train), and the 3 MPS chi levels produce different mean test_accuracy on at least one dataset (max - min across chi=4/8/16 mean accuracy on MNIST is at least 0.01). trainable_parameter_count is reported per cell and matches the expected formula within 1 percent.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q07-results\", \"requirements\": \"Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\", \"weight\": 3, \"sub_tasks\": [{\"id\": \"q07-result-h1-quant\", \"requirements\": \"Quantitative test of H1. Does the MPS at chi=16 reach test_accuracy >= 92 percent on 8x8 downsampled MNIST (3-seed mean)? 100% if >= 92 percent, 67% if >= 85 percent, 33% if >= 75 percent, 0% otherwise.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q07-result-h2-quant\", \"requirements\": \"Quantitative test of H2. On 8x8 Fashion-MNIST, does the parameter-matched CNN beat chi=16 MPS by at least 5 absolute percentage points (3-seed mean)? 100% if CNN gap >= 5pp, 67% if CNN gap 2-5pp, 33% if CNN gap 0-2pp, 0% if MPS matches or beats CNN.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q07-result-h3-quant\", \"requirements\": \"Quantitative test of H3. On 8x8 MNIST, is the chi=4 to chi=8 accuracy gain greater than the chi=8 to chi=16 accuracy gain (3-seed mean)? Specifically: (acc_chi8 - acc_chi4) > (acc_chi16 - acc_chi8). 100% if cleanly satisfied with difference of differences >= 1pp, 67% if log-linear trend holds with smaller gap, 33% if marginally so, 0% if linear or super-linear scaling observed.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q07-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 per-(condition, dataset) mean test accuracies and the trainable_parameter_count parity check between chi=8 MPS and small_cnn_matched. References Stoudenmire and Schwab NeurIPS 2016 and discusses whether the observed MNIST vs Fashion-MNIST gap is consistent with the CNN's stronger spatial-bias inductive prior.\", \"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/Q07.yaml", "rubric_file": "tasks/quantum/rubrics/Q07.json"}
{"id": "Q08", "domain": "quantum", "title": "Layerwise learning vs end-to-end training for variational quantum classifiers", "topic": "Layerwise 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 tasks", "domains": ["quantum-machine-learning", "training-strategies", "barren-plateaus"], "arxiv_id": null, "venue": "ARC-Bench 2026", "metric_key": "test_accuracy", "metric_direction": "maximize", "gpu_required": false, "est_wall_clock_sec": 1500, "synthesis": "Variational 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\"Layerwise learning for quantum neural networks\") 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_hypotheses": 3, "hypotheses": "[{\"id\": \"H1\", \"statement\": \"Layerwise training reaches higher test accuracy than end-to-end training on at least 1 of 2 datasets, with a 3-seed-mean gap of at least 3 absolute percentage points.\", \"measurable\": true}, {\"id\": \"H2\", \"statement\": \"The mean gradient norm during the first 10 optimization steps of the layerwise schedule (averaged across all newly added blocks) is at least 5 times larger than the mean gradient norm during the first 10 steps of end-to-end training (3-seed mean), confirming the Skolik 2021 mechanism.\", \"measurable\": true}, {\"id\": \"H3\", \"statement\": \"Both layerwise and end-to-end VQC outperform the random-init control (no training) by at least 5 absolute percentage points on both datasets (3-seed mean), confirming that training actually contributes — the ansatz itself is not memorizing class structure at initialization.\", \"measurable\": true}]", "experiment_design": "{\"research_question\": \"Does layerwise incremental training of a 4-qubit reps=5 VQC reach higher test accuracy or faster convergence than end-to-end training of the same ansatz on small UCI binary classification?\", \"conditions\": [{\"name\": \"layerwise_growth\", \"description\": \"EfficientSU2(num_qubits=4, reps=5, entanglement='linear'). Training schedule: (1) train only the first reps=1 block via VQC.fit() for 80 COBYLA iterations; (2) freeze those parameters, add a fresh reps=1 block initialized to small N(0, 0.01) noise, train only the new block for 80 iterations; repeat until all 5 blocks are trained. Record the gradient norm at the start of each new layer's training.\"}, {\"name\": \"end_to_end\", \"description\": \"EfficientSU2(num_qubits=4, reps=5, entanglement='linear'). Single VQC.fit() call training all 40 parameters simultaneously from random N(0, 0.1) initialization for 400 COBYLA iterations (5 x 80, matching the total iteration budget of the layerwise schedule).\"}, {\"name\": \"random_init_control\", \"description\": \"Same EfficientSU2 ansatz, parameters drawn from Uniform[-pi, pi] and NEVER trained. Evaluate predict() directly on the test set. Floor for trainability — any trained model should beat this.\"}], \"baselines\": [\"logistic_regression: sklearn.linear_model.LogisticRegression(max_iter=1000, random_state=seed). Linear classical baseline.\", \"mlp_matched: sklearn.neural_network.MLPClassifier(hidden_layer_sizes=(8,), activation='relu', max_iter=500, random_state=seed). Parameter count: 4*8 + 8 + 8*1 + 1 = 49 parameters, within 20 percent of the VQC's 40 parameters.\"], \"metrics\": [{\"name\": \"test_accuracy\", \"direction\": \"maximize\", \"description\": \"Held-out 20 percent test split accuracy, 3-seed mean. Primary metric.\"}, {\"name\": \"mean_gradient_norm_first10\", \"direction\": \"maximize\", \"description\": \"L2 norm of the gradient vector averaged across the first 10 optimization steps. For layerwise, averaged across the first 10 steps of each newly added block. For end-to-end, the first 10 steps of the single training run. Tests the Skolik mechanism.\"}, {\"name\": \"iterations_to_target_accuracy\", \"direction\": \"minimize\", \"description\": \"Number of total COBYLA iterations to reach test accuracy >= 0.8 (or to budget 400 if never reached). Tests practical convergence speed.\"}], \"datasets\": [{\"name\": \"uci_iris_binary_pca4\", \"source\": \"sklearn.datasets.load_iris + PCA to 4 dimensions\", \"description\": \"Iris dataset restricted to classes {versicolor=1, virginica=2} (binary, 100 samples). PCA to 4 dimensions on standard-scaled features. 80/20 split. Approximately linearly separable; logistic regression should reach >=85 percent.\"}, {\"name\": \"breast_cancer_pca4\", \"source\": \"sklearn.datasets.load_breast_cancer + PCA to 4 dimensions\", \"description\": \"Wisconsin breast cancer dataset, 569 samples, 30 features reduced to 4 via PCA. 80/20 split. Non-trivially separable; logistic regression reaches around 0.92.\"}], \"compute_requirements\": {\"gpu_required\": false, \"estimated_wall_clock_sec\": 1500}}", "requirements": "", "rubric": "{\"id\": \"q08-root\", \"requirements\": \"An empirical study of layerwise vs end-to-end training of a 4-qubit reps=5 EfficientSU2 VQC on UCI binary classification (iris-binary and breast-cancer). The agent must (a) implement the layerwise training schedule manually (train reps=1, freeze, add reps=1, train, ...), (b) implement the end-to-end baseline that trains all 5 reps together, (c) measure mean gradient norm during the first 10 optimization steps of each schedule to test the Skolik 2021 mechanism, and (d) compare against logistic regression + parameter-matched MLP baselines. Score H1/H2/H3 with numerical evidence.\", \"judging_note\": \"Layerwise studies are scored on (i) correctness of the freeze-and-add mechanism (verifiable: the layerwise condition should have N optimizer.minimize() calls each operating on a subset of parameters, not 1 single call over all parameters), (ii) parameter counts matching across conditions (the layerwise and end-to-end VQCs must end with the same 40-parameter ansatz), (iii) the gradient-norm probe being measured at consistent points across conditions, (iv) the random-init control producing accuracy near 0.5 on both datasets (otherwise the ansatz is leaking labels through initialization).\", \"weight\": 1, \"sub_tasks\": [{\"id\": \"q08-code\", \"requirements\": \"Code-development bucket: layerwise freeze-and-add schedule implemented manually, classical baselines parameter-matched, gradient-norm probe consistent.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q08-code-layerwise-mechanism\", \"requirements\": \"The layerwise condition trains the EfficientSU2(reps=5) ansatz by 5 sequential optimizer.minimize() calls. Each call trains only the parameters belonging to the newly added reps=1 block while the previous blocks have their parameters bound to their previously converged values via qiskit.QuantumCircuit.assign_parameters() on a partial dictionary. After all 5 calls the final fitted VQC has 40 trainable parameters, identical in count to the end-to-end VQC.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Method Implementation\"}, {\"id\": \"q08-code-gradient-probe\", \"requirements\": \"Mean gradient norm during the first 10 optimization steps is recorded per condition via the qiskit_machine_learning VQC callback or via a custom wrapper around the loss function that uses parameter-shift gradients. For layerwise, the metric is averaged across the first 10 steps of each newly added block (so total of 50 steps averaged, since 5 blocks x 10). For end-to-end, the metric is the first 10 steps of the single training run.\", \"weight\": 7.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q08-code-classical-baselines\", \"requirements\": \"mlp_matched uses sklearn.neural_network.MLPClassifier(hidden_layer_sizes=(8,)) for ~49 parameters, within 20 percent of the VQC's 40 parameters. logistic_regression uses sklearn.linear_model.LogisticRegression(max_iter=1000). Both train on the same 80/20 train/test split as the VQC conditions using the same per-seed random_state.\", \"weight\": 6.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q08-exec\", \"requirements\": \"Execution-validity bucket: all 30 cells ran and produced numerically valid outputs.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q08-exec-cells-ran\", \"requirements\": \"At least 27 cells out of 30 expected (5 conditions x 2 datasets x 3 seeds) completed without unhandled errors and produced a test_accuracy value. Missing more than 3 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\": \"q08-exec-numerical\", \"requirements\": \"Numerical validity: test_accuracy in [0, 1] with non-degenerate predictions (no condition collapses to a single-class predictor on all test samples). The random_init_control condition produces test_accuracy approximately 0.5 +/- 0.1 on both datasets (otherwise label leakage in the untrained ansatz). mean_gradient_norm_first10 is strictly positive across all cells.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q08-results\", \"requirements\": \"Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\", \"weight\": 3, \"sub_tasks\": [{\"id\": \"q08-result-h1-quant\", \"requirements\": \"Quantitative test of H1. On at least 1 of 2 datasets, is layerwise test_accuracy >= end-to-end test_accuracy + 3 absolute pp (3-seed mean)? 100% if gap >= 3pp on at least 1 dataset, 67% if gap >= 1pp on at least 1 dataset, 33% if layerwise marginally faster on any dataset, 0% if end-to-end equals or beats layerwise on both datasets.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q08-result-h2-quant\", \"requirements\": \"Quantitative test of H2. Is mean_gradient_norm_first10 of layerwise >= 5x mean_gradient_norm_first10 of end-to-end (3-seed mean, across both datasets combined)? 100% if ratio >= 5x, 67% if 2-5x, 33% if any positive ratio (layerwise > end-to-end), 0% otherwise.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q08-result-h3-quant\", \"requirements\": \"Quantitative test of H3. Do both layerwise and end-to-end test_accuracy exceed random_init_control test_accuracy by >= 5 absolute pp on both datasets (3-seed mean)? 100% if both gaps >= 5pp on both datasets, 67% if both on 1 dataset, 33% if at least one VQC beats random anywhere, 0% if random matches or beats trained VQCs.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q08-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 specific 3-seed mean test_accuracy, mean_gradient_norm_first10, and iterations_to_target_accuracy values per (condition, dataset). References Skolik et al. Quantum 2021 and discusses whether the layerwise gradient-norm advantage matches their theoretical prediction.\", \"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/Q08.yaml", "rubric_file": "tasks/quantum/rubrics/Q08.json"}
{"id": "Q09", "domain": "quantum", "title": "Noise-aware variational quantum classifier training", "topic": "Noise-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 transfer", "domains": ["ai-for-quantum", "noisy-quantum-training", "robustness"], "arxiv_id": null, "venue": "ARC-Bench 2026", "metric_key": "test_accuracy", "metric_direction": "maximize", "gpu_required": false, "est_wall_clock_sec": 1500, "synthesis": "Real 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 \"QuantumNAS: Noise-Adaptive Search for Robust Quantum\nCircuits\") and Sharma et al. (PRX Quantum 2022 \"Trainability of\ndissipative perceptron-based quantum neural networks\") 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 \"deployment noise rate\") 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_hypotheses": 3, "hypotheses": "[{\"id\": \"H1\", \"statement\": \"On the noisy test set at p=0.01, the noisy-trained-mid VQC (training noise p=0.005) achieves test accuracy at least 5 absolute percentage points higher than the ideal-trained VQC (3-seed mean), demonstrating that moderate noise-aware training improves test-time noise robustness.\", \"measurable\": true}, {\"id\": \"H2\", \"statement\": \"On the ideal test set (noiseless), the ideal-trained VQC outperforms every noisy-trained variant by at least 2 absolute percentage points (3-seed mean), reflecting the no-free-lunch tradeoff that noise-aware training sacrifices some clean-test accuracy.\", \"measurable\": true}, {\"id\": \"H3\", \"statement\": \"The high-noise-trained VQC (training noise p=0.01) performs worse than the mid-noise-trained VQC on BOTH clean and noisy test sets (3-seed mean), indicating that p=0.01 is past the sweet spot and the optimizer is overfitting to noise statistics — negative transfer.\", \"measurable\": true}]", "experiment_design": "{\"research_question\": \"Does noise-aware VQC training at a moderate training noise rate (p=0.005) produce a model more robust to test-time depolarizing noise than ideal training, and does high training noise cause negative transfer on clean test data?\", \"conditions\": [{\"name\": \"train_ideal\", \"description\": \"VQC trained on noiseless qiskit.primitives.StatevectorSampler. EfficientSU2(num_qubits=4, reps=2, entanglement='linear') ansatz + ZFeatureMap feature map. qiskit_machine_learning.VQC(optimizer=COBYLA(maxiter=200), sampler=StatevectorSampler()). After training, evaluate on BOTH ideal test (StatevectorSampler) and noisy test (depolarizing p=0.01 NoiseModel).\"}, {\"name\": \"train_noisy_low\", \"description\": \"Same ansatz + feature map. VQC trained on a noisy AerSimulator with depolarizing channel p=0.001 applied after every single-qubit and two-qubit gate. Same COBYLA maxiter=200. Evaluate on both ideal and noisy test sets.\"}, {\"name\": \"train_noisy_mid\", \"description\": \"Same as train_noisy_low but training noise rate p=0.005.\"}, {\"name\": \"train_noisy_high\", \"description\": \"Same as train_noisy_low but training noise rate p=0.01 (matches the test-noise rate).\"}], \"baselines\": [\"no_training_control: Same ansatz but parameters randomly initialized and never trained. Evaluate predict() directly on both test sets. Establishes the untrained floor.\", \"logistic_regression: sklearn.linear_model.LogisticRegression(max_iter=1000, random_state=seed) on the same 4 features. Classical baseline.\"], \"metrics\": [{\"name\": \"test_accuracy\", \"direction\": \"maximize\", \"description\": \"Average of test_accuracy_ideal and test_accuracy_noisy_p01, 3-seed mean. Primary metric for the bench.\"}, {\"name\": \"test_accuracy_ideal\", \"direction\": \"maximize\", \"description\": \"Test accuracy on the noiseless test set (StatevectorSampler evaluation), 3-seed mean.\"}, {\"name\": \"test_accuracy_noisy_p01\", \"direction\": \"maximize\", \"description\": \"Test accuracy on the noisy test set at depolarizing rate p=0.01 (AerSimulator with NoiseModel), 3-seed mean. The 'deployment-noise' robustness metric.\"}], \"datasets\": [{\"name\": \"synthetic_classification_4d_sep05\", \"source\": \"sklearn.datasets.make_classification\", \"description\": \"make_classification(n_samples=200, n_features=4, n_informative=3, n_redundant=0, n_clusters_per_class=1, class_sep=0.5, flip_y=0.05, random_state=seed). Moderately difficult binary classification, native 4D. StandardScaler fit on train only. 80/20 split.\"}], \"compute_requirements\": {\"gpu_required\": false, \"estimated_wall_clock_sec\": 1500}}", "requirements": "", "rubric": "{\"id\": \"q09-root\", \"requirements\": \"An empirical study of noise-aware VQC training. Four quantum training conditions vary the training-time depolarizing noise rate (ideal, p=0.001, p=0.005, p=0.01), evaluated on both an ideal test set and a noisy test set at p=0.01. The agent must (a) implement the noise model via qiskit_aer.NoiseModel applying single-qubit and two-qubit depolarizing channels, (b) train VQC under each noise level using qiskit_machine_learning.VQC with the appropriate sampler, (c) evaluate each trained model on BOTH ideal and noisy test sets to expose the robustness-vs-clean-accuracy tradeoff, and (d) score H1/H2/H3 with numerical evidence.\", \"judging_note\": \"Noise-aware training studies are scored on (i) correctness of the qiskit_aer NoiseModel construction (depolarizing channel must be applied after every gate, not only after measurement; verifiable by inspecting the agent's noise model setup), (ii) test_accuracy reporting BOTH ideal and noisy variants per cell (without both, H1 cannot be evaluated), (iii) the noise-rate sweep producing visibly different test accuracies (cells reporting identical numbers across noise levels indicate the noise model is not actually being applied during training), and (iv) numerical evidence backing the three-way comparison: ideal-train vs noisy-mid-train vs noisy-high-train.\", \"weight\": 1, \"sub_tasks\": [{\"id\": \"q09-code\", \"requirements\": \"Code-development bucket: NoiseModel correctly constructed, training pipeline applies noise, evaluation on both ideal and noisy test.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q09-code-noise-model\", \"requirements\": \"qiskit_aer.NoiseModel with depolarizing_error applied to all single-qubit gates (h, ry, rz, etc.) AND two-qubit gates (cx). For a noisy-train condition at rate p, the single-qubit error rate is p and the two-qubit error rate is p (or some agent-documented scaling of p). A sanity check verifies that the same ansatz parameters produce different expectation values under the noise model vs under StatevectorSampler (otherwise the noise is not being applied).\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Method Implementation\"}, {\"id\": \"q09-code-training-pipeline\", \"requirements\": \"Each training condition uses qiskit_machine_learning.VQC with a qiskit.primitives.BackendSamplerV2 (or BackendSampler) bound to either AerSimulator (for noisy training) or StatevectorSampler (for ideal training). Same ansatz family (EfficientSU2 num_qubits=4 reps=2 entanglement='linear'), same optimizer (COBYLA maxiter=200), same per-seed random initialization across noise-rate conditions for paired comparison.\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Experimental Setup\"}, {\"id\": \"q09-code-dual-eval\", \"requirements\": \"Each trained VQC is evaluated on TWO test sets: (a) ideal StatevectorSampler (test_accuracy_ideal), (b) noisy AerSimulator at depolarizing p=0.01 (test_accuracy_noisy_p01). Both numbers are logged per cell. The primary 'test_accuracy' metric is the average of the two. Each cell's METRIC_RESULT JSON includes all three numbers.\", \"weight\": 6.0, \"sub_tasks\": [], \"task_category\": \"Code Development\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q09-exec\", \"requirements\": \"Execution-validity bucket: all 18 cells ran with valid outputs.\", \"weight\": 2, \"sub_tasks\": [{\"id\": \"q09-exec-cells-ran\", \"requirements\": \"At least 16 cells out of 18 expected (6 conditions x 1 dataset x 3 seeds) completed without unhandled errors and produced both test_accuracy_ideal AND test_accuracy_noisy_p01 values. 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\": \"q09-exec-numerical\", \"requirements\": \"Numerical validity: both test accuracies in [0, 1]; for any single training condition, test_accuracy_ideal and test_accuracy_noisy_p01 differ by at least 0.01 (cells reporting bit-identical clean and noisy accuracy mean the noise model isn't being applied at evaluation); no_training_control accuracy is in [0.4, 0.6] (random predictor floor).\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Code Execution\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}], \"task_category\": null, \"finegrained_task_category\": null}, {\"id\": \"q09-results\", \"requirements\": \"Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.\", \"weight\": 3, \"sub_tasks\": [{\"id\": \"q09-result-h1-quant\", \"requirements\": \"Quantitative test of H1. On the noisy test set at p=0.01, is train_noisy_mid (training noise p=0.005) test_accuracy >= train_ideal test_accuracy + 5 absolute pp (3-seed mean)? 100% if gap >= 5pp, 67% if 2-5pp, 33% if any positive gap, 0% if ideal train matches or beats noisy-mid train on noisy test.\", \"weight\": 10.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q09-result-h2-quant\", \"requirements\": \"Quantitative test of H2. On the ideal test set, does train_ideal beat EVERY noisy-trained variant by >= 2 absolute pp (3-seed mean)? 100% if gap >= 2pp vs all three noisy variants, 67% if gap >= 2pp vs at least 2 of 3, 33% if marginal advantage on at least 1, 0% if noisy training matches or beats ideal training on clean test (no tradeoff).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q09-result-h3-quant\", \"requirements\": \"Quantitative test of H3. Does train_noisy_high underperform train_noisy_mid on BOTH the clean and the noisy test set (3-seed mean)? 100% if cleanly worse on both, 67% if worse on 1 of 2 by >= 3pp, 33% if marginally worse on 1, 0% if high-noise training matches or beats mid-noise on both test sets (no negative transfer observed).\", \"weight\": 8.0, \"sub_tasks\": [], \"task_category\": \"Result Analysis\", \"finegrained_task_category\": \"Evaluation, Metrics & Benchmarking\"}, {\"id\": \"q09-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 per-(training_noise_rate, test_set) 3-seed mean accuracy values. References Wang NeurIPS 2022 QuantumNAS and Sharma PRX Quantum 2022. Discusses whether the observed sweet-spot noise rate matches the test-deployment rate, and acknowledges that AerSimulator depolarizing channel is a simplified model relative to real hardware noise (T1/T2, crosstalk, readout asymmetry not captured).\", \"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/Q09.yaml", "rubric_file": "tasks/quantum/rubrics/Q09.json"}
{"id": "Q10", "domain": "quantum", "title": "Quantum autoencoder for pure-state compression", "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", "domains": ["quantum-machine-learning", "generative-models", "autoencoders"], "arxiv_id": null, "venue": "ARC-Bench 2026", "metric_key": "reconstruction_fidelity", "metric_direction": "maximize", "gpu_required": false, "est_wall_clock_sec": 1200, "synthesis": "A quantum autoencoder takes an n-qubit quantum state, applies a\nparameterized circuit that disentangles the information onto a\nsmaller subset of m < n \"latent\" qubits, and traces out the\nremaining n - m \"trash\" 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 \"does the autoencoder learn\nanything\" 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\": 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/Q10.yaml", "rubric_file": "tasks/quantum/rubrics/Q10.json"}