RSFQ logic

Combined chip analysis: ONE call -> verify + timing + yield + bias.

The PRIMARY endpoint for the unified chip-analysis UI. Bundles all four sub-analyses over the same composed circuit, each keeping its own source / confidence / caveats. Yield is timing-gated only when the nominal timing analysis closed. If a sub-analysis errors, its slot carries {"error": {...}} and the others still return -- the call never 500s on a sub-failure (only a malformed top-level request is a 400). Sync def so the (CPU-bound) engines run in the threadpool.

First-order RSFQ bias-network sizing for a composed circuit.

Reads every standing DC bias source in the merged deck and reports total + per-cell bias current, resistor-bias sizing (Rb = Vsupply/Ibias), and an honest static-power figure with the ERSFQ/eSFQ zero-static-power note. Returns the engine contract incl. source / caveat (HONEST: first- order, NOT a routed/extracted bias network). Bad input -> 400 envelope.

Emit an extraction-ready handoff manifest for a real extractor.

The HONEST path to real inductances: a human/tool-readable manifest of the composed circuit's instances + wires for InductEx/FastHenry on the laid-out GDS, rather than a faked field solve. Returns {manifest}; bad input -> 400 envelope.

Assembled GLOBAL bias-rail (and Ic) margin for a composed passive circuit.

A real chip shares ONE bias rail across every cell, so the band that matters at tapeout is where the WHOLE composed chain still works -- always tighter than any single cell, and pinned by whichever stage gives out first. Walks one global scale on every standing bias source (and, by default, every JJ Ic), re-judging the end-to-end functional verdict, and returns the assembled band + the limiting stage + honest caveats. Passive dataflow only; a clocked circuit returns supported: False (HTTP 200). Sync def so the (CPU-bound) margin walk runs in the threadpool. Bad input -> 400 envelope.

First-order inductance ESTIMATE for one wire / route segment.

L = Ls_per_sq * (length/width) squares rule on a process sheet inductance. geometry is a length in um (number) or a {length_um, width_um?, n_squares?} dict; process is a process-registry name (the same record /api/process serves; an unknown name is a 400 unknown_process, never a silent default) or an override dict. Returns L_pH + sheet_L_status + the method / caveat that say this is an order-of-magnitude estimate, NEVER extraction. Bad input -> 400 envelope.

Assembled bias margin of the SAME chip retargeted across fab processes.

Retargets the composed netlist to each named process (JJ model swap + junction-area renorm to hold the design Ic) and recomputes the assembled bias band (coarse, bias-only). The margin shift across nodes reflects each process's IcRn / gap / specific-capacitance differences plus an un-reoptimized design. Passive dataflow only. Sync def (CPU-bound margin walks run in the threadpool). Bad input -> 400 envelope.

List the literature-anchored RSFQ process records (for the UI selector).

Each record carries its source / confidence / caveat (the honesty contract) verbatim -- these are order-of-magnitude ANCHORS, not fab-calibrated PDK data.

Three-way operating-point validation: surrogate vs analytic vs JoSIM.

The trust handle: pick an operating point (global bias_factor / ic_factor on the shared rail + JJ Ic) and get, side by side, the FAST surrogate verdict, the EXACT analytic verdict, and REAL JoSIM on the SAME flattened deck (degrading cleanly to available: False when no JoSIM binary is installed), with agreement flags. Scaled points are passive-only; clocked circuits validate at nominal. A missing JoSIM binary is a clean 200 (agreement exact_vs_josim: None); only a malformed request is a 400, including a custom-cell cir with a file-touching JoSIM directive (refused before JoSIM runs, see josim_confirm.check_deck). Sync def so the (subprocess + CPU) work runs in the threadpool.

Chip-level RSFQ yield by analytic Monte Carlo over a composed circuit.

