MonomialPropagator

Number of distinct variational parameters seen while building the graph.

Number of authoring gates ingested into the graph.

A single-term gate expands to one graph layer; a multi-term gate expands to several layers sharing one gate, so n_gates \<= graph_layers. Stays correct after a graph prefix is consumed by :meth:contract_partially / :meth:propagate.

The parameter mapping owned by the graph, one entry per graph layer.

Entry i is the variational-parameter index driving the i-th graph layer (a generated Majorana monomial), in the same order as the parameter vector passed to :meth:expectation_value. This is the graph's native (per-monomial) mapping, which is finer-grained than the per-gate mapping of the authoring :class:~monoprop.circuit.Circuit when gates bundle several monomials.

Number of fermionic modes for the simulator.

Number of evolved Majoranas (graph layers).

Whether the simulator is in the Schrodinger picture (else Heisenberg).

Current cutoff value for the simulation.

Current lower absolute tolerance for the cutoff function (None if unset).

Current upper absolute tolerance for the cutoff function (None if unset).

Current cutoff type ("length" or "support").

Read-only on the base; :class:~monoprop.majorana_propagator.MajoranaPropagator exposes a setter since either scheme is valid there.

Construct a propagator from a circuit and propagate it in one step.

Uses circuit.initial_state as the reference state and evolves circuit in place via :meth:propagate -- a one-shot contraction that stores no graph. The observable (initial_operator) and truncation settings (cutoff and the rest of config) are supplied separately -- they are not part of the circuit.

Read the result off the evolved operator/state with :meth:evolved_operator (or :meth:expectation_value) taking no parameters -- the circuit's angles are already applied. This is the memory-lean path for a single evaluation; if you instead need a reusable graph to re-evaluate at many angles (or to take gradients), construct the propagator directly and call :meth:build_graph.

Append a circuit to the propagation graph.

Builds (or extends) the reusable evolution graph, recording each layer's gate information (the parameter that drives it and its generator coefficient) so that later evaluation takes only parameters. The circuit's angle indices are local (0-based); when extending a non-empty graph they are shifted up onto the accumulated parameter axis automatically, so each call's circuit is authored independently.

Evolve and contract immediately, without storing a graph.

More memory-efficient than :meth:build_graph because it does not retain the propagation graph; use it for a single contraction at the circuit's parameters rather than repeated re-evaluation.

Compute the expectation value at parameters.

Replays the stored graph against the current initial operator and reference state. This is a convenience wrapper that builds and immediately evaluates an expectation-value functional with no paring.

Compute the expectation value and gradient at parameters.

Both quantities are computed in a single backward pass over the graph.

Compute the gradient at parameters.

Return a reusable callable computing the expectation value from parameters.

Returns a callable that accepts a parameter vector (a sequence, or None) and returns the expectation value, replaying the current evolution graph. Build it once and call it repeatedly across many parameter values.

Return a reusable callable computing (expectation value, gradient).

Like :meth:expectation_value_functional, but the returned callable computes both the expectation value and the full parameter gradient in a single backward pass over the graph.

Contract the graph into the operator/state at parameters.

Permanently folds the stored gates, evaluated at parameters, into the operand: the initial operator in the Heisenberg picture, or the reference state in the Schrodinger picture. This shrinks the graph that remains to be replayed, which is useful when a prefix of the circuit is fixed and its contribution can be baked in once instead of being replayed on every evaluation.

Return the evolved operator/state as a dict, without modifying state.

Equivalent to :meth:contract_partially with inplace=False, returned as a mapping keyed by Majorana indices and without touching the simulator state.

Replace coefficients of the initial operator (existing terms only).

Re-weights the initial operator the graph is evaluated against, without touching the evolution graph or rebuilding the simulator. Only the initial operator is affected -- the gates and their generator coefficients are unchanged -- and only Majorana terms already present in the initial operator can be updated (no new terms are introduced).

Number of Majorana terms currently tracked.

Size metrics of the evolution graph.