Comparing quantum data encoding strategies for variational classifiers
Domain: quantum (quantum-machine-learning, data-encoding, feature-maps)
Topic: Comparing quantum data encoding strategies (angle, amplitude, IQP, ZZ feature map) for variational quantum classifiers on small low-dimensional binary classification tasks
Venue: ARC-Bench 2026
Headline metric: test_accuracy (maximize)

Research briefing:
Quantum data encoding is widely regarded as the bottleneck of variational
quantum machine learning. The way classical features are loaded into a
quantum state determines what functions the subsequent variational ansatz
can express. Three encoding families are compared here: angle encoding
(single-qubit rotations only, no input entanglement), amplitude encoding
(information-dense state preparation that loads the classical vector as
state amplitudes), and the ZZ feature map (Hadamards plus diagonal
pairwise phase rotations, injecting entanglement at the input layer).

The research question is direct. Holding the variational ansatz, the
classical optimizer, the simulator backend, and the dataset preprocessing
fixed, which encoding produces the best test accuracy on a moderately
difficult 6D binary classification task, and does at least one quantum
encoding approach the better of two classical baselines (logistic
regression and a small MLP)?

Implementation guidance is provided by the `quantum-qiskit` skill, which
is automatically injected into the stage-10 code generation prompt for
this topic. Use the skill's reference patterns verbatim: import
`ZFeatureMap`, `StatePreparation`, and `ZZFeatureMap` from
`qiskit.circuit.library`; use `qiskit_machine_learning.algorithms.VQC`
with the reference Sampler primitive for training; never roll a custom
optimization loop. Hand-written gate sequences in place of these
library classes have been observed to produce degenerate ablations
(three encodings collapsing to nearly identical computations) and will
fail the rubric.

Experimental protocol. All three quantum encodings share EfficientSU2
reps=1 linear entanglement as the variational ansatz, COBYLA maxiter=200
as the optimizer, and the noiseless statevector backend as the simulator.
Two classical baselines (LogisticRegression and MLPClassifier) run on
the same 6D features. Five random seeds per cell across 5 conditions
yields 25 total cells. Each per-seed result is logged to stdout as a
single line with the prefix `METRIC_RESULT` followed by a JSON object
containing `condition`, `dataset`, `seed`, and `test_accuracy` keys so
the autoclaw sandbox parser can collect structured metrics.

Research question: *On a moderately difficult 6D binary classification
task (LogisticRegression baseline expected around 0.65 to 0.80), does
the choice of quantum encoding (angle, amplitude, ZZ) measurably change
variational classifier accuracy, and does at least one quantum encoding
approach the better classical baseline?*

Hypotheses:
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., 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., 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.

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: no
estimated_wall_clock_sec: 1800

Requirements:

Scoring rubric:
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.
sub_tasks: 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.
sub_tasks: 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).
task_category: Code Development
finegrained_task_category: Method Implementation, 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.
task_category: Code Development
finegrained_task_category: Experimental Setup, 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.
task_category: Code Development
finegrained_task_category: Experimental Setup, requirements: Execution-validity bucket: all cells ran and produced numerically valid outputs.
sub_tasks: 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.
task_category: Code Execution
finegrained_task_category: Evaluation, Metrics & Benchmarking, 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).
task_category: Code Execution
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.
sub_tasks: requirements: Quantitative test of H1. 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).
task_category: Result Analysis
finegrained_task_category: Evaluation, Metrics & Benchmarking, 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).
task_category: Result Analysis
finegrained_task_category: Evaluation, Metrics & Benchmarking, 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.
task_category: Result Analysis
finegrained_task_category: Evaluation, Metrics & Benchmarking, 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.
task_category: Result Analysis
finegrained_task_category: Logging, Analysis & Presentation