pyrauli 0.2.1__tar.gz → 0.3.1__tar.gz

{pyrauli-0.2.1 → pyrauli-0.3.1}/CMakeLists.txt

@@ -15,7 +15,7 @@ FetchContent_Declare(
 FetchContent_Declare(
 		propauli
 		GIT_REPOSITORY https://github.com/zefresk/propauli.git
-		GIT_TAG v2.0.2
+		GIT_TAG v2.1.0
 )
 
 FetchContent_MakeAvailable(pybind11 propauli)

{pyrauli-0.2.1 → pyrauli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyrauli
-Version: 0.2.1
+Version: 0.3.1
 Summary: A very fast and easy to use Quantum circuit simulator relying on Pauli propagation. Compatible with qiskit.
 License:                     GNU GENERAL PUBLIC LICENSE
                                 Version 3, 29 June 2007

{pyrauli-0.2.1 → pyrauli-0.3.1}/docs/guides/how_to_circuit.rst

@@ -19,3 +19,9 @@ number of qubits and then add gates sequentially. Finally, you run the circuit o
    :dedent: 4
 
 
+.. NOTE::
+        :py:class:`~pyrauli.Circuit` supports all Pauli gates (I, X, Y, Z), the Hadamard gate (H), the CNOT gate (CX) and the RZ(:math:`\theta`) gate. 
+
+
+.. TIP::
+        For more complex gates, you may use the Qiskit transpiler on :py:class:`~Pbackend`. See :doc:`../guides/how_to_qiskit`.

{pyrauli-0.2.1 → pyrauli-0.3.1}/docs/guides/how_to_complexity.rst

@@ -12,7 +12,7 @@ manage this complexity automatically during a :py:class:`~pyrauli.Circuit.run()`
 Remove small coefficients
 -------------------------
 
-**Solution:** Use a :py:class:`~pyrauli.CoefficientTruncator`.
+Use a :py:class:`~pyrauli.CoefficientTruncator`.
 
 This truncator removes any Pauli terms whose coefficient magnitude is below a
 given threshold.
@@ -23,10 +23,21 @@ given threshold.
    :end-before: # [truncator_coeff]
    :dedent: 4
 
+Available truncators
+--------------------
+
+* :py:class:`~pyrauli.NeverTruncator`: never truncate observable.
+* :py:class:`~pyrauli.CoefficientTruncator`: truncate terms with absolute coefficient value below set threshold.
+* :py:class:`~pyrauli.WeightTruncator`: truncate terms with Pauli weight above set threshold.
+* :py:class:`~pyrauli.LambdaTruncator`: truncate terms if they match a predicate (Python function or lambda).
+* :py:class:`~pyrauli.KeepNTruncator`: truncate least significant terms if their number exceed a threshold. (Keep at most N different terms)
+* :py:class:`~pyrauli.MultiTruncator`: Combine a list of truncators into one.
+
+
 Using a custom Truncator with your own logic
 --------------------------------------------
 
-**Solution:** Use a :py:class:`~pyrauli.LambdaTruncator`.
+Use a :py:class:`~pyrauli.LambdaTruncator`.
 
 This allows you to provide a custom Python function that filters the terms.
 
@@ -37,12 +48,12 @@ This allows you to provide a custom Python function that filters the terms.
    :dedent: 4
 
 .. NOTE::
-   This truncator removes :py:class:`~pyrauli.PauliTerm` containing :math:`Y`. However, this is not an efficient.
+   This truncator removes :py:class:`~pyrauli.PauliTerm` containing :math:`Y`. However, this is not very efficient.
 
 Controlling when truncation is applied
 --------------------------------------
 
-**Solution:** Use a :py:class:`~pyrauli.SchedulingPolicy`.
+Use a :py:class:`~pyrauli.SchedulingPolicy`.
 
 Scheduling Policies give you fine-grained control over when a :py:class:`~pyrauli.Truncator` is
 applied during the simulation. It can query a :py:class:`~pyrauli.SimulationState` object and other information to make a decision.

{pyrauli-0.2.1 → pyrauli-0.3.1}/docs/guides/how_to_qiskit.rst

@@ -27,6 +27,9 @@ The :py:class:`~pyrauli.PBackend` class allows you to use ``pyrauli`` as a backe
 Qiskit ecosystem, enabling you to **transpile** and run circuits defined in Qiskit on the
 ``pyrauli`` simulator.
 
+.. IMPORTANT::
+   If your Qiskit circuit uses unsupported gates, you need to transpile it, as you would for any other backend.
+
 Here is an example of transpilation to :py:class:`~pyrauli.PBackend`, relying on Qiskit ``PassManager``:
 
 .. literalinclude:: /../tests/test_backend.py
@@ -56,3 +59,13 @@ the hood.
    :start-after: # [estimator_complex]
    :end-before: # [estimator_complex]
    :dedent: 4
+
+Qiskit and reverse qubit ordering
+---------------------------------
+
+Qiskit uses reverse qubit ordering, while ``pyrauli`` use normal ordering. :py:class:`~pyrauli.from_qiskit` will not reverse the order of the qubit or Observable unless the `reverse=True` parameter is used.
+
+However, when a qiskit observable is passed to the `.run` method, it will be reversed so that the output result match the output you would get on any other qiskit backend.
+
+.. IMPORTANT::
+   You don't need to do anything different if using the qiskit compatible backend and qiskit observable. However, you may need to reverse the observable ordering when using :py:class:`~pyrauli.Circuit` and :py:class:`~pyrauli.from_qiskit` directly.

{pyrauli-0.2.1 → pyrauli-0.3.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "pyrauli"
-version = "0.2.1"
+version = "0.3.1"
 description = "A very fast and easy to use Quantum circuit simulator relying on Pauli propagation. Compatible with qiskit."
 readme = "README.md"
 requires-python = ">=3.9"

{pyrauli-0.2.1 → pyrauli-0.3.1}/src/pyrauli/__init__.py

@@ -8,7 +8,7 @@ simulation, powered by the C++ `propauli` library.
 from ._core import (
     PauliEnum, PauliGate, CliffordGate, UnitalNoise, QGate, Pauli, PauliTerm,
     Observable, Noise, NoiseModel, Truncator, CoefficientTruncator,
-    WeightTruncator, NeverTruncator, LambdaTruncator, MultiTruncator,
+    WeightTruncator, KeepNTruncator, NeverTruncator, LambdaTruncator, MultiTruncator,
     SchedulingPolicy, NeverPolicy, AlwaysBeforeSplittingPolicy,
     AlwaysAfterSplittingPolicy, Circuit, OperationType, Timing,
     SimulationState, CompressionResult, LambdaPolicy,
@@ -17,7 +17,7 @@ from ._core import (
 __all__ = [
     "PauliEnum", "PauliGate", "CliffordGate", "UnitalNoise", "QGate", "Pauli",
     "PauliTerm", "Observable", "Noise", "NoiseModel", "Truncator",
-    "CoefficientTruncator", "WeightTruncator", "NeverTruncator",
+    "CoefficientTruncator", "WeightTruncator", "KeepNTruncator", "NeverTruncator",
     "LambdaTruncator", "MultiTruncator", "SchedulingPolicy", "NeverPolicy",
     "AlwaysBeforeSplittingPolicy", "AlwaysAfterSplittingPolicy", "Circuit",
     "OperationType", "Timing", "SimulationState", "CompressionResult",

{pyrauli-0.2.1 → pyrauli-0.3.1}/src/pyrauli/_core/bindings.cpp

@@ -29,6 +29,7 @@ using SchedulingPolicyPtr = std::shared_ptr<SchedulingPolicy>;
 using CoeffTruncatorPtr = std::shared_ptr<CoefficientTruncator<coeff_t>>;
 using WeightTruncatorPtr = std::shared_ptr<WeightTruncator>;
 using NeverTruncatorPtr = std::shared_ptr<NeverTruncator>;
+using KeepNTruncatorPtr = std::shared_ptr<KeepNTruncator<coeff_t>>;
 using NeverPolicyPtr = std::shared_ptr<NeverPolicy>;
 using AlwaysBeforePolicyPtr = std::shared_ptr<AlwaysBeforeSplittingPolicy>;
 using AlwaysAfterPolicyPtr = std::shared_ptr<AlwaysAfterSplittingPolicy>;
@@ -211,6 +212,10 @@ PYBIND11_MODULE(_core, m) {
 	py::class_<NeverTruncator, Truncator<coeff_t>, NeverTruncatorPtr>(m, "NeverTruncator",
 									  "A truncator that never removes any terms.")
 		.def(py::init<>());
+	py::class_<KeepNTruncator<coeff_t>, Truncator<coeff_t>, KeepNTruncatorPtr>(
+		m, "KeepNTruncator",
+		"A truncator that removes least significant Pauli Terms, when their numbers is above a threshold.")
+		.def(py::init<std::size_t>());
 	py::class_<LambdaTruncator, Truncator<coeff_t>, LambdaTruncatorPtr>(
 		m, "LambdaTruncator", "A truncator that uses a Python function as a predicate.")
 		.def(py::init<LambdaPredicate_t>());

{pyrauli-0.2.1 → pyrauli-0.3.1}/src/pyrauli/converters.py

@@ -7,7 +7,7 @@ from qiskit.circuit import QuantumCircuit
 from qiskit.quantum_info import SparsePauliOp
 import pyrauli
 
-def from_qiskit(qiskit_obj, noise_model: pyrauli.NoiseModel = None):
+def from_qiskit(qiskit_obj, noise_model: pyrauli.NoiseModel = None, reverse=False):
     """
     Converts a Qiskit object to its pyrauli equivalent.
 
@@ -21,7 +21,7 @@ def from_qiskit(qiskit_obj, noise_model: pyrauli.NoiseModel = None):
     if isinstance(qiskit_obj, QuantumCircuit):
         return from_qiskit_qc(qiskit_obj, noise_model=noise_model)
     elif isinstance(qiskit_obj, SparsePauliOp):
-        return from_qiskit_obs(qiskit_obj)
+        return from_qiskit_obs(qiskit_obj, reverse=reverse)
     else:
         raise ValueError(f"Can't convert object of type {type(qiskit_obj)} to pyrauli object.")
 
@@ -51,7 +51,7 @@ def from_qiskit_qc(qiskit_circuit: QuantumCircuit, noise_model: pyrauli.NoiseMod
 
     return pyrauli_circuit
 
-def from_qiskit_obs(qiskit_obs: SparsePauliOp) -> pyrauli.Observable:
+def from_qiskit_obs(qiskit_obs: SparsePauliOp, reverse=False) -> pyrauli.Observable:
     """
     Translates a Qiskit SparsePauliOp to a pyrauli.Observable.
     """
@@ -59,6 +59,11 @@ def from_qiskit_obs(qiskit_obs: SparsePauliOp) -> pyrauli.Observable:
     for pauli_string, coeff in zip(qiskit_obs.paulis, qiskit_obs.coeffs):
         if coeff.imag != 0.:
             logging.warning("pyrauli observables don't support complex coefficients.")
-        pt = pyrauli.PauliTerm(pauli_string.to_label(), float(coeff.real))
+
+        ps = pauli_string.to_label()
+        if reverse:
+            ps = ps[::-1]
+
+        pt = pyrauli.PauliTerm(ps, float(coeff.real))
         pts.append(pt)
     return pyrauli.Observable(pts)

{pyrauli-0.2.1 → pyrauli-0.3.1}/src/pyrauli/estimator.py

@@ -122,7 +122,7 @@ class PyrauliEstimator(BaseEstimatorV2):
         """
         exp_values = []
         for obs in observables:
-                pyrauli_obs = from_qiskit(obs)
+                pyrauli_obs = from_qiskit(obs, reverse=True)
                 final_observable = pyrauli_circuit.run(pyrauli_obs)
                 exp_values.append(final_observable.expectation_value())
         return exp_values

{pyrauli-0.2.1 → pyrauli-0.3.1}/tests/test_backend.py

@@ -1,3 +1,4 @@
+from dataclasses import replace
 import pytest
 import numpy as np
 
@@ -63,7 +64,7 @@ def test_estimator_multiple_observables_per_pub():
     qc.rz(np.pi/2, 0)
     qc.rz(np.pi/3, 1)
     qc.h([0, 1])
-    observables = [SparsePauliOp("ZI"), SparsePauliOp("IZ")]
+    observables = [SparsePauliOp("IZ"), SparsePauliOp("ZI")]
     
     job = estimator.run([(qc, observables)])
     result = job.result()
@@ -82,7 +83,7 @@ def test_estimator_multiobs_multiparams():
     qc.rz(thetas[0], 0)
     qc.rz(thetas[1], 1)
     qc.h([0, 1])
-    observables = [SparsePauliOp("ZI"), SparsePauliOp("IZ")]
+    observables = [SparsePauliOp("IZ"), SparsePauliOp("ZI")]
     
     job = estimator.run([(qc, observables, (np.pi/2, np.pi/3)), (qc, observables, (np.pi/3, np.pi/2))])
     result = job.result()
@@ -158,6 +159,31 @@ def test_random_circuits_match_aer_simulator():
         
         assert pyrauli_result == pytest.approx(qiskit_ev, abs=1e-6)
 
+def test_random_circuits_random_obs_match_aer_simulator():
+    """Compares PyrauliEstimator against qiskit for many random circuits."""
+    pyrauli_estimator = PyrauliEstimator()
+    qiskit_estimator = StatevectorEstimator()
+    
+    transpilation_backend = PBackend(num_qubits=4)
+    pm = generate_preset_pass_manager(backend=transpilation_backend, optimization_level=0)
+
+    np.random.seed(42) # for reproducibility
+    for i in range(8):
+        qc = random_circuit(num_qubits=4, depth=8, seed=i, max_operands=2)
+        obs = SparsePauliOp("".join(np.random.choice(["I", "X", "Y", "Z"], replace=True, size=4)))
+        transpiled_qc = pm.run(qc)
+        
+        # Run on pyrauli
+        pyrauli_job = pyrauli_estimator.run([(transpiled_qc, obs)])
+        pyrauli_result = pyrauli_job.result()[0].data.evs[0]
+        
+        # Run on Aer
+        qiskit_job = qiskit_estimator.run([(transpiled_qc, obs)])
+        qiskit_result = qiskit_job.result()
+        qiskit_ev = qiskit_result[0].data.evs #.... 
+        
+        assert pyrauli_result == pytest.approx(qiskit_ev, abs=1e-6)
+
 @pytest.fixture
 def simple_pub():
     """Returns a simple PUB for running on the backend/estimator."""

{pyrauli-0.2.1 → pyrauli-0.3.1}/tests/test_truncator.py

@@ -6,6 +6,7 @@ from pyrauli import (
     Circuit,
     CoefficientTruncator,
     WeightTruncator,
+    KeepNTruncator,
     LambdaTruncator,
     MultiTruncator,
     AlwaysAfterSplittingPolicy
@@ -37,6 +38,19 @@ def test_weight_truncator_on_observable():
     assert len(obs) == 1
     assert obs[0] == PauliTerm("IIII", 0.5)
 
+def test_keepn_truncator_on_observable():
+    """Tests that terms with high Pauli weight are removed."""
+    obs = Observable([PauliTerm("IIII", 0.5), PauliTerm("ZYXI", 0.11), PauliTerm("YYYY", -0.5), PauliTerm("IXYZ", 0.1)])
+
+    truncator = KeepNTruncator(2)
+    
+    removed_count = obs.truncate(truncator)
+    
+    assert removed_count == 2
+    assert len(obs) == 2
+    assert obs[0] == PauliTerm("IIII", 0.5)
+    assert obs[1] == PauliTerm("YYYY", -0.5)
+
 def test_lambda_truncator_on_observable_def():
     """Tests truncation based on a custom Python function."""
     # This predicate removes any term containing a 'Y'