API Reference

This page contains the auto-generated API reference for the pyrauli package.

pyrauli: A Python Wrapper for ProPauli

This package provides a high-performance Python interface for quantum circuit simulation, powered by the C++ propauli library.

class pyrauli.AlwaysAfterSplittingPolicy

Bases: SchedulingPolicy

A policy that applies an optimization just after every splitting gate.

class pyrauli.AlwaysBeforeSplittingPolicy

Bases: SchedulingPolicy

A policy that applies an optimization just before every splitting gate.

class pyrauli.Circuit

Bases: pybind11_object

Represents a quantum circuit and provides a high-level simulation interface.

add_operation(*args, **kwargs)

Overloaded function.

add_operation(self: pyrauli._core.Circuit, op: str, qubit: int) -> None

Adds a single-qubit gate.

add_operation(self: pyrauli._core.Circuit, op: str, qubit: int, param: float) -> None

Adds a single-qubit gate with a parameter.

add_operation(self: pyrauli._core.Circuit, op: str, qubit: int, theta: float, phi: float, lambda: float) -> None

Adds a single-qubit gate with three parameters (U3).

add_operation(self: pyrauli._core.Circuit, op: str, control: int, target: int) -> None

Adds a two-qubit gate.

cx(self: pyrauli._core.Circuit, control: int, target: int) → None: Adds a CNOT (CX) gate.

eiht(*args, **kwargs)

Overloaded function.

eiht(self: pyrauli._core.Circuit, pauli_axis: list[pyrauli._core.Pauli], t: float) -> None

Adds a global evolution gate for a Hamiltonian term e^(-iHt) where H is the Pauli axis.

eiht(self: pyrauli._core.Circuit, pauli_axis: list[str], t: float) -> None

Adds a global evolution gate from a list of Pauli strings.

expectation_value(*args, **kwargs)

Overloaded function.

expectation_value(self: pyrauli._core.Circuit, target_observable: pyrauli._core.Observable, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy] = <pyrauli._core.SequentialPolicy object at 0x7f85616d6a30>) -> tuple[float, float]

Simulate one observable on the circuit and return only its expectation value.

expectation_value(self: pyrauli._core.Circuit, target_observables: list[pyrauli._core.Observable], runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy] = <pyrauli._core.SequentialPolicy object at 0x7f85616daa30>) -> list[tuple[float, float]]

Simulate a batch of observable and returns each of their expectation values.

h(self: pyrauli._core.Circuit, qubit: int) → None: Adds a Hadamard gate.

i(self: pyrauli._core.Circuit, qubit: int) → None: Adds an Identity gate.

nb_qubits(self: pyrauli._core.Circuit) → int: Gets the number of qubits in the circuit.

reset(self: pyrauli._core.Circuit) → None: Clears all operations from the circuit.

rp(*args, **kwargs)

Overloaded function.

rp(self: pyrauli._core.Circuit, pauli_axis: list[pyrauli._core.Pauli], theta: float) -> None

Adds a global rotation gate around a specified Pauli axis.

rp(self: pyrauli._core.Circuit, pauli_axis: list[str], theta: float) -> None

Adds a global rotation gate from a list of Pauli strings.

run(*args, **kwargs)

Overloaded function.

run(self: pyrauli._core.Circuit, target_observable: pyrauli._core.Observable, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy] = <pyrauli._core.SequentialPolicy object at 0x7f8561913570>) -> pyrauli._core.Observable

Simulate one observable on the circuit and return its evolved self.

run(self: pyrauli._core.Circuit, target_observables: list[pyrauli._core.Observable], runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy] = <pyrauli._core.SequentialPolicy object at 0x7f85616a42f0>) -> list[pyrauli._core.Observable]

Simulate a batch of observable and returns each of them.

rz(self: pyrauli._core.Circuit, qubit: int, theta: float) → None: Adds an Rz rotation gate.

set_merge_policy(self: pyrauli._core.Circuit, arg0: pyrauli._core.SchedulingPolicy) → None: Sets a new policy for when to merge Pauli terms.

set_truncate_policy(self: pyrauli._core.Circuit, arg0: pyrauli._core.SchedulingPolicy) → None: Sets a new policy for when to truncate the observable.

