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

Data re-uploading is a variational quantum circuit pattern in which the
classical input x is loaded into the same qubits multiple times,
interleaved with trainable rotation layers: the circuit
W(theta_L) U(x) W(theta_{L-1}) U(x) ... W(theta_1) U(x) |0> applies L
encoding blocks U(x) and L trainable blocks W(theta). Perez-Salinas et al.
proved in 2020 that a single qubit with sufficient re-uploading depth is
a universal function approximator on bounded intervals. Schuld, Sweke,
and Meyer (PRA 2021) then proved the structural reason: a re-uploading
circuit's output function is a truncated Fourier series in the input x,
with the set of representable frequencies determined by the eigenvalue
spectrum of the encoding generators and growing with L.

The practical question that follows is whether the theoretical
expressivity claim translates into empirical fit quality. As L grows we
expect (i) more representable frequencies (better fit on high-bandwidth
targets), and (ii) more parameters and more risk of overfitting on
finite-sample regression with discontinuous targets. Classical kernel
regression (RBF) and polynomial regression provide the natural baselines
because they too can be interpreted as choosing a basis of functions
(Gaussian or polynomial) of fixed expressivity; comparing quantum
re-uploading against these classical baselines is the cleanest way to
ask "does the Fourier structure imposed by re-uploading give a useful
inductive bias on these targets, or do classical models with comparable
capacity match it?"

Implementation guidance is provided by the quantum-qiskit skill, which
is automatically injected at stage 10 and contains canonical code for
building re-uploading circuits using qiskit.circuit.ParameterVector and
rotation gates. Training uses Adam through parameter-shift gradients
(do NOT roll your own gradient finite-difference loop). The simulator
is fixed to AerSimulator(method='statevector') for noiseless evaluation
so the Fourier-spectrum probe is clean.

Experimental protocol. Four quantum re-uploading depths (L=1, L=3, L=5,
L=7) are compared against two classical baselines (RBF kernel ridge
regression with bandwidth chosen by cross-validation; polynomial
regression of degree 7). All six conditions are evaluated on two 1D
regression targets: a sum-of-sinusoids signal with known frequency
content, and a step function (tests handling of discontinuities).
Each (condition, dataset) cell is averaged over 2 random seeds, giving
6 conditions x 2 datasets x 2 seeds = 24 total cells.

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 (sinusoid mixture), and does the
recovered Fourier spectrum overlap with the target spectrum scale
predictably with L?*

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.

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.

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.

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?

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.

Same single-qubit re-uploading template with L=3 encoding blocks. 6 trainable parameters.

Same template with L=5 encoding blocks. 10 trainable parameters.

Same template with L=7 encoding blocks. 14 trainable parameters.

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.

Mean squared error on a 200-point held-out test set, averaged over 2 random seeds per (condition, dataset) cell. Primary metric.

Mean squared error on the 200-point training set after training completes.

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.

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).

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.

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.

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.

Code-development bucket: 4 re-uploading circuits + 2 classical baselines are implemented correctly with shared training pipeline and reproducible per-cell seed control.

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.

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).

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].

Execution-validity bucket: all 24 cells ran and produced numerically valid outputs.

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.

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].

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.

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.

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.

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).


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

A barren plateau is the phenomenon, first identified by McClean et al.
in 2018, that the gradient of a variational quantum circuit's loss
becomes exponentially small in the number of qubits when the ansatz is
drawn from a sufficiently random circuit ensemble. Concretely, for a
loss L(theta) = <psi(theta)|H|psi(theta)> where the parameterized
state is generated by a random-ish unitary, the variance of the
gradient dL/dtheta_k scales as O(1/2^n). For n = 20 qubits this
variance is below machine epsilon, and SGD or any gradient-based
optimizer has effectively zero signal to follow. This is the central
trainability obstruction in variational quantum machine learning.

