Entangling-gate ablation in a variational quantum classifier
Domain: quantum (quantum-machine-learning, entanglement, ablation-study)
Topic: Ablating entangling gates in a variational quantum classifier: how much classification accuracy is actually attributable to CNOTs versus single-qubit rotations
Venue: ARC-Bench 2026
Headline metric: test_accuracy (maximize)

Research briefing:
Quantum machine learning models routinely use parameterized circuits
that mix single-qubit rotations with entangling two-qubit gates,
typically CNOTs. The common narrative is that entanglement is the
source of quantum advantage. If a variational classifier with no
entangling gates whatsoever can match the accuracy of one with full
entanglement, that narrative breaks down for this task class. The
purpose of this study is to measure the actual contribution of
entanglement in a simple variational quantum classifier by cleanly
removing CNOTs in a controlled monotonic manner.

The design isolates entanglement to one source. The data encoding is
fixed to angle encoding (single-qubit rotations only, no entangling
gates). The variational ansatz template is EfficientSU2 with reps=3,
which by default places a linear chain of CNOTs between each rotation
block (5 CNOTs per entangling layer, 3 layers, 15 CNOTs total for
6 qubits). We ablate by replacing some or all of those CNOTs with
identity, while keeping every single-qubit rotation parameter intact.
This isolates the gain attributable to two-qubit entangling structure
from the gain attributable to the trainable single-qubit basis change.
half_entanglement uses an independent random Bernoulli(0.5) mask over
the 15 CNOT positions per cell, seeded deterministically so the
ablation is reproducible but not aligned with any fixed pattern.

A parameter-matched classical baseline (sklearn MLPClassifier with a
hidden layer sized so its total parameter count is within 10 percent
of the VQC parameter count) tells us whether either quantum condition
is competitive with a trivial classical alternative on the same data.
If the no-entanglement VQC underperforms the classical MLP, the
conclusion is that on these tasks, entangling layers are not just
helpful but necessary for the variational quantum model to be a
viable choice at all.

Datasets are deliberately shared with Q01 (encoding comparison) so
results can be read across both studies. If the cross-topic story
holds, the encoding family that benefits most from ansatz CNOTs in
Q02 should also be the family that performed worst in Q01 (because
the ansatz CNOTs are compensating for the encoding's lack of input
entanglement). The current manifest does not require that
cross-comparison, but the writeup is encouraged to discuss it.

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?*

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

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

Requirements:

Scoring rubric:
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.
sub_tasks: 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.
sub_tasks: 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.
task_category: Code Development
finegrained_task_category: Method Implementation, 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.
task_category: Code Development
finegrained_task_category: Experimental Setup, 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).
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 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.
task_category: Code Execution
finegrained_task_category: Evaluation, Metrics & Benchmarking, 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).
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 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.
task_category: Result Analysis
finegrained_task_category: Evaluation, Metrics & Benchmarking, 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.
task_category: Result Analysis
finegrained_task_category: Evaluation, Metrics & Benchmarking, 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.
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 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.
task_category: Result Analysis
finegrained_task_category: Logging, Analysis & Presentation