set_truncator(self: pyrauli._core.Circuit, arg0: pyrauli._core.Truncator) → None: Sets a new truncator for the circuit.

u3(self: pyrauli._core.Circuit, qubit: int, theta: float, phi: float, lambda: float) → None: Adds an U3 gate.

x(self: pyrauli._core.Circuit, qubit: int) → None: Adds a Pauli-X gate.

y(self: pyrauli._core.Circuit, qubit: int) → None: Adds a Pauli-Y gate.

z(self: pyrauli._core.Circuit, qubit: int) → None: Adds a Pauli-Z gate.

class pyrauli.CliffordGate

Bases: pybind11_object

Enumeration for single-qubit Clifford gates.

Members:

H : Hadamard gate.

H = <CliffordGate.H: 0>

CliffordGate.name -> str

property value

class pyrauli.CoefficientTruncator

Bases: Truncator

Truncator that removes Pauli terms with small coefficients.

class pyrauli.CompressionResult

Bases: pybind11_object

Stores the result of a compression (merge or truncate) operation.

nb_terms_after(self: pyrauli._core.CompressionResult) → int: Number of terms after compression.

property nb_terms_before: Number of terms before compression.

property nb_terms_merged: Number of terms removed/merged.

class pyrauli.KeepNTruncator

Bases: Truncator

A truncator that removes least significant Pauli Terms, when their numbers is above a threshold.

class pyrauli.LambdaPolicy

Bases: SchedulingPolicy

A policy that uses a Python function to determine when to apply optimizations.

class pyrauli.LambdaTruncator

Bases: Truncator

A truncator that uses a Python function as a predicate.

class pyrauli.MultiTruncator

Bases: Truncator

A truncator that combines multiple truncators at runtime.

class pyrauli.NeverPolicy

Bases: SchedulingPolicy

A policy that never applies an optimization.

class pyrauli.NeverTruncator

Bases: Truncator

A truncator that never removes any terms.

class pyrauli.Noise

Bases: pybind11_object

Defines the strengths of different noise channels.

property amplitude_damping_strength

property dephasing_strength

property depolarizing_strength

class pyrauli.NoiseModel

Bases: pybind11_object

A model for applying noise to quantum gates.

add_amplitude_damping_on_gate(self: pyrauli._core.NoiseModel, arg0: pyrauli._core.QGate, arg1: float) → None: Adds an amplitude damping channel to be applied after a specific gate type.

add_unital_noise_on_gate(self: pyrauli._core.NoiseModel, arg0: pyrauli._core.QGate, arg1: pyrauli._core.UnitalNoise, arg2: float) → None: Adds a unital noise channel to be applied after a specific gate type.

class pyrauli.Observable

Bases: pybind11_object

Represents a quantum observable as a linear combination of Pauli strings.

apply_amplitude_damping(self: pyrauli._core.Observable, qubit: int, noise_strength: float, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85616cba30>) → None: Applies an amplitude damping noise channel.

apply_clifford(self: pyrauli._core.Observable, clifford_gate: pyrauli._core.CliffordGate, qubit: int, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85616cac30>) → None: Applies a single-qubit Clifford gate to the observable.

apply_cx(self: pyrauli._core.Observable, qubit_control: int, qubit_target: int, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85616cb530>) → None: Applies a CNOT (CX) gate to the observable.

apply_pauli(self: pyrauli._core.Observable, pauli_gate: pyrauli._core.PauliGate, qubit: int, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f8561aaa4f0>) → None: Applies a single-qubit Pauli gate to the observable.

apply_rp(self: pyrauli._core.Observable, axis: pyrauli._core.PauliAxis, theta: float, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85616cbf70>) → None: Applies a global rotation around a Pauli axis.

apply_rz(self: pyrauli._core.Observable, qubit: int, theta: float, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85616cb1b0>) → None: Applies a single-qubit Rz rotation gate to the observable.

apply_u3(self: pyrauli._core.Observable, qubit: int, theta: float, phi: float, lambda: float, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f8561907370>) → None: Applies an U3 gate.

apply_unital_noise(self: pyrauli._core.Observable, unital_noise_type: pyrauli._core.UnitalNoise, qubit: int, noise_strength: float, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85616da8b0>) → None: Applies a single-qubit unital noise channel.