Cerezo et al. ("Cost function dependent barren plateaus in shallow
parametrized quantum neural networks", Nature Communications 2021)
showed that the locality of the cost function matters. If the cost is
a sum of single-qubit Pauli expectations (a local cost), then the
gradient variance can scale only polynomially in n even at moderate
ansatz depth. If the cost is a product or projection over all qubits
(a global cost), the variance is exponentially suppressed at any
depth. The mechanism is that local-cost observables overlap with only
a constant-size subspace of the 2^n dimensional Hilbert space, while
global-cost observables are spread thinly across the entire space and
almost always cancel.

The empirical question this topic addresses is whether the local-cost
free lunch holds at moderate depth on a CPU-feasible 6-qubit
benchmark. We fix n=6 qubits and the EfficientSU2 hardware-efficient
ansatz family (a standard choice in qiskit). We vary depth (number of
ansatz layers L) and cost-function locality, then directly probe the
gradient distribution by sampling 100 random parameter vectors per
cell, computing the parameter-shift gradient with respect to theta_0
for each, and reporting the empirical variance. A subsidiary check
trains each condition for 100 Adam iterations and reports the loss
change as a practical sanity probe of whether the gradient signal is
large enough to drive optimization at all.

Implementation guidance is provided by the quantum-qiskit skill,
which is automatically injected at stage 10. Use qiskit.circuit.library
EfficientSU2 verbatim; do NOT hand-write H/CNOT/RY gate stacks (a
prior failed run produced an "ablation failure" where three nominally
different encodings collapsed to identical circuits because they
were hand-coded). Use qiskit_algorithms.utils.algorithm_globals
random_seed for reproducibility. Gradients are computed via the
parameter-shift rule on a statevector backend.

Experimental protocol. Four conditions cover the cost x depth grid:
(local_cost_L2) shallow + local, the trainable control; (local_cost_L10)
medium + local, the regime Cerezo's theorem predicts is still
trainable; (local_cost_L20) deep + local, stressing the prediction;
(global_cost_L10) medium + global, the negative control where a barren
plateau is expected. Each condition is run with 3 different random
ansatz-structure seeds (controlling which qubits are entangled in each
EfficientSU2 layer) for variance estimation across architectures, and
100 random parameter vectors per (condition, structure-seed) cell are
used to estimate gradient variance. Total cells: 4 conditions x 3
ansatz seeds = 12 cells. No external dataset is required because this
is a measurement experiment on the ansatz family itself.

Research question: *Does the local-cost trick avoid the barren plateau
on a 6-qubit EfficientSU2 ansatz at L=10 and L=20 ansatz depth, as
predicted by Cerezo et al. 2021, when compared against the
global-cost baseline at the same depth and against the shallow local-cost
control?*

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.

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).

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.

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?

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.

Proposed-method stress test. EfficientSU2 reps=20, same local cost <Z_0>. Tests whether the polynomial-decay prediction holds at deeper ansatz.

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.

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).

Mean of |dL/dtheta_0| over the 100 random samples.

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.

Synthetic, generated in-script via numpy.random.RandomState(ansatz_structure_seed).uniform(-pi, pi, size=(100, n_params))

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.

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.

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.

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.

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.

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.

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.

Execution-validity bucket: all 12 cells ran and produced numerically valid outputs.

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.

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).

Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.

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.

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).

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).

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).


Neural-network warm-start for QAOA-MaxCut initialization

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

The Quantum Approximate Optimization Algorithm (QAOA) prepares a
parameterized quantum state to approximate the maximum cut of a graph.
At depth p=1 the state depends on two real parameters (beta, gamma),
and the algorithm proceeds by classical optimization of those two
parameters against the average cut size sampled from measurements of
the prepared state. The bottleneck for practical QAOA is the initial
parameter guess. Random initialization frequently falls into the
barren-plateau region or onto sub-optimal local minima, requiring many
classical iterations to escape. Brandao et al. 2018 showed
theoretically that the optimal (beta, gamma) values concentrate
around a problem-independent point on certain graph ensembles, so a
fixed initialization like (pi/4, pi/4) is a strong default.

Beyond concentration, a richer strategy is to train a classical
neural network offline to predict the optimal (beta, gamma) given
features of the input graph. Verdon et al. 2019 introduced the idea
as quantum-aware meta-learning. Jain et al. (Quantum 2022, "Graph
neural network initialisation of QAOA") showed that a graph neural
network trained on a few thousand small graphs can predict initial
parameters that reduce the number of subsequent classical
optimization iterations by 5-10x compared to random initialization,
with measurable transfer to out-of-distribution graph families.

The empirical question this topic addresses is whether the MLP-warm-start
strategy actually generalizes off-distribution: a model trained on
Erdős-Rényi graphs of one density should ideally retain its advantage
on regular graphs of a different size. We also want to verify whether
the simpler "fixed init at (pi/4, pi/4)" baseline (from Brandao 2018)
is competitive with the MLP-predicted init at p=1, since the
concentration result suggests that simple defaults may be hard to
beat in the low-depth regime.

Implementation guidance is provided by the quantum-qiskit skill at
stage 10. Implement QAOA on the qiskit AerSimulator statevector
backend; the small graph sizes (n=6 to n=8) make exact statevector
simulation cheap. The MLP is sklearn.neural_network.MLPRegressor
trained offline on a precomputed set of (graph_features, optimal_beta,
optimal_gamma) tuples obtained by grid search on 200 training
graphs. Optimization at test time uses COBYLA with a hard cap of 20
iterations.

Experimental protocol. Two graph families serve as the test bed.
In-distribution: Erdős-Rényi G(n=6, p=0.5) graphs (matched to the MLP
training distribution). Out-of-distribution: 3-regular graphs at n=8
(different size and edge density). Four conditions cover the
initialization strategies: random init, fixed init (beta=gamma=pi/4),
MLP-init evaluated in-distribution, and MLP-init evaluated
out-of-distribution. (MLP-init has 2 conditions because the model
trained on Erdős-Rényi G(n=6, p=0.5) is evaluated on both graph
families to test transfer.) Each (condition, graph family) cell is
averaged over 3 different random graph instances drawn within that
family. Total cells: 4 conditions x 2 graph families x 3 seeds = 24
cells.

Research question: *Does a small MLP trained to predict QAOA-MaxCut
initial parameters from graph features (degree distribution, edge
density, spectral gap) provide a faster warm-start than random
initialization or the Brandao 2018 fixed (pi/4, pi/4) initialization,
and does the advantage transfer to graphs from a different
distribution than the MLP was trained on?*

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.

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.

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.

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?

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.

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.

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.

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.

approximation ratio (cut_size / optimal_cut_size) achieved after exactly 20 COBYLA iterations, regardless of whether the target threshold was met. 3-graph mean.

Fraction of the 3 random graph instances in a cell that reached approximation ratio 0.9 within the 20-iteration budget.

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.

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.

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.

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.

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.

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).

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.

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.