Under per-junction Ic (area) + per-inductor L Gaussian process variation, what fraction of dies keep EVERY cell functional end to end? This is the CORRECT RSFQ-logic yield model and REPLACES the misapplied transmon frequency-collision model for RSFQ layouts. Returns yield_fraction, per-cell pass rates, limiting cell(s), and intact source / caveats (HONEST: analytic-engine yield over a process-variation MODEL, not fab- measured). Sync def so the (CPU-bound) Monte Carlo runs in the threadpool. Bad input -> 400 envelope.

Export the composed circuit as a JoSIM-runnable .cir deck.

The honest handoff: every instance's bare cell is built, nets/designators prefixed per instance, wired ports unified, and the whole thing emitted as one deck behind a single shared jmitll model. driven (default True) adds the same stimulus + .tran / .print the analytic verify uses, so JoSIM runs the identical experiment. Returns {deck, driven, format}; bad input -> 400 envelope. format="wrspice" translates the same deck to WRspice (see /api/sfq/cir).

Confirm a composed circuit (or raw deck) against REAL JoSIM.

Accepts either cells (+ optional wires) -- the driven deck is built via composed_deck_cir -- or a raw deck string (wins if supplied). Shells out to a JoSIM binary under a hard timeout when one is on PATH / FLUXUS_JOSIM; otherwise degrades cleanly to available: False / source: "analytic". NEVER hangs and NEVER 500s when JoSIM is absent. A deck using a file-touching directive (.include, .file, .iv, .control, a cus(...) source, or any directive off the allowlist in josim_confirm.check_deck) is refused with a 400 naming it, before JoSIM runs. binary is the bare executable name, never its path. Returns the josim_confirm contract plus josim_available; the confirmed deck text comes back only when JoSIM ran (otherwise deck_withheld names /api/circuit/deck). timeout_s above JOSIM_TIMEOUT_MAX_S (the request budget) is a 422. Sync def so the (subprocess-bound) call runs in the threadpool.

Analytic (nominal-inductance) timing analysis of a composed circuit.

Composes the cells+wires, drives + simulates once on the analytic engine, and reports per-path propagation delay, clock arrival + worst-case skew, per-stage setup/hold margins, fmax (passive circuits only; refused with a caveat when clocked cells are present), and a closure verdict against the optional clock_period_ps. A stage that should fire and did not is a violation, so a dead circuit never closes. Returns the engine's stable contract incl. source / confidence / caveats (HONEST: nominal, NOT post-layout). Interconnect delay is added only for wires given a length_um: each becomes a PTL hop of driver + length / v + receiver, with v from the stripline geometry, eps_r and the London depth (fluxus.sfq.ptl, Swihart 1961), reported under ptl and in each path's ptl_delay_ps. Bad input -> 400 envelope.

Compose wired RSFQ cells into ONE netlist and verify it end-to-end.

Builds each cell's bare graph, prefixes its nets by instance id, unifies wired ports into shared nodes, merges into a single deck behind one shared jmitll model, drives the detected input with a single SFQ pulse, and simulates on the analytic SPICE engine to confirm the pulse propagates stage-to-stage to the output. Returns per-stage slip counts, the end-to-end output pulse count, the input->output propagation delay, and a functional verdict. Un-clocked SFQ dataflow (jtl / splitter / custom) composes; clocked cells (dff / and2 / or2) are scoped out of v1 with a clear note. Sync def so the (CPU-bound) engine runs in the threadpool. Bad input (no cells, malformed wires, unknown cells/ports, clocked cells) yields a 400 with the structured error envelope.

Named, literature-anchored RSFQ process / PDK parameter sets.

Returns {processes: [record, ...]} for every node in the registry (MIT-LL SFQ5ee-style, AIST STP-style, generic teaching node). Each record carries source (citation), confidence ({low, medium} -- never high) and caveat (NOT fab-calibrated PDK data) verbatim. Treat values as order-of-magnitude anchors.

Export the JoSIM .cir netlist for one RSFQ cell + experiment.