expectation_value(self: pyrauli._core.Observable, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f8561906df0>) → float: Calculates the expectation value of the observable.

merge(self: pyrauli._core.Observable, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85616a7030>) → int: Merges Pauli terms with identical Pauli strings.

size(self: pyrauli._core.Observable) → int: Gets the number of Pauli terms in the observable.

truncate(self: pyrauli._core.Observable, arg0: Truncator<float>) → int: Truncates the observable based on a given truncation strategy.

truncate_error(self: pyrauli._core.Observable) → float: Gets the accumulated truncation error.

class pyrauli.OperationType

Bases: pybind11_object

Type of operation in the simulation.

Members:

BasicGate

SplittingGate

Merge

Truncate

BasicGate = <OperationType.BasicGate: 0>

Merge = <OperationType.Merge: 2>

SplittingGate = <OperationType.SplittingGate: 1>

Truncate = <OperationType.Truncate: 3>

OperationType.name -> str

property value

class pyrauli.PBackend(num_qubits: int = 128, noise_model: NoiseModel = None, truncator: Truncator = <pyrauli._core.NeverTruncator object>, merge_policy: SchedulingPolicy = <pyrauli._core.AlwaysAfterSplittingPolicy object>, truncate_policy: SchedulingPolicy = <pyrauli._core.AlwaysAfterSplittingPolicy object>, runtime: RuntimePolicy = <pyrauli._core.ParallelPolicy object>, **kwargs)

Bases: BackendV2

A Qiskit BackendV2 that uses the pyrauli simulator.

This backend integrates pyrauli’s Pauli back-propagation engine into the Qiskit ecosystem, allowing it to be used as a target for Qiskit’s transpiler and as a simulator for running quantum circuits.

from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from pyrauli import PBackend

# Create a Qiskit circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

# Define an observable and instantiate the backend
obs = SparsePauliOp("ZI")
backend = PBackend()

# Run using the PUB (Primitive Unified Bloc) format
job = backend.run([(qc, obs)])
result = job.result()
ev = result.results[0].data.evs[0]

print(f"Expectation value from Qiskit backend: {ev}")

property max_circuits: int: The maximum number of circuits that can be run in a single job.

run(run_input: List[Tuple] | Tuple, **options) → JobV1

Run a circuit or a list of circuits on the backend.

This backend uses a PyrauliEstimator to execute the circuits.

Parameters:

run_input – A list of pubs, where each pub is a tuple of (circuit, observables, parameter_values) or any other PUBs structure.
**options – Runtime options for the execution. may include: “noise_model”, “truncator”, “merge_policy”, “truncate_policy”

Returns:

A JobV1 object that represents the execution.

property target: Target: The Qiskit Target object for this backend, detailing supported gates and connectivity.

class pyrauli.Pauli

Bases: pybind11_object

Represents a single Pauli operator (I, X, Y, or Z).

apply_clifford(self: pyrauli._core.Pauli, arg0: pyrauli._core.CliffordGate) → float: Applies a single-qubit Clifford gate to this operator, modifying it in place.

apply_cx(self: pyrauli._core.Pauli, arg0: pyrauli._core.Pauli) → float: Applies the control part of a CNOT gate to this operator, modifying it and the target in place.

apply_pauli(self: pyrauli._core.Pauli, arg0: pyrauli._core.PauliGate) → float: Applies a Pauli gate to this operator (in the Heisenberg picture).

apply_unital_noise(*args, **kwargs)

Overloaded function.

apply_unital_noise(self: pyrauli._core.Pauli, arg0: pyrauli._core.UnitalNoise, arg1: float) -> float

Applies a unital noise channel to this operator.

apply_unital_noise(self: pyrauli._core.Pauli, arg0: pyrauli._core.UnitalNoise, arg1: SymbolicCoefficient<float>) -> SymbolicCoefficient<float>

Applies a unital noise channel to this operator.

commutes_with(self: pyrauli._core.Pauli, arg0: pyrauli._core.Pauli) → bool: Checks if this Pauli operator commutes with another.

multiply_right(self: pyrauli._core.Pauli, other: pyrauli._core.Pauli) → int: Computes the algebraic product with another Pauli (self = self * other) and returns the phase (0 for 1, 1 for i, -1 for -i).