Execution-validity bucket: all cells ran and produced numerically valid outputs.

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.

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).

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.

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).

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).

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.


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

A Matrix Product State (MPS) is a tensor network in which a target
tensor of N indices is decomposed into a 1D chain of N small tensors,
each connected to its neighbors by "bond" indices of dimension chi.
MPS originated in condensed-matter physics as the representation
underlying the Density Matrix Renormalization Group (DMRG) for 1D
ground-state computation, and Schollwock's 2011 review remains the
canonical reference. Stoudenmire and Schwab (NeurIPS 2016, "Supervised
Learning with Tensor Networks") repurposed the MPS as a classical
supervised classifier. The idea is simple: each input feature
(pixel) is mapped to a small feature vector (e.g. cos(pi*x/2),
sin(pi*x/2) for grayscale x in [0,1]), and the per-pixel feature
vectors are contracted with a chain of MPS tensors to produce a
class-score vector. The MPS bond dimension chi controls how much
correlation between distant pixels the classifier can capture,
giving an interpretable expressivity knob.

Crucially, the MPS classifier runs entirely on classical hardware.
This makes it a "quantum-inspired classical" baseline: the same
mathematical machinery as a low-entanglement quantum state, but
implemented as a NumPy tensor contraction. Glasser et al. (PRX 2018)
extended the framework to richer tensor networks. More recent
benchmarks (Liu et al. 2022 Nature Communications Physics) have asked
where the bond-dimension sweet spot is for image classification and
whether MPS classifiers can be competitive with CNNs at small
parameter budgets.

This topic asks whether an MPS classifier matches a parameter-matched
CNN baseline on a CPU-feasible image classification task. The
comparison is not "does MPS beat CNN at large scale" (it doesn't, on
high-resolution images) but rather "at matched small parameter
counts, is the MPS inductive bias competitive with a small CNN's
spatial bias on 8x8 downsampled MNIST and Fashion-MNIST?" The
question is timely because tensor-network ML is increasingly cited
as the honest classical baseline against which to measure quantum
machine learning claims of advantage.

Implementation guidance. Use pure NumPy or PyTorch for the MPS
contraction (no qiskit required for this topic; it is quantum-inspired
classical computation). The standard MPS classifier from Stoudenmire
& Schwab 2016 stores N+1 tensors of shape (chi, d, chi) where N is
the number of pixels (64 for an 8x8 image), d=2 is the per-pixel
feature dimension (we use the cos/sin embedding), and chi is the
bond dimension. The CNN baseline is a single 3x3 convolution layer
with K filters followed by a fully connected output layer; K is
chosen so the total parameter count is within 10 percent of the MPS
parameter count at each bond dimension.

Experimental protocol. Three MPS bond dimensions (chi=4, chi=8,
chi=16) are compared against two classical baselines (logistic
regression on flattened 8x8 pixels; small CNN with parameter count
matched to the chi=8 MPS). All five conditions are evaluated on two
datasets: 8x8 downsampled MNIST (10 classes, 5000 train / 1000 test
images) and 8x8 downsampled Fashion-MNIST (10 classes, same
size). Each (condition, dataset) cell is averaged over 3 random
seeds (controlling MPS / CNN initialization and the train / test
split). Total cells: 5 conditions x 2 datasets x 3 seeds = 30 cells.

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 the accuracy
scale with chi?*

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.

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.

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).

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?

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.

MPS classifier with chi=8. Approximate parameter count: 64 * 2 * 8 * 8 = 8192. Trained with Adam on cross-entropy for 50 epochs.

MPS classifier with chi=16. Approximate parameter count: 64 * 2 * 16 * 16 = 32768. Trained with Adam on cross-entropy for 50 epochs.

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.

Top-1 classification accuracy on the 1000-image held-out test set, 3-seed mean. Primary metric.

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.