Builds the cell deck for the given experiment (default = the cell's canonical active case) with optional params overrides and emits it as JoSIM-runnable .cir text. Powers the "download .cir" button. Bad cell/param/experiment yields a 400 with the structured error envelope.

format="wrspice" returns the same circuit in WRspice syntax under the same cir key, plus probes (each JoSIM .print and the WRspice vector it became), untranslated, notes and verified (true only for a deck that was itself run in WRspice). The default format="josim" response is unchanged apart from format.

Both formats carry tests: the exported experiment as a /api/sfq/netlist/margins test (inputs empty because the deck drives its own stimulus, expected the library experiment's per-junction slip counts; postable as is), deck_pulses_ps (the stimulus times the deck already drives) and experiments (the cell's experiments, each its own deck).

Score a user-supplied SFQ netlist (custom-cell live feedback).

Margins of a user netlist under a user functional test.

Runs the analytic engine (the one behind every exact-engine library margin) on the caller's netlist. Each knob (global bias, global ic, or each_bias / each_inductor / each_ic one element at a time) is walked out from nominal in bracket_step steps until a test fails, then bisected to resolution. Returns per-knob low / high (last passing factors), the first failing factors, censoring, what limited each edge, the critical (nearest-edge) element, and run counts. confirm="josim" reruns the boundary points of the global knobs and the critical element in JoSIM where a binary is found.

These are analytic-engine margins, not surrogate output. A netlist the engine cannot simulate (transmission lines, unsupported sources, symbolic values, too large) is a 400 naming the reason. Runtime is capped by budget_s (default and maximum: the request budget); the response echoes the budget_s used (budget_from says whether it was the request's or the server default) and elapsed_s. Knobs left when the budget runs out are listed in not_swept. Every response carries estimate (points, transients and seconds the sweep can take, counted and timed from the nominal run); estimate_only=true returns only that. Sync def so the CPU-bound sweep runs in the threadpool.

Maximize the analytic bias-margin width over a cell's knobs.

Coordinate-ascent inverse design, functional-gated, bounded to <= 60 analytic margin evaluations. Sync def so the (CPU-bound) search runs in the threadpool. Bad cell name yields a 400 envelope.

Physics-unit knobs (bias% / βL / βc) for one cell -- read and set.

READ: returns each defined physics knob's current value and the raw spec field it maps to. SET: when targets is supplied (e.g. {"betac": 1.0}), also returns applied_params -- the raw spec overrides that realize those targets with the junction Ic held fixed, ready to post back as params. Fast (pure arithmetic). Bad cell / param / target -> 400 envelope.

Fast surrogate margin prediction for an RSFQ cell or raw netlist.

Accepts a named cell (+ optional params) or a raw cir netlist. Returns the surrogate's functional verdict and bias/Ic band factors (or abstains). Sync def so model inference runs in the threadpool. Bad input yields a 400 with the structured error envelope.

Predict many designs of one cell in a single call.

Each entry in specs is the same param object /api/sfq/predict takes, and each result is byte-identical to what that endpoint would return for the same design -- same envelope gate, same conformal escalation, same per-quantity refusal. The gate is the same function the single path calls, including the graph check on the built deck (the batch skipped that until 2026-10-11, audit RC-023). results is positionally aligned with specs; a spec that fails validation becomes an error object in its own slot rather than failing the batch. A value that is not a finite number is refused for the whole request by the schema, with a 422 naming specs[i].knob, like any other wrongly typed value.

This exists because per-call overhead dominates: 11.2 ms/spec one at a time versus 0.25-0.30 ms/spec batched (measured 2026-10-11 over 1000 specs, deck build and graph check included), so a 1000-cell sweep goes from about 11 s to about 0.3 s. Requests over 5000 specs are TRUNCATED and say so in a clamped block rather than being rejected.

Real per-cell knob schema (the UI's single source of truth).

Knob keys are the exact dataclass field names (so the UI posts them straight back as params); ranges come from the cell_problems / comparator knob dicts and defaults from the validated base specs. DFF exposes a curated subset of its search knobs.

Analytic SPICE engine margins for one RSFQ cell (jtl/splitter/dff).

Runs the JoSIM-validated, WSL-free analytic engine: functional verdict, per-JJ slip counts, and coarse-step bias/Ic margin bands. Sync def so the (CPU-bound) engine runs in the threadpool. A bad cell name or unknown param yields a 400 with the structured error envelope.

One-call single-cell datasheet: margins + timing + yield + surrogate.

Runs the standard characterization battery for one RSFQ cell and bundles it: exact-engine functional verdict + bias/Ic margins, propagation delay + max toggle rate (fmax), process-variation yield, and a fast surrogate cross-check (surrogate_agrees). Each section keeps its own source / note; a section the exact engine cannot serve fast (e.g. the DRO latch) passes an unsupported payload instead of failing the datasheet. Sync def so the (CPU-bound, ~1-2 min) battery runs in the threadpool. Only a malformed request (bad cell / param) is a 400.

2D bias x Ic operating-region (shmoo) map for one RSFQ cell.

Sweeps an n x n grid (n clamped 5..13, default 9) of bias x Ic scale factors through the analytic engine, marking each point functional iff the full truth table passes. Sync def so the (CPU-bound) sweep runs in the threadpool. COST: n*n analytic transients (~1 s each); default n=9 is ~81 sims (~1-2 min). Bad input yields a 400 envelope.

1-D sensitivity curve: one knob vs. one metric for an RSFQ cell.

Varies knob across its schema range in n points (clamped 5..21) and computes metric (bias_margin / ic_margin band width, delay ps, or functional 1/0) at each via the analytic engine; non-evaluable points are null rather than failing the sweep. Sync def so the (CPU-bound) sweep runs in the threadpool. Bad cell/knob/metric yields a 400 envelope.

Propagation delay + max operating frequency for one RSFQ cell.

Runs the analytic engine on the cell's canonical active experiment (or a named one): propagation_delay_ps (slips timed at their voltage peak; passive cells: input-JJ first slip -> output-JJ first slip; clocked dff/and2/or2: clock edge -> output-JJ first slip, the same reference /api/circuit/verify uses) and fmax_ghz (bounded pulse/clock-train scan for the minimum functional period). Either may be null for cell types that do not support a metric. Sync def so the (CPU-bound) engine runs in the threadpool. Bad input yields a 400 envelope.

How much static trapped flux a cell's loop tolerates, or the yield under a drawn trapped flux (plus optional Ic spread).

mode="tolerance" (default): for each target inductor, the contiguous working window of static flux around zero, in Phi0, on the analytic engine with the full truth table as the gate, plus the pulse counts at the first failure on each side. mode="yield": the fraction of n_trials drawn devices that work with flux ~ N(0, trap_sigma_phi0) per target and per-junction Ic ~ N(1, ic_sigma_pct). The response states what is modelled, what is assumed (the target loop and the flux size) and what is not modelled (the probability of trapping a vortex). Bad input -> 400.

Per-JJ phase(t) traces + slip-event times for one RSFQ experiment.

Runs the analytic engine on the named experiment (default = the cell's canonical active case) and returns the phase trace (downsampled to <= 400 points) and slip-event times per junction (each at the slip's voltage peak). Sync def so the engine runs in the threadpool. Bad input yields a 400 envelope.

Process-variation Monte Carlo yield (the tapeout question).

Each trial perturbs EVERY junction's critical current independently (Gaussian on each JJ area; effective Ic = icrit*area) and optionally each inductor, then checks the full truth table; yield_fraction = functional / n_trials from a seeded RNG. Sync def so the (CPU-bound) Monte Carlo runs in the threadpool. COST: n_trials * #experiments analytic transients (~1 s each); n_trials clamped <= 120, default 40 (~40 s). Bad input yields a 400 envelope.