Qubit design

Evaluate one placed cell with its surrogate (metrics + health).

Chip map for rendering: node coordinates, roles, edges, targets.

Coordinates are lattice grid units (scale freely). role is the heavy-hex role code (0/1 vertex sublattice, 2 edge qubit; square lattices report -1). f_ghz is the default frequency-allocation pattern the yield Monte Carlo uses when no targets are supplied.

ZZ and effective qubit-qubit coupling vs tunable-coupler frequency, and the idle points where each crosses zero (exact), beside Yan et al.'s analytic g~ and its zero.

Dressed frequencies, anharmonicities and the full chi matrix of a small lumped circuit (a trimon, a coupled pair, a chain), by exact diagonalisation. chi_ij = E(1_i 1_j) - E(1_i) - E(1_j) + E(0).

J, static ZZ (exact and perturbative) and dressed frequencies of two transmons coupled by a capacitor (capacitive) or a shared resonator (bus). A value whose dressed levels are hybridised is null, with the reason in refused.

Partial-inductance field solve over supplied conductor segments.

Runs the REAL closed-form PEEC field solver (fluxus.em.inductance.extract_inductance): Grover straight-bar self terms + Neumann centre-filament mutuals, reduced to a loop/net inductance, with optional London kinetic inductance and a perfect-conductor ground-plane image. Returns the solver's stable dict: L_pH, L_geometric_pH, L_kinetic_pH, L_matrix_pH, n_segments, n_image_segments, london_nm, ground_plane, method, caveat.

DISTINCT from /api/chip/parasitics (a squares-rule ESTIMATE) and /api/chip/extract (an extraction HANDOFF manifest): this is an actual field solve. Its loop sums are checked against closed-form PEEC sums (hairpin, rectangle, square loop) and its mutuals against an independent Neumann quadrature; the model itself (centre-filament mutuals, uniform-current bar self term, ideal image plane) is not validated against measurement or a full field solver, and it is NOT InductEx-grade (no cross-section current solve, no multilayer superconducting stackup). Bad geometry yields a 400 with the structured error envelope.

Evaluate a placed design: per-cell metrics + chip-level rollup.

Export one quantum design cell as a GDSII mask, base64 in JSON.

Builds the planar transmon + CPW-resonator layout with fluxus.layout.gds.cellspec_to_gds (same pad / gap / ground-cutout conventions as the capacitance solver) and returns the GDS file bytes as base64 so the browser can download it. Returns {filename, gds_base64, size_bytes, n_polygons, area_um2, source}. HONEST scope: a single-qubit-plus-resonator mask for layout sanity and area accounting, NOT a DRC-clean, tape-out-ready reticle and NOT an EM mesh. Bad cell parameters yield a 400 with the structured error envelope.

Export one TransmonCross cell (the SQuADDS geometry) as GDSII bytes.

Draws qiskit-metal's TransmonCross with fluxus.layout.cross (cross, cross pocket, claw with its ground spacing and claw_cpw stub, and a junction marker) and returns the file itself, application/octet-stream with a Content-Disposition filename. Unlike /api/gds (base64 in JSON), the body is the .gds file.

A geometry outside the trained envelope is still exported, since it is only geometry. X-Fluxus-Envelope says in or outside: whether /api/qem/cross's predictions for this cell come from the HFSS-trained engines (capacitance and fr), and X-Fluxus-Envelope-Detail is the JSON from fluxus.layout.cross.cross_envelope naming the field that is outside. HONEST scope (X-Fluxus-Source): the qubit cell alone, not the resonator, not a tape-out-ready reticle and not an EM mesh. A geometry that cannot be drawn, or a non-physical junction or resonator value, is a 400 with the structured error envelope, as on /api/gds.

Inverse design: targets -> ranked, oracle-verified candidates.

Every candidate is re-solved with fluxus.physics.solve_cell (result.source == 'oracle') and ranked by ascending weighted normalized distance to the targets.

Inverse design over the SQuADDS TransmonCross envelope.

Enumerates the whole 4-parameter design space with a fast accelerator, re-solves the finalists with the REAL chain, then polishes them continuously so the answer does not depend on where the grid points fell. Every returned number comes from solve_cross_cell, never from the accelerator.