weight(self: pyrauli._core.Pauli) → int: Calculates the Pauli weight (1 if not Identity, 0 otherwise).

class pyrauli.PauliAxis

Bases: pybind11_object

A memory-efficient representation of a Pauli string axis.

nb_qubits(self: pyrauli._core.PauliAxis) → int: Returns the number of qubits.

class pyrauli.PauliEnum

Bases: pybind11_object

Enumeration for single Pauli operators (I, X, Y, Z).

Members:

I

X

Y

Z

I = <PauliEnum.I: 0>

X = <PauliEnum.X: 1>

Y = <PauliEnum.Y: 2>

Z = <PauliEnum.Z: 3>

PauliEnum.name -> str

property value

class pyrauli.PauliGate

Bases: pybind11_object

Enumeration for single-qubit Pauli gates (I, X, Y, Z).

Members:

I

X

Y

Z

I = <PauliGate.I: 0>

X = <PauliGate.X: 1>

Y = <PauliGate.Y: 2>

Z = <PauliGate.Z: 3>

PauliGate.name -> str

property value

class pyrauli.PauliTerm

Bases: pybind11_object

Represents a single term in an observable, consisting of a Pauli string and a coefficient.

apply_amplitude_damping_xy(self: pyrauli._core.PauliTerm, arg0: int, arg1: float) → None: Applies the X/Y part of the amplitude damping channel.

apply_amplitude_damping_z(self: pyrauli._core.PauliTerm, arg0: int, arg1: float) → pyrauli._core.PauliTerm: Applies the Z part of the amplitude damping channel, splitting the term.

apply_clifford(self: pyrauli._core.PauliTerm, arg0: pyrauli._core.CliffordGate, arg1: int) → None: Applies a Clifford gate to a specific qubit of the term.

apply_cx(self: pyrauli._core.PauliTerm, arg0: int, arg1: int) → None: Applies a CNOT gate to the term.

apply_pauli(self: pyrauli._core.PauliTerm, arg0: pyrauli._core.PauliGate, arg1: int) → None: Applies a Pauli gate to a specific qubit of the term.

apply_rz(self: pyrauli._core.PauliTerm, arg0: int, arg1: float) → pyrauli._core.PauliTerm: Applies an Rz gate, potentially splitting the term.

apply_unital_noise(self: pyrauli._core.PauliTerm, arg0: pyrauli._core.UnitalNoise, arg1: int, arg2: float) → None: Applies a unital noise channel to a specific qubit of the term.

property coefficient: The coefficient of the term.

expectation_value(self: pyrauli._core.PauliTerm) → float: Calculates the expectation value of this single term.

pauli_weight(self: pyrauli._core.PauliTerm) → int: Calculates the Pauli weight (number of non-identity operators).

class pyrauli.PyrauliEstimator(noise_model: NoiseModel | None = None, truncator: Truncator = <pyrauli._core.NeverTruncator object>, merge_policy: SchedulingPolicy = <pyrauli._core.AlwaysAfterSplittingPolicy object>, truncate_policy: SchedulingPolicy = <pyrauli._core.AlwaysAfterSplittingPolicy object>, runtime: RuntimePolicy = <pyrauli._core.ParallelPolicy object>)

Bases: BaseEstimatorV2

A Qiskit Estimator primitive that uses the pyrauli C++ simulator.

This estimator calculates the expectation values of observables for given quantum circuits, leveraging the high-performance Pauli back-propagation engine of pyrauli.

from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from pyrauli import PyrauliEstimator

estimator = PyrauliEstimator()
qc = QuantumCircuit(1)
qc.h(0)
obs = SparsePauliOp("Z") # EV of Z on |+> state is 0

job = estimator.run([(qc, obs)])
result = job.result()
print(result[0].data.evs[0])

run(run_input: List[Tuple] | Tuple, **options: Any) → PJob

Run a list of pubs (Primitive Unified Blocs) on the estimator.

Parameters:

run_input – A list of pubs, where each pub is a tuple of (circuit, observables, parameter_values). See qiskit documentation on PUBs
**options – Additional circuit options: “noise_model”, “truncator”, “truncate_policy”, “merge_policy”.

Returns:

