quchip.engine¶

Engine pipeline: Chip → ResolvedFrame → EngineResult → SolveProblem.

The engine is the physics-to-solver layer. It owns no solvers and no backend-specific types, and produces structured, backend-agnostic descriptions that each backend converts to its own optimal form.

Responsibilities¶

quchip.engine.frames resolves a FrameSpec into ResolvedFrame (per-device frame frequencies, demodulation frequencies, and the frame mode).
quchip.engine.assembly assembles an EngineResult with static terms, dynamic terms, and their ScalarModulation signal programs. It applies 2π, rotating-frame subtraction, RWA band decomposition (Jaynes & Cummings 1963; Gambetta et al., PRA 74, 042318 (2006)).
quchip.engine.excitation reads the excitation-number structure of a resolved chip into an ExcitationStructure.
quchip.engine.observables decomposes dict-form e_ops into solver-ready bands and, after the solve, demodulates expectations back into the lab/control frame.
quchip.engine.problem packages solve inputs (including collapse operators) into a frozen SolveProblem or SolveBatch.

Public API¶

simulate(): full pipeline + solve + wrap result.
build_problem(): assemble and package a SolveProblem.
solve_problem(): dispatch a SolveProblem through the chip’s backend.
solve_batch() / solve_many(): batched dispatch.

Functions

`build_engine_result`(chip, drive_ops, **kwargs)	Assemble a `EngineResult` for a resolved frame.
`build_problem`(chip, drive_ops, tlist, *[, ...])	Resolve, assemble, and package a frozen `SolveProblem`.
`build_steadystate_problem`(chip, **kwargs)	Build a frozen static Lindblad steady-state request.
`simulate`(chip, drive_ops, tlist, *[, ...])	Build a `SolveProblem`, dispatch it, and wrap the solver output.
`solve_batch`(batch, *[, progress, max_workers])	Dispatch a `SolveBatch` through its chip backend.
`solve_many`(batch_or_problems, *[, progress, ...])	Solve a native batch or an ordered collection of captured requests.
`solve_problem`(problem)	Dispatch a `SolveProblem` through its chip backend.
`steadystate`(chip, **kwargs)	Solve a chip's unique static Lindblad steady state.
`steadystate_batch`(chip, axes, *kwargs)	Solve static Lindblad steady states over parameter axes.

Modules

`approximations`	Engine-side operations owned by explicit approximation strategies.
`assembly`	Assemble an `EngineResult` from chip physics, controls, and frame.
`bands`	Band decomposition by excitation-change weight.
`basis`	Local energy-basis resolution and explicit transformation records.
`conditional_response`	Weak-probe commutator sources for a frozen dressed reference.
`dressing`	Assign dressed eigenvectors to bare or eigenstate references, and build dressed results.
`excitation`	Excitation-number structure of resolved chips.
`field_noise`	Thermal input fields in the instantaneous network's physical channel basis.
`field_statistics`	Stationary output statistics and their propagation through resolved wiring.
`frames`	Resolve integration frames and observable-demodulation frequencies.
`input_output`	Backend-neutral input-output assembly for stationary port calculations.
`ir`	IR types shared by engine responsibilities and backends.
`linear_response`	Structural lowering for exact passive-linear input-output response.
`monitoring`	Select declared physical channels for continuous diffusive monitoring.
`observables`	Band-decompose dict-form `e_ops` and demodulate expectations after the solve.
`output_network`	Acyclic reference transformations downstream of the Markovian boundary.
`partitioned`	Partition-aware dispatch for `quchip.engine.simulate()`.
`problem`	Package engine physics and solve inputs into frozen solve requests.
`pulse_space`	Invariant excitation spaces for deterministic evolution.
`reference`	Reference-plane transforms applied outside the Markovian core.
`routes`	Choose how stationary and static calculations solve, and record the reason.
`sampling`	Automatic output sampling over captured physics, separate from solver steps.
`sector_stationary`	Stationary states and output statistics of excitation-conserving chips on sectors.
`sectors`	Excitation sectors and cutoff classes of a chip's static model.
`slh`	Gough-James algebra on resolved SLH triples: series product, concatenation, feedback.
`solver_hints`	Advisory solver-hint heuristics (post-assembly metadata only).
`states`	State preparation in the solver basis.
`steady_state`	Build and solve backend-neutral stationary Lindblad problems.
`truncation`	Captured physical cutoff checks, sampled without storing state histories.