Simulated reference (HFSS), never silicon. A returned design is a proposal to simulate, not a fabrication instruction.

Josephson junction calculator: one of Lj, Ic, EJ, Rn_room -> all the rest.

Closed forms (fluxus.physics.junction): Lj = Phi0/(2 pi Ic), EJ = Phi0 Ic/(2 pi), Ic = Jc * area, and the Ambegaokar-Baratoff Ic*Rn = pi Delta/(2e) at T = 0 with Delta = 1.764 kB Tc. Returns lj_nh, ic_na, ej_ghz, rn_ohm_cold, rn_ohm_room (null unless room_over_cold_ratio is given), ic_rn_uv, gap_uev, area_um2 (null unless jc is given), the echoed input and settings, and notes. Missing, duplicate, inconsistent or non-physical input is a 400 naming the problem. Analytic, not measured.

Logical-qubit preflight: a bounded answer plus its refusals.

NO PROJECT REQUIRED. Every input has a default or a refusal, because the chain answers a PRE-BUILD question and the person asking it may not have a project yet.

The response deliberately carries structure a caller could flatten and must not: every channel keeps its kind (PREDICTED / PROFILE / BOUND / REFUSED), leakage stays a RANGE conditional on has_lru, and quotable says which of the four decision modes may be answered at all. The go/no-go is REFUSED and that refusal is part of the answer.

Predict the five Hamiltonian targets for one cell.

Returns a serialized fluxus.core.PredictionResult: value (HamiltonianResult incl. source), intervals (split-conformal, alpha=0.1, only when calibration residuals exist and the prediction did not abstain; a weak-tier answer has no chi_mhz interval, see fluxus.qem.chi_tier), in_envelope, abstained, model_version.

Hamiltonian for one TransmonCross cell (SQuADDS geometry family).