A PJob object that represents the asynchronous execution.

class pyrauli.QGate

Bases: pybind11_object

Enumeration for all supported quantum gates and noise channels.

Members:

I

X

Y

Z

H

Rz

Rp

U3

Cx

AmplitudeDamping

Depolarizing

Dephasing

AmplitudeDamping = <QGate.AmplitudeDamping: 9>

Cx = <QGate.Cx: 8>

Dephasing = <QGate.Dephasing: 11>

Depolarizing = <QGate.Depolarizing: 10>

H = <QGate.H: 4>

I = <QGate.I: 0>

Rp = <QGate.Rp: 6>

Rz = <QGate.Rz: 5>

U3 = <QGate.U3: 7>

X = <QGate.X: 1>

Y = <QGate.Y: 2>

Z = <QGate.Z: 3>

QGate.name -> str

property value

class pyrauli.RuntimePolicy

Bases: pybind11_object

Runtime execution policy.

class pyrauli.SchedulingPolicy

Bases: pybind11_object

Abstract base class for defining scheduling policies.

class pyrauli.SimulationState

Bases: pybind11_object

Holds the state of the simulation at a given point in time.

property merge_history: History of merge operations.

property nb_gates_applied: Total number of gates applied so far.

property nb_splitting_gates_applied: Number of splitting gates applied so far.

property nb_splitting_gates_left: Number of splitting gates remaining in the circuit.

property terms_history: History of observable sizes after each operation.

property truncate_history: History of truncate operations.

class pyrauli.SymbolicCircuit

Bases: pybind11_object

Represents a quantum circuit and provides a high-level simulation interface.

add_operation(*args, **kwargs)

Overloaded function.

add_operation(self: pyrauli._core.SymbolicCircuit, op: str, qubit: int) -> None

Adds a single-qubit gate.

add_operation(self: pyrauli._core.SymbolicCircuit, op: str, qubit: int, param: pyrauli._core.SymbolicCoefficient) -> None

Adds a single-qubit gate with a parameter.

add_operation(self: pyrauli._core.SymbolicCircuit, op: str, qubit: int, theta: pyrauli._core.SymbolicCoefficient, phi: pyrauli._core.SymbolicCoefficient, lambda: pyrauli._core.SymbolicCoefficient) -> None

Adds a single-qubit gate with a parameter.

add_operation(self: pyrauli._core.SymbolicCircuit, op: str, qubit: int, param: str) -> None

Adds a single-qubit gate with a parameter.

add_operation(self: pyrauli._core.SymbolicCircuit, op: str, control: int, target: int) -> None

Adds a two-qubit gate.

cx(self: pyrauli._core.SymbolicCircuit, control: int, target: int) → None: Adds a CNOT (CX) gate.

eiht(*args, **kwargs)

Overloaded function.

eiht(self: pyrauli._core.SymbolicCircuit, pauli_axis: list[pyrauli._core.Pauli], t: pyrauli._core.SymbolicCoefficient) -> None

Adds a global evolution gate for a Hamiltonian term e^(-iHt) where H is the Pauli axis.

eiht(self: pyrauli._core.SymbolicCircuit, pauli_axis: list[str], t: pyrauli._core.SymbolicCoefficient) -> None

Adds a global evolution gate from a list of Pauli strings.

expectation_value(*args, **kwargs)

Overloaded function.

expectation_value(self: pyrauli._core.SymbolicCircuit, target_observable: pyrauli._core.SymbolicObservable, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy] = <pyrauli._core.SequentialPolicy object at 0x7f85616a59b0>) -> tuple[pyrauli._core.SymbolicCoefficient, pyrauli._core.SymbolicCoefficient]

Simulate one observable on the circuit and return only its expectation value.

expectation_value(self: pyrauli._core.SymbolicCircuit, target_observables: list[pyrauli._core.SymbolicObservable], runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy] = <pyrauli._core.SequentialPolicy object at 0x7f8561690a30>) -> list[tuple[pyrauli._core.SymbolicCoefficient, pyrauli._core.SymbolicCoefficient]]

Simulate a batch of observable and returns each of their expectation values.

h(self: pyrauli._core.SymbolicCircuit, qubit: int) → None: Adds a Hadamard gate.