Wall-clock seconds for 50 epochs of training, measured per cell. Tests the practical compute cost of each method at matched accuracy.

sklearn.datasets.fetch_openml('mnist_784') downsampled to 8x8 via skimage.transform.resize

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).

sklearn.datasets.fetch_openml('Fashion-MNIST') downsampled to 8x8

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.

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.

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.

Code-development bucket: MPS classifier implemented correctly with proper per-pixel feature embedding, CNN baseline parameter-matched, and training pipeline shared across conditions.

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.

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.

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.

Execution-validity bucket: all 30 cells ran with valid outputs.

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.

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.

Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.

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.

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.

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.

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.


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

Variational quantum classifiers (VQCs) at moderate depth (reps >= 5)
suffer from barren plateaus: the gradient of the loss with respect to
any single parameter is exponentially suppressed when the ansatz is
initialized randomly across all layers. Skolik et al. (Quantum 2021,
"Layerwise learning for quantum neural networks") proposed a training
schedule that avoids this trap by adding ansatz layers incrementally.
Concretely, the agent trains a reps=1 ansatz to convergence, freezes
its parameters, prepends or appends a fresh reps=1 block initialized
to identity, trains only the new block to convergence, and so on
until the target depth is reached. Each layer of training sees a much
smaller parameter space, so the gradient signal stays well above the
barren-plateau floor at every step.

The empirical question this topic addresses is whether the layerwise
schedule actually delivers higher final test accuracy AND faster
practical convergence than naive end-to-end training of the full
reps=5 ansatz on small UCI binary classification tasks. A
parameter-matched classical baseline (sklearn MLPClassifier) and a
logistic regression baseline serve as the cross-paradigm controls
required by the bench's PROCEED gate; they also calibrate the
difficulty of each dataset (logistic regression should fit linear
separable cases cleanly).

Implementation guidance is provided by the quantum-qiskit skill,
which is automatically injected at stage 10. Use
qiskit.circuit.library.EfficientSU2(num_qubits=4, reps=5,
entanglement='linear') as the underlying ansatz family, and use
qiskit_machine_learning.algorithms.VQC for training (it works in
qiskit 2.x; do NOT use qiskit_algorithms.VQE which is broken). For
the layerwise condition, the agent must implement the layer-freezing
schedule manually: construct an ansatz with only the first k blocks
trainable and previous blocks bound to their converged parameters.
The classical baselines train on the same 80/20 train/test split
using the same per-seed random_state.

Experimental protocol. Three quantum conditions compare training
schedules at the same final depth (reps=5): layerwise growth from
reps=1 to reps=5, end-to-end training of reps=5 from random
initialization, and a random-init control (no training, evaluate
the randomly initialized reps=5 ansatz). Two classical baselines
(logistic regression, MLPClassifier with parameter count matched to
the VQC's 40-parameter count) provide the cross-paradigm reference.
Each (condition, dataset) cell is averaged over 3 seeds. Total:
5 conditions x 2 datasets x 3 seeds = 30 cells.

Research question: *Does layerwise incremental training of a VQC
reach higher test accuracy or faster convergence than end-to-end
training of the same final-depth ansatz, and does the layerwise
gradient norm at each newly added layer remain above the
barren-plateau threshold?*

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.

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.

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.

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?

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.

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).

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.

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.

Held-out 20 percent test split accuracy, 3-seed mean. Primary metric.

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.

Number of total COBYLA iterations to reach test accuracy >= 0.8 (or to budget 400 if never reached). Tests practical convergence speed.

sklearn.datasets.load_iris + PCA to 4 dimensions

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.

sklearn.datasets.load_breast_cancer + PCA to 4 dimensions

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.

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.

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).

Code-development bucket: layerwise freeze-and-add schedule implemented manually, classical baselines parameter-matched, gradient-norm probe consistent.

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.

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.

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.

Execution-validity bucket: all 30 cells ran and produced numerically valid outputs.

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.

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.

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.

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.

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.


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

Real quantum hardware exhibits gate errors, readout errors, and
decoherence at rates that vary across devices. A VQC trained on a
noiseless statevector simulator may converge to parameters that work
on the ideal training distribution but degrade sharply when deployed
on a noisy device. The noise-aware training strategy is to inject
simulated noise during training (e.g. a depolarizing channel after
each two-qubit gate) so the optimizer can find parameters that are
robust to that noise model. The closest classical analog is
adversarial training or training-time data augmentation.