Each step is exact, trained on HFSS, or a named closed form: geometry -> capacitance matrix (HFSS-trained, 0.30%/0.56% median held-out), capacitance -> EC and L_j -> EJ (exact; C_sigma is the cross-to-ground capacitance plus the claw path in series with the resonator, and leaves out the junction's own capacitance), EC/EJ -> f01 and anharmonicity (exact Cooper-pair box), resonator -> fr (HFSS-trained on the one CPW cross-section SQuADDS simulated, no kinetic inductance), g from the two-node capacitance matrix with the resonator capacitance taken as the admittance slope of the loaded line at the claw node (trained fr, an analytic cross-section Z0 and the HFSS-trained claw-to-ground capacitance; not trained itself, and coverage of its interval is not measured), and finally chi by exact diagonalisation.

claw_cpw_length_um (default 40, the only value in the HFSS capacitance data) is not a model input. Another value is answered, with in_envelope false and outside_trained_configuration naming it.

This is the geometry family qiskit-metal and SQuADDS use. The parallel-pad POST /api/qem path is a DIFFERENT, incompatible geometry and is unaffected.

Refuses with HTTP 422 and a structured outside_envelope body rather than extrapolating the capacitance. A resonator outside the fr engine's envelope is answered with the analytic CPW form instead, and then in_envelope is false, abstained is true and out_of_envelope names the fr refusal. Simulated reference, never silicon.

Readout (added 2026-10-16, fields only added): kappa_khz (kappa / 2 pi, the coupled-line closed form fed with the chain's fr, scored against SQuADDS HFSS kappa), kappa_source, purcell_t1_us (single-mode Purcell limit, divided by the optional user-supplied purcell_filter_suppression), purcell_source, and a readout block with validation flags, refusals and the dispersive-form value.

lambda/2 (2026-10-16): the resonator carries its NCap coupler (finger_count, finger_length_um, cap_gap_um, cap_width_um; defaults are the half-wave eigenmode rows' coupler), and fr and kappa both come from the half-wave NCap engine (kappa_source squadds_halfwave_ncap): HFSS-trained eigenmode fr and NCap capacitances through the series-coupled closed form SQuADDS's own half-wave table is built with. readout.halfwave carries the capacitances and the eigenmode fr before the coupler's loading. Outside its envelope fr falls back as above and kappa is null with the reason.

Many TransmonCross designs in one call.

results is aligned with items; each slot is exactly the /api/qem/cross body for that item (its 422 or 400 error body when it is refused or malformed) plus status, the HTTP status it would have had. summary counts answered, abstained, refused and error slots and the fields refusals named. Over 500 items: truncated with clamped. Past the request budget: budget_exhausted slots and budget.

f01, anharmonicity, g, chi and the Purcell T1 limit against flux.

Each point is the full /api/qem/cross chain with EJ(Phi) from the asymmetric DC-SQUID relation (Koch et al. 2007, Eq. (2.13)); the geometry, EC, fr and kappa do not depend on flux and are the same at every point. Columns are lists aligned with flux_phi0; a point that cannot be solved (EJ = 0 for a symmetric SQUID at half a flux quantum) is null there with the reason in refused, and an unresolved chi is null with chi_method saying so. transmon_regime is false where EJ/EC < 20. No intervals. Off-envelope geometry is refused (422) as on /api/qem/cross.

One or two TransmonCross fields over a linear grid, point answers.

Every point is the /api/qem/cross answer for base plus the grid values, projected to f01, anharmonicity, fr, g, chi, EC, EJ, kappa, Purcell T1, regime and source, or to the refusal's code, field and reason. n defaults to 21 and is clamped to 201 for one axis and 41 per axis for two, with a clamped block. No intervals: ask /api/qem/cross/batch with intervals at the points you care about.

Every qubit-design input: unit, default, role (swept, pinned, free, resonator, control), range or pinned value, the unsampled ground-spacing gap and the claw support rule; outputs with units; the engines behind each step; interval coverage; refusal kinds; batch and sweep limits; exit codes; and every qubit route with its CLI command. Read from the constants the engines refuse by.

Whether each qubit-design engine loads on this host, with versions.

Which TransmonCross candidates still need your solver.

ACCEPT when every requirement's calibrated interval sits inside its window, REJECT when one sits wholly outside, SIMULATE otherwise (and for a refused design, an abstention or a missing interval). Never reads the point estimate. Returns per-candidate decisions with reasons, counts, simulate_rate and the accept and reject risk BOUNDS (k x alpha and alpha), which are bounds from coverage, not measured decision error. Up to 200 candidates; each is an interval solve (about 0.16 s).

The /api/qem prediction for one parallel-pad cell beside the analytic oracle's: per-target delta (predicted minus verified) and, where an interval is served, whether the oracle value falls inside it. The oracle is a closed form, not an EM solver; this checks the surrogate against its own teacher.

Predict resonator fr (GHz) with the persisted SQuADDS surrogate.

Input is resonator geometry (ResonatorSpec fields + optional coupling_length_um). Returns fr_ghz from the data-trained surrogate, its held-out rel_interval (the measured p95 relative error, a fractional band -- NOT a per-point conformal interval), and source: "squadds_surrogate". HONEST: trained on SQuADDS HFSS eigenmode simulation (EM-simulated, not silicon); predicts the resonator fr only. 503 (with the shared error envelope) when the checkpoint has not been trained/persisted yet.

Monte Carlo frequency-collision yield for a fixed-frequency chip.

Returns a serialized fluxus.core.YieldReport: n_trials, yield_fraction, collision_counts (Hertzberg et al. arXiv:2009.00781 rule name -> mean violations per chip), notes.

Yield versus frequency spread: [[sigma_f_mhz, yield], ...].

Yield Monte Carlo with per-qubit collision attribution.

Same simulation as /api/yld plus per_qubit_rate (fraction of trials each qubit participated in >= 1 violation -- for chip-map coloring) and targets_ghz (the allocation pattern used).

Frequency-collision yield over the supplied qubit graph + targets.

Runs the SAME Hertzberg et al. (arXiv:2009.00781) collision Monte Carlo as /api/yld, but over the EXPLICIT topology the caller supplies -- frequencies_ghz[k] is qubit k's target frequency and edges are 0-based index pairs (the floorplan's real wiring) -- rather than a generated heavy-hex / square lattice. Mirrors the shape of /api/yld/detail so the frontend can reuse its rendering: n_qubits, n_edges, n_trials, yield_fraction, collision_counts, per_qubit_rate, note, source.

n_trials is clamped to <= 50000. Empty frequencies or edges that reference out-of-range / self-looped indices return a 400 envelope.