i(self: pyrauli._core.SymbolicCircuit, qubit: int) → None: Adds an Identity gate.

nb_qubits(self: pyrauli._core.SymbolicCircuit) → int: Gets the number of qubits in the circuit.

reset(self: pyrauli._core.SymbolicCircuit) → None: Clears all operations from the circuit.

rp(*args, **kwargs)

Overloaded function.

rp(self: pyrauli._core.SymbolicCircuit, pauli_axis: list[pyrauli._core.Pauli], theta: pyrauli._core.SymbolicCoefficient) -> None

Adds a global rotation gate around a specified Pauli axis.

rp(self: pyrauli._core.SymbolicCircuit, pauli_axis: list[str], theta: pyrauli._core.SymbolicCoefficient) -> None

Adds a global rotation gate from a list of Pauli strings.

run(*args, **kwargs)

Overloaded function.

run(self: pyrauli._core.SymbolicCircuit, target_observable: pyrauli._core.SymbolicObservable, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy] = <pyrauli._core.SequentialPolicy object at 0x7f856169d0f0>) -> pyrauli._core.SymbolicObservable

Simulate one observable on the circuit and return its evolved self.

run(self: pyrauli._core.SymbolicCircuit, target_observables: list[pyrauli._core.SymbolicObservable], runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy] = <pyrauli._core.SequentialPolicy object at 0x7f8561854670>) -> list[pyrauli._core.SymbolicObservable]

Simulate a batch of observable and returns each of them.

rz(self: pyrauli._core.SymbolicCircuit, qubit: int, theta: pyrauli._core.SymbolicCoefficient) → None: Adds an Rz rotation gate.

set_merge_policy(self: pyrauli._core.SymbolicCircuit, arg0: pyrauli._core.SchedulingPolicy) → None: Sets a new policy for when to merge Pauli terms.

set_truncate_policy(self: pyrauli._core.SymbolicCircuit, arg0: pyrauli._core.SchedulingPolicy) → None: Sets a new policy for when to truncate the observable.

set_truncator(self: pyrauli._core.SymbolicCircuit, arg0: pyrauli._core.SymbolicTruncator) → None: Sets a new truncator for the circuit.

u3(self: pyrauli._core.SymbolicCircuit, qubit: int, theta: pyrauli._core.SymbolicCoefficient, phi: pyrauli._core.SymbolicCoefficient, lambda: pyrauli._core.SymbolicCoefficient) → None: Adds an U3 gate.

x(self: pyrauli._core.SymbolicCircuit, qubit: int) → None: Adds a Pauli-X gate.

y(self: pyrauli._core.SymbolicCircuit, qubit: int) → None: Adds a Pauli-Y gate.

z(self: pyrauli._core.SymbolicCircuit, qubit: int) → None: Adds a Pauli-Z gate.

class pyrauli.SymbolicCoefficient

Bases: pybind11_object

An easy to use symbolic coefficient.

compile(self: pyrauli._core.SymbolicCoefficient) → CompiledExpression<float>: Returns a fast compiled symbolic coefficient for faster evaluation.

cos(self: pyrauli._core.SymbolicCoefficient) → pyrauli._core.SymbolicCoefficient: Apply cosinus

evaluate(self: pyrauli._core.SymbolicCoefficient, variables: dict[str, float] = {}) → float: Evaluate into a real by replacing variables.

optimize(self: pyrauli._core.SymbolicCoefficient) → CompiledExpression<float>: Returns a simplified and compiled symbolic coefficient.

simplified(self: pyrauli._core.SymbolicCoefficient) → pyrauli._core.SymbolicCoefficient: Returns simplified symbolic coefficient using arithmetic rules.

sin(self: pyrauli._core.SymbolicCoefficient) → pyrauli._core.SymbolicCoefficient: Apply sinus

sqrt(self: pyrauli._core.SymbolicCoefficient) → pyrauli._core.SymbolicCoefficient: Apply sqrt

symbolic_evaluate(self: pyrauli._core.SymbolicCoefficient, variables: dict[str, float] = {}) → pyrauli._core.SymbolicCoefficient: Evaluate into another symbolic coefficient by replacing some variables.

to_string(self: pyrauli._core.SymbolicCoefficient, format: str = '{:.3f}') → str: Convert to string using a formatting for real.