Two open empirical questions follow. First, does noise-aware training
produce strictly more robust models on noisy test data than ideal
training, and at what training noise rate is the robustness gain
worth the loss of clean-test accuracy? Second, does training at high
noise (p=0.01) cause negative transfer to clean test data — i.e.
does the model overfit to the noise statistics and underperform an
ideal-trained model on noise-free evaluation? Wang et al. (NeurIPS
2022 "QuantumNAS: Noise-Adaptive Search for Robust Quantum
Circuits") and Sharma et al. (PRX Quantum 2022 "Trainability of
dissipative perceptron-based quantum neural networks") explored
these tradeoffs at small scale, leaving the precise sweet-spot
noise rate as a benchmark question.

Implementation guidance is provided by the quantum-qiskit skill at
stage 10. Use qiskit_aer.AerSimulator with a custom NoiseModel that
applies a single-qubit and two-qubit depolarizing channel after each
parameterized gate. The training uses
qiskit_machine_learning.algorithms.VQC with a custom
qiskit.primitives.BackendSamplerV2 bound to the noisy AerSimulator
for noisy-train conditions, and the noiseless reference
qiskit.primitives.StatevectorSampler for the ideal-train condition.
Evaluation always runs on both an ideal statevector test set and a
noisy test set at p=0.01 (the "deployment noise rate") so each cell
produces two test_accuracy values: clean and noisy. The primary
metric is the average across both.

Experimental protocol. Four quantum training conditions vary the
training noise rate: ideal (p=0), low noise (p=0.001), mid noise
(p=0.005), high noise (p=0.01). Two baselines complete the bench
gate: a no-training control (random initialization, no fit) and
logistic regression on the same 4D features. All six conditions
are evaluated on a single synthetic binary classification dataset
(make_classification with class_sep=0.5, 200 samples, 4 features),
averaged over 3 seeds. Total: 6 conditions x 1 dataset x 3 seeds
= 18 cells.

Research question: *On a synthetic 4D binary classification task,
does noise-aware VQC training at a moderate training noise rate
(p=0.005) produce a model that is more robust to test-time
depolarizing noise (p=0.01) than an ideal-trained VQC, and does
high training noise (p=0.01) cause negative transfer to clean
test data?*

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.

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.

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.

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?

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).

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.

Same as train_noisy_low but training noise rate p=0.005.

Same as train_noisy_low but training noise rate p=0.01 (matches the test-noise rate).

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.

Average of test_accuracy_ideal and test_accuracy_noisy_p01, 3-seed mean. Primary metric for the bench.

Test accuracy on the noiseless test set (StatevectorSampler evaluation), 3-seed mean.

Test accuracy on the noisy test set at depolarizing rate p=0.01 (AerSimulator with NoiseModel), 3-seed mean. The 'deployment-noise' robustness metric.

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.

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.

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.

Code-development bucket: NoiseModel correctly constructed, training pipeline applies noise, evaluation on both ideal and noisy test.

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).

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.

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.

Execution-validity bucket: all 18 cells ran with valid outputs.

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.

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).

Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.

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.

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).

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).

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).


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

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

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

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

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

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

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

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.

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.

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.

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?

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.

Same as compress_4_to_2 but with 1 trash qubit (qubit 3) and 3 latent qubits (0, 1, 2). Easier compression task.

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).

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'.

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.

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>.

Wall-clock seconds for the 100 COBYLA iterations of training. Reported for context — the compression task should fit well under 60 seconds per cell.

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

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.

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.

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).

Code-development bucket: encoder/decoder built from qiskit.circuit.library, SWAP-test or direct-fidelity loss implemented correctly, training pipeline runs.

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).

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).

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.

Execution-validity bucket: all 15 cells ran with valid outputs.

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.

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).

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.

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.

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.

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).


E. coli succinate-production strain optimization via constraint-based knockout screen on iAF1260

Succinate is a top-12 platform chemical and a recurring case study in
metabolic engineering. The standard genome-scale model E. coli iAF1260
(2382 reactions, 1668 metabolites, 1261 genes) provides a well-validated
testbed for in-silico strain design: from a fixed glucose-minimal medium
one can predict (a) the maximum aerobic biomass growth rate, (b) the
maximum theoretical succinate secretion flux once growth is held at a feasible
fraction of optimum, (c) the set of single- and double-gene knockouts
that decouple biomass from succinate secretion enough to push the strain
toward a high-secretion non-growth-coupled phenotype.

A credible CPU-scale study of this topic (a) loads iAF1260 from BIGG and
validates aerobic biomass > 0.7 1/h on glucose-minimal medium, (b) runs
parsimonious FBA (pFBA) at the wild-type optimum and reports the central
carbon flux distribution, (c) sweeps the production envelope (biomass vs
succinate secretion) using flux variability analysis (FVA) on the
succinate exchange across a grid of biomass-fraction-of-optimum values,
(d) runs a single-gene knockout screen (≤100 candidate genes drawn from
central carbon metabolism, fermentation, and TCA cycle) and ranks each KO
by post-KO succinate secretion flux at 50% of WT growth, (e) reports the top three
KO strains with mechanistic explanation tied to the network topology.

The research question is: *which single-gene knockouts of central carbon
metabolism in E. coli iAF1260 produce the largest predicted succinate
secretion flux while preserving at least 50% of wild-type biomass growth, and what
is the mechanistic role of each in shifting flux toward succinate?*