class pyrauli.SymbolicMultiTruncator

Bases: SymbolicTruncator

A truncator that combines multiple truncators at runtime.

class pyrauli.SymbolicNeverTruncator

Bases: SymbolicTruncator

A truncator that never removes any terms.

class pyrauli.SymbolicNoise

Bases: pybind11_object

Defines the strengths of different noise channels.

property amplitude_damping_strength

property dephasing_strength

property depolarizing_strength

class pyrauli.SymbolicNoiseModel

Bases: pybind11_object

A model for applying noise to quantum gates.

add_amplitude_damping_on_gate(*args, **kwargs)

Overloaded function.

add_amplitude_damping_on_gate(self: pyrauli._core.SymbolicNoiseModel, arg0: pyrauli._core.QGate, arg1: pyrauli._core.SymbolicCoefficient) -> None

Adds an amplitude damping channel to be applied after a specific gate type.

add_amplitude_damping_on_gate(self: pyrauli._core.SymbolicNoiseModel, arg0: pyrauli._core.QGate, arg1: str) -> None

Adds an amplitude damping channel to be applied after a specific gate type, using a variable name for strength.

add_unital_noise_on_gate(*args, **kwargs)

Overloaded function.

add_unital_noise_on_gate(self: pyrauli._core.SymbolicNoiseModel, arg0: pyrauli._core.QGate, arg1: pyrauli._core.UnitalNoise, arg2: pyrauli._core.SymbolicCoefficient) -> None

Adds a unital noise channel to be applied after a specific gate type.

add_unital_noise_on_gate(self: pyrauli._core.SymbolicNoiseModel, arg0: pyrauli._core.QGate, arg1: pyrauli._core.UnitalNoise, arg2: str) -> None

Adds a unital noise channel to be applied after a specific gate type, using a variable name for strength.

class pyrauli.SymbolicObservable

Bases: pybind11_object

Represents a quantum observable symbolically, as a linear combination of Pauli strings.

apply_amplitude_damping(self: pyrauli._core.SymbolicObservable, qubit: int, noise_strength: pyrauli._core.SymbolicCoefficient, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f856169e3f0>) → None: Applies an amplitude damping noise channel.

apply_clifford(self: pyrauli._core.SymbolicObservable, clifford_gate: pyrauli._core.CliffordGate, qubit: int, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f856169f1b0>) → None: Applies a single-qubit Clifford gate to the observable.

apply_cx(self: pyrauli._core.SymbolicObservable, qubit_control: int, qubit_target: int, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f856194d7f0>) → None: Applies a CNOT (CX) gate to the observable.

apply_pauli(self: pyrauli._core.SymbolicObservable, pauli_gate: pyrauli._core.PauliGate, qubit: int, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f856169ed70>) → None: Applies a single-qubit Pauli gate to the observable.

apply_rp(self: pyrauli._core.SymbolicObservable, axis: pyrauli._core.PauliAxis, theta: pyrauli._core.SymbolicCoefficient, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f8561afe270>) → None: Applies a global rotation around a Pauli axis (e^i*theta*P).

apply_rz(self: pyrauli._core.SymbolicObservable, qubit: int, noise_strength: pyrauli._core.SymbolicCoefficient, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85619c1070>) → None: Applies a single-qubit Rz rotation gate to the observable.

apply_u3(self: pyrauli._core.SymbolicObservable, qubit: int, theta: pyrauli._core.SymbolicCoefficient, phi: pyrauli._core.SymbolicCoefficient, lambda: pyrauli._core.SymbolicCoefficient, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85616cdcb0>) → None: Applies an U3 gate.

apply_unital_noise(self: pyrauli._core.SymbolicObservable, unital_noise_type: pyrauli._core.UnitalNoise, qubit: int, noise_strength: pyrauli._core.SymbolicCoefficient, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85619befb0>) → None: Applies a single-qubit unital noise channel.

expectation_value(self: pyrauli._core.SymbolicObservable, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85616d99f0>) → pyrauli._core.SymbolicCoefficient: Calculates the expectation value of the observable.

merge(self: pyrauli._core.SymbolicObservable, runtime: Union[pyrauli._core.SequentialPolicy, pyrauli._core.ParallelPolicy]=<pyrauli._core.SequentialPolicy object at 0x7f85616a6930>) → int: Merges Pauli terms with identical Pauli strings.

simplify(self: pyrauli._core.SymbolicObservable, variable_map: dict[str, float] = {}) → None: Simplify the observable coefficient and replace variables.

size(self: pyrauli._core.SymbolicObservable) → int: Gets the number of Pauli terms in the observable.

truncate(self: pyrauli._core.SymbolicObservable, arg0: Truncator<SymbolicCoefficient<float> >) → int: Truncates the observable based on a given truncation strategy.

truncate_error(self: pyrauli._core.SymbolicObservable) → pyrauli._core.SymbolicCoefficient: Gets the accumulated truncation error.

class pyrauli.SymbolicPauliTerm

Bases: pybind11_object

Represents a single term in an observable, consisting of a Pauli string and a coefficient.

apply_amplitude_damping_xy(self: pyrauli._core.SymbolicPauliTerm, arg0: int, arg1: pyrauli._core.SymbolicCoefficient) → None: Applies the X/Y part of the amplitude damping channel.

apply_amplitude_damping_z(self: pyrauli._core.SymbolicPauliTerm, arg0: int, arg1: pyrauli._core.SymbolicCoefficient) → pyrauli._core.SymbolicPauliTerm: Applies the Z part of the amplitude damping channel, splitting the term.

apply_clifford(self: pyrauli._core.SymbolicPauliTerm, arg0: pyrauli._core.CliffordGate, arg1: int) → None: Applies a Clifford gate to a specific qubit of the term.

apply_cx(self: pyrauli._core.SymbolicPauliTerm, arg0: int, arg1: int) → None: Applies a CNOT gate to the term.

apply_pauli(self: pyrauli._core.SymbolicPauliTerm, arg0: pyrauli._core.PauliGate, arg1: int) → None: Applies a Pauli gate to a specific qubit of the term.

apply_rz(self: pyrauli._core.SymbolicPauliTerm, arg0: int, arg1: pyrauli._core.SymbolicCoefficient) → pyrauli._core.SymbolicPauliTerm: Applies an Rz gate, potentially splitting the term.

apply_unital_noise(self: pyrauli._core.SymbolicPauliTerm, arg0: pyrauli._core.UnitalNoise, arg1: int, arg2: pyrauli._core.SymbolicCoefficient) → None: Applies a unital noise channel to a specific qubit of the term.

property coefficient: The coefficient of the term.

expectation_value(self: pyrauli._core.SymbolicPauliTerm) → pyrauli._core.SymbolicCoefficient: Calculates the expectation value of this single term.

pauli_weight(self: pyrauli._core.SymbolicPauliTerm) → int: Calculates the Pauli weight (number of non-identity operators).

class pyrauli.SymbolicTruncator

Bases: pybind11_object

Abstract base class for defining truncation strategies.

class pyrauli.SymbolicWeightTruncator

Bases: SymbolicTruncator

Truncator that removes Pauli terms with high Pauli weight.

class pyrauli.Timing

Bases: pybind11_object

Timing of a policy application relative to an operation.

Members:

Before

After

After = <Timing.After: 1>

Before = <Timing.Before: 0>

Timing.name -> str

property value

class pyrauli.Truncator

Bases: pybind11_object

Abstract base class for defining truncation strategies.

class pyrauli.UnitalNoise

Bases: pybind11_object

Enumeration for unital noise channels.

Members:

Depolarizing : Depolarizing noise channel.

Dephasing : Dephasing noise channel.

Dephasing = <UnitalNoise.Dephasing: 1>

Depolarizing = <UnitalNoise.Depolarizing: 0>

UnitalNoise.name -> str

property value

class pyrauli.WeightTruncator

Bases: Truncator

Truncator that removes Pauli terms with high Pauli weight.

pyrauli.from_qiskit(qiskit_obj, noise_model: NoiseModel = None, reverse=False)

Converts a Qiskit object to its pyrauli equivalent.

Parameters:

qiskit_obj – The Qiskit object to convert (QuantumCircuit or SparsePauliOp).
noise_model – A pyrauli NoiseModel to apply to the circuit.

Returns:

The equivalent pyrauli object.