Wild-type aerobic E. coli iAF1260 on glucose-minimal medium predicts a biomass growth rate within ±10% of 0.736 1/h (the published BIGG iAF1260 reference value).

The biomass-vs-succinate production envelope, computed via FVA at biomass fractions from 0.1 to 1.0 of WT optimum, is monotonically non-increasing in succinate as biomass approaches the WT optimum (i.e., succinate is growth-competing under aerobic glucose conditions).

At least 3 of the top-5 single-gene knockouts identified by the screen as maximizing succinate secretion flux at 50% WT-growth disrupt canonical competing by-product or respiration pathways described in the metabolic-engineering literature (e.g., pyruvate-formate-lyase pflB, lactate dehydrogenase ldhA, alcohol dehydrogenase adhE, acetate kinase ackA, phosphate acetyltransferase pta, or their isozymes), or are accompanied by a mechanistic explanation for why the knockout redirects flux toward succinate under the chosen medium.

Which single-gene knockouts of central carbon metabolism in E. coli iAF1260 produce the largest predicted succinate secretion flux while preserving at least 50% of wild-type biomass growth, and what is the mechanistic role of each in shifting flux toward succinate?

Wild-type iAF1260 on glucose-minimal medium with O2 unconstrained. Reference condition.

Same as wt_aerobic_glucose but with pFBA (parsimonious FBA) for unique flux distribution.

FVA on succinate exchange across biomass-fraction-of-optimum grid {0.1, 0.2, ..., 1.0}.

Single-gene knockouts on a curated set of ≤100 central-carbon / fermentation / TCA genes (glycolysis, PPP, TCA, anaplerotic, fermentation by-products); for each, FBA at fixed biomass = 0.5 × WT optimum; record succinate exchange flux.

wt_aerobic_glucose (no perturbation) is the no-engineering baseline

Published BIGG iAF1260 reference growth rate (0.736 1/h on glucose-minimal aerobic) — the model-validity gate

Wild-type biomass exchange flux (1/h) on glucose-minimal aerobic; reference value 0.736.

Succinate exchange flux (mmol/gDW/h) at biomass = 0 (theoretical maximum).

Succinate exchange flux at biomass = 0.5 × WT optimum, wild-type strain.

Maximum succinate exchange flux over the single-KO screen at biomass = 0.5 × WT optimum.

BIGG database (http://bigg.ucsd.edu/models/iAF1260) via cobra.io.load_model('iAF1260')

A canonical results.json file exists at the workspace root with at least the keys: primary_metric (number), metrics (object of numeric keys), hypotheses (object with h1/h2/h3 entries each carrying a `supported` boolean), summary (non-empty string).

results.json metrics MUST contain a numeric value for `wt_growth_observed_1_per_h` (or an equivalent wt_growth_*_1_per_h key) that is non-null and finite. The wild-type growth rate must be reported, otherwise H1 cannot be evaluated.

results.json structured_results MUST contain a list of the top 5 ranked single-gene knockouts with at least {gene_id, gene_name, ko_succinate_flux_mmol_gDW_h, is_canonical} fields each. The list need not include the textbook canonical genes — but it MUST exist and identify at least 5 candidates.

A production-envelope figure (biomass-vs-succinate, or analogous) must exist under figures/ or analysis/ in PDF or PNG format with axes labeled and units shown. Either a single multi-curve figure or per-condition figures both qualify.

Each of hypotheses.h1, hypotheses.h2, hypotheses.h3 in results.json MUST have an explicit `supported` boolean and a `details` string of at least 40 characters describing the evidence used to reach that verdict.

Top-3 KO targets are discussed mechanistically — naming the pathway each KO disables and a one-sentence rationale for why the disruption redirects flux to succinate.  Acceptable inside summary, structured_results, or a separate writeup field.

The solver backend (cobra optlang interface name + version) and any RNG seeds used (e.g. for sampling) are reported in results.json. Required for reproducibility but not for scientific correctness.

A credible constraint-based experiment on E. coli iAF1260 that (a) loads the BIGG model and validates wild-type growth, (b) computes a flux distribution under the standard objective, (c) characterises the biomass-vs-succinate production envelope, (d) runs a single-gene knockout screen targeted at central carbon metabolism, and (e) ties the top-ranked knockouts to the network mechanism. Partial but well-motivated evidence deserves partial credit; rigid wording or naming should not penalize a substantively correct experiment.

Score on biological substance and quantitative correctness, not exact threshold satisfaction. Reproducing canonical FBA numbers (WT growth ~0.7, well-known knockouts like pflB/ldhA/adhE/ackA-pta) is strong evidence; novel-but-coherent design choices are acceptable.

The constraint-based pipeline is implemented with COBRApy and a BIGG genome-scale model.

The submission loads E. coli iAF1260 (or a comparable validated genome-scale metabolic model) from BIGG via COBRApy, with the medium constraints (glucose uptake, O2 availability) explicitly set and the biomass objective explicitly named.

FBA and pFBA are invoked correctly to obtain wild-type growth and a unique flux distribution; output flux table covers exchange + central-carbon reactions at minimum.

The biomass-vs-succinate production envelope is computed by sweeping a fraction-of-optimum biomass constraint and running FVA (or two-step FBA) on the succinate exchange at each grid point.

The single-gene knockout screen iterates over a curated central-carbon / fermentation / TCA gene set (≤100), applies model.genes.<g>.knock_out() (or equivalent reaction-bound deletion), and records succinate flux at fixed biomass = 0.5 × WT optimum.

Execution produces the FBA / FVA / KO numbers needed to evaluate the hypotheses without crashing.

Solver returns optimal status for the wild-type FBA and at least 90% of the KO conditions; no negative biomass or non-physical fluxes (succinate secretion negative under aerobic glucose, etc.) appear without explanation.

Mass balance, charge balance, and biomass-positive checks pass for the loaded model; this is the biology-validity gate analogous to physics-validity (gauge invariance, unitarity) in the physics rubric.

A machine-readable results artifact (results.json or simulations/*.csv) records WT growth rate, the production-envelope grid (biomass fraction → succinate secretion flux in mmol/gDW/h), and a per-KO succinate-flux table. If yield is reported, define it separately as succinate secretion flux divided by glucose uptake flux.

The results analysis addresses the three hypotheses with quantitative evidence and a clear narrative tied to network mechanism.

Quantitative test of H1: predicted WT aerobic growth rate is reported and compared to the published BIGG reference 0.736 1/h. Score 100% if relative error < 3%, 67% if < 10%, 33% if < 30%, 0% otherwise.

Quantitative test of H2: production envelope shows succinate is growth-competing — succinate flux is non-increasing as biomass approaches WT optimum. Score 100% if monotonic over ≥8 of 10 grid points, 67% if ≥6 of 10, 33% if ≥4 of 10.

Quantitative test of H3: among the top-5 KO ranked by succinate secretion flux at 0.5 × WT growth, count how many disrupt canonical competing by-product or respiration pathways for succinate-overproduction logic, such as {pflB, ldhA, adhE, ackA, pta, acetate/ethanol/lactate branch competitors, oxygen-respiration competitors}, or include a specific mechanistic explanation for redirecting flux toward succinate under the chosen medium. Score 100% if ≥3 of 5 meet this canonical-or-mechanistic criterion, 67% if 2 of 5, 33% if 1 of 5, 0% otherwise.

At least one publication-quality figure is produced — typically the production envelope (biomass on x, succinate secretion flux on y, with WT and best KO overlaid) and/or the KO essentiality / flux heatmap. Axes labeled with units (1/h, mmol/gDW/h), legend present.

The README or results writeup discusses each hypothesis outcome, names the top knockouts with their gene/enzyme identity, and gives a one-paragraph mechanistic interpretation (which competing pathways the KOs disable, why this redirects flux to succinate).

Reproducibility: the model, run cards, and seeds are checked into artifacts so a fresh clone can rerun and obtain matching numbers.

The loaded GSMM is either persisted (models/iAF1260.json) or pinned by version + BIGG URL in the writeup; a downstream user can locate the exact model object used.

The medium definition (exchange bounds), objective function, FVA fraction-of-optimum, and KO gene list are saved to a config / params file (not only inline in code).

Solver settings (LP backend name + version, tolerance) are recorded; if any sampling step is used, the RNG seed is logged. A second run reproduces the central WT growth rate to within solver tolerance.


E. coli acetate overflow metabolism phase map under glucose and oxygen limitation

Overflow acetate secretion in E. coli is a canonical constraint-based
modelling phenotype. A credible CPU-scale study loads a validated E. coli
genome-scale model, fixes a glucose-minimal medium, sweeps glucose and oxygen
uptake bounds, computes growth and major secretion products, and identifies
the transition from respiratory growth to overflow/fermentative by-product
secretion.

The research question is: under which glucose and oxygen uptake regimes does
E. coli switch from primarily respiratory growth to acetate-secreting overflow
metabolism, and how robust is that regime boundary across FBA and pFBA?

The selected E. coli BIGG model grows on aerobic glucose-minimal medium with a positive biomass objective and no infeasible solver status.

A two-dimensional glucose-vs-oxygen phase plane contains distinct regimes with high oxygen/low acetate and low oxygen/high acetate secretion.

pFBA reduces total internal flux while preserving the same growth-rate regime boundaries to within a small tolerance.

Under which glucose and oxygen uptake regimes does E. coli switch from respiratory growth to acetate overflow?

Wild-type E. coli iJO1366 or iAF1260 on glucose-minimal medium with oxygen available.

Grid over glucose uptake and oxygen uptake bounds; compute biomass, acetate, ethanol, lactate, succinate, and CO2 exchange fluxes.

Run pFBA on the same grid or a representative subset and compare growth plus secretion regimes.

High-oxygen glucose condition is the respiratory baseline.

Zero-oxygen glucose condition is the fermentative baseline.

Biomass objective flux for each nutrient grid point.

Acetate exchange secretion flux.

Approximate oxygen bound below which acetate secretion exceeds a chosen threshold.

Total absolute flux under pFBA.

E. coli GSMM

BIGG iJO1366 or iAF1260 via cobra.io.load_model

A results.json file exists with primary_metric, metrics, hypotheses, summary, and structured_results.

A machine-readable phase-plane table exists with glucose_bound, oxygen_bound, growth_rate, and acetate_flux columns.

A PNG or PDF heatmap/phase-plane figure exists with glucose and oxygen axes and units.

results.json metrics MUST contain a numeric value for `aerobic_glucose_growth_rate_1_per_h` (or an equivalent aerobic_growth_*_1_per_h key) that is non-null, finite, and positive. The aerobic reference growth rate must be reported, otherwise H1 cannot be evaluated.

The overflow boundary and its mechanistic basis are discussed — why E. coli switches to acetate-secreting overflow at the identified nutrient threshold. Acceptable inside summary, phase_plane_interpretation, or a separate writeup field.

The solver backend (cobra optlang interface name + version) and COBRApy version are reported in results.json. Required for reproducibility but not for scientific correctness.

A credible constraint-based E. coli acetate-overflow phase-plane study that loads a validated BIGG model, sets glucose and oxygen medium bounds, sweeps a two-dimensional nutrient grid, reports growth and by-product secretion, and interprets the acetate overflow boundary.

Score biological substance and quantitative reproducibility over exact thresholds. iJO1366, iAF1260, or a comparable curated E. coli GSMM are acceptable.

The COBRApy implementation defines the model, medium, phase-plane grid, FBA/pFBA runs, and secretion extraction.

Loads a validated E. coli BIGG model, explicitly sets glucose and oxygen exchange bounds, and names the biomass objective.

Constructs a two-dimensional glucose-by-oxygen grid with at least 8 values per axis and restores model state between conditions.

Extracts biomass plus acetate, ethanol, lactate, succinate, CO2, and O2/glucose exchange fluxes where present.

Runs pFBA on the full grid or a justified representative subset and records total absolute flux.

Execution produces stable phase-plane artifacts without infeasible or missing-condition failures dominating the study.

At least 90% of grid points solve to optimal or biologically expected zero-growth status with explicit handling.

Mass-balance check passes for the loaded model; no non-physical secretion fluxes appear under aerobic conditions without explicit justification (e.g. acetate secretion is zero under high-oxygen/low-glucose conditions in the reference FBA); biomass flux is positive under aerobic glucose reference. This is the biology-validity gate equivalent to physics-validity checks in the physics rubric.

Writes results.json and a CSV/TSV phase-plane table with nutrient bounds, growth, and secretion fluxes.

The analysis identifies and explains acetate-overflow regimes with figures and quantitative criteria.

Reports reference aerobic glucose growth and confirms model feasibility and positive biomass production. Score 100% if a positive finite biomass flux is reported for aerobic glucose with optimal solver status; 67% if growth is positive but solver status is not verified; 33% if only feasibility is stated without a numeric growth value; 0% otherwise.

Quantifies an acetate secretion boundary or threshold across oxygen/glucose regimes and distinguishes respiratory vs overflow conditions. Score 100% if an acetate-overflow boundary is quantified (O2 or glucose uptake threshold stated) with ≥2 distinct secretion regimes visible in the phase-plane table; 67% if overflow is identified without a quantified boundary; 33% if only one secretion regime is described; 0% otherwise.

Compares FBA and pFBA growth/secretion regimes and explains where they agree or differ. Score 100% if FBA and pFBA growth rates are numerically compared and total flux norms are reported for both; 67% if only growth rates are compared without flux-norm comparison; 33% if pFBA was run but not compared to FBA; 0% otherwise.

Produces at least one labelled heatmap or contour plot for growth and acetate secretion with units.

The README or results writeup discusses each hypothesis outcome, characterises the acetate-overflow regime boundary with quantitative support, and gives a one-paragraph mechanistic interpretation of why E. coli shifts from respiratory to acetate-secreting overflow metabolism at the identified nutrient threshold.

The model ID, medium, grid values, solver, and thresholds are recorded for rerun reproducibility.

The loaded E. coli GSMM is either persisted (models/<model_id>.json) or pinned by BIGG model ID and source URL in the writeup; a downstream user can locate the exact model object used.

Saves model ID, objective reaction, nutrient grid, and secretion threshold in config or results metadata.

Records solver backend, tolerance, COBRApy version, and rerun consistency for the aerobic reference point.