pyrauli 0.3.1__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyrauli
-Version: 0.3.1
+Version: 0.3.2
 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
@@ -686,6 +686,7 @@ Project-URL: Homepage, https://github.com/zefresk/pyrauli
 Requires-Python: >=3.9
 Provides-Extra: qiskit
 Requires-Dist: qiskit>=2.0.0; extra == "qiskit"
+Requires-Dist: numpy; extra == "qiskit"
 Provides-Extra: test
 Requires-Dist: pytest>=8.0.0; extra == "test"
 Requires-Dist: pytest-cov>=5.0.0; extra == "test"
@@ -753,7 +754,7 @@ final_observable = circuit.run(observable)
 
 # 5. Retrieve the final expectation value
 # The expectation value is calculated with respect to the initial |00...0> state
-expectation_value = final_observable.get_expectation_value()
+expectation_value = final_observable.expectation_value()
 
 print(f"Final observable: {final_observable}")
 print(f"Expectation value: {expectation_value}")

{pyrauli-0.3.1 → pyrauli-0.3.2}/README.md

@@ -58,7 +58,7 @@ final_observable = circuit.run(observable)
 
 # 5. Retrieve the final expectation value
 # The expectation value is calculated with respect to the initial |00...0> state
-expectation_value = final_observable.get_expectation_value()
+expectation_value = final_observable.expectation_value()
 
 print(f"Final observable: {final_observable}")
 print(f"Expectation value: {expectation_value}")

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

@@ -60,6 +60,20 @@ the hood.
    :end-before: # [estimator_complex]
    :dedent: 4
 
+Full PUBs support
+-----------------
+
+``pyrauli`` intends to be fully compatible with Qiskit and the provided backends and estimators should be able to be swapped with any other qiskit backend. Therefore, :py:class:`~pyrauli.PyrauliEstimator` and :py:class:`~pyrauli.PBackend` `.run` methods allows for any PUB (see `Qiskit documentation on PUBs https://qiskit.qotlabs.org/docs/guides/primitive-input-output`).
+
+Below is an example of what is possible:
+
+.. literalinclude:: /../tests/test_backend.py
+   :language: python
+   :start-after: # [qiskit_multiparameters]
+   :end-before: # [qiskit_multiparameters]
+   :dedent: 4
+
+
 Qiskit and reverse qubit ordering
 ---------------------------------
 

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

@@ -5,7 +5,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "pyrauli"
-version = "0.3.1"
+version = "0.3.2"
 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"
@@ -25,7 +25,8 @@ Homepage = "https://github.com/zefresk/pyrauli"
 
 [project.optional-dependencies]
 qiskit = [
-    "qiskit>=2.0.0"
+    "qiskit>=2.0.0",
+    "numpy"
 ]
 test = [
     "pytest>=8.0.0",

{pyrauli-0.3.1 → pyrauli-0.3.2}/src/pyrauli/backend.py

@@ -93,14 +93,14 @@ class PBackend(BackendV2):
         """Default options for the backend."""
         return Options()
 
-    def run(self, run_input: Union[QuantumCircuit, List[QuantumCircuit]], **options) -> JobV1:
+    def run(self, run_input: Union[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.
 
         Args:
-            run_input: A QuantumCircuit or a list of them to run.
+            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:

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

@@ -7,15 +7,17 @@ managing simulation jobs.
 """
 import uuid
 import numpy as np
-from typing import List, Tuple, Union
+from typing import List, Tuple, Union, Optional, Any, Callable, Dict
 from concurrent.futures import ThreadPoolExecutor
 
+from qiskit import QuantumCircuit
 from qiskit.primitives import BaseEstimatorV2
 from qiskit.providers import BackendV2, JobV1, Options, JobStatus
 from qiskit.result import Result
 from qiskit.primitives.primitive_job import PrimitiveJob
 from qiskit.primitives.containers import PubResult, PrimitiveResult, DataBin
 from qiskit.quantum_info import SparsePauliOp
+from qiskit.circuit import ParameterVector
 
 from . import Circuit, Observable, NoiseModel, Truncator, NeverTruncator, SchedulingPolicy, AlwaysAfterSplittingPolicy
 from .converters import from_qiskit
@@ -43,7 +45,11 @@ class PyrauliEstimator(BaseEstimatorV2):
         result = job.result()
         print(result[0].data.evs[0])
     """
-    def __init__(self, noise_model: NoiseModel = None, truncator: Truncator = NeverTruncator(), merge_policy: SchedulingPolicy = AlwaysAfterSplittingPolicy(), truncate_policy: SchedulingPolicy = AlwaysAfterSplittingPolicy()):
+    def __init__(self, 
+                 noise_model: Optional[NoiseModel] = None, 
+                 truncator: Truncator = NeverTruncator(), 
+                 merge_policy: SchedulingPolicy = AlwaysAfterSplittingPolicy(), 
+                 truncate_policy: SchedulingPolicy = AlwaysAfterSplittingPolicy()) -> None:
         """
         Initializes the PyrauliEstimator.
 
@@ -59,18 +65,16 @@ class PyrauliEstimator(BaseEstimatorV2):
         self._truncator = truncator or NeverTruncator()
         self._merge_policy = merge_policy or AlwaysAfterSplittingPolicy()
         self._truncate_policy = truncate_policy or AlwaysAfterSplittingPolicy()
-
         self._executor = ThreadPoolExecutor(max_workers=1)
 
-
-    def run(self, run_input: List[Tuple], **options) -> 'PJob':
+    def run(self, run_input: Union[List[Tuple], Tuple], **options: Any) -> 'PJob':
         """
         Run a list of pubs (Primitive Unified Blocs) on the estimator.
 
         Args:
-            run_input: A list of pubs, where each pub is a tuple of
-                      (circuit, observables, parameter_values).
-            **options: Additional circuit options: "noise_model", "truncator", "truncate_policy", "merge_policy".
+            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.
@@ -80,13 +84,14 @@ class PyrauliEstimator(BaseEstimatorV2):
         job.submit()
         return job
 
-    def _run_job(self, job_id: str, pubs: List[Tuple], **options) -> Result:
+    def _run_job(self, job_id: str, pubs: List[Tuple], **options: Any) -> Result:
         """
         The core simulation logic that is executed by the PJob.
 
         Args:
             job_id: The ID for the job.
             pubs: The list of pubs to execute.
+            **options: Runtime options passed to the run method.
 
         Returns:
             A Qiskit Result object containing the simulation results.
@@ -95,45 +100,78 @@ class PyrauliEstimator(BaseEstimatorV2):
         trunc = self._truncator if "truncator" not in options else options.get("truncator")
         trunc_pol = self._truncate_policy if "truncate_policy" not in options else options.get("truncate_policy")
         merge_pol = self._merge_policy if "merge_policy" not in options else options.get("merge_policy")
-        print(nm, self._noise_model)
 
         results = []
         for pub in pubs:
             circuit, observables, parameter_values = self._unpack_pub(pub)
 
             # Bind parameters if they exist
-            bound_circuit = circuit.assign_parameters(parameter_values) if parameter_values is not None else circuit
+            bound_circuits = self._assign_parameters(circuit, parameter_values)
             
             # Convert to pyrauli objects and simulate
-            pyrauli_circuit = from_qiskit(bound_circuit, noise_model=nm)
-            pyrauli_circuit.set_truncator(trunc)
-            pyrauli_circuit.set_merge_policy(merge_pol)
-            pyrauli_circuit.set_truncate_policy(trunc_pol)
-            exp_values = self._simulate_observables(pyrauli_circuit, observables)
+            pyrauli_circuits = [from_qiskit(bqc, noise_model=nm) for bqc in bound_circuits]
+            for pyrauli_circuit in pyrauli_circuits:
+                pyrauli_circuit.set_truncator(trunc)
+                pyrauli_circuit.set_merge_policy(merge_pol)
+                pyrauli_circuit.set_truncate_policy(trunc_pol)
+
+            exp_values = self._simulate_observables(pyrauli_circuits, observables, trunc, merge_pol, trunc_pol) 
             
             # Format the result for this pub
-            results.append({"success": True, "data": {"evs": exp_values}, "metadata": {}, 'shots': 1})
+            results.append({"success": True, "data": {"evs": np.atleast_1d(np.squeeze(np.array(exp_values)))}, "metadata": {}, 'shots': 1})
             
         return Result.from_dict({"job_id": job_id, "results": results, "success": True, "backend_name": self.name})
 
-    def _simulate_observables(self, pyrauli_circuit: Circuit, observables: List[SparsePauliOp]) -> List[float]:
+    def _simulate_observables(self, 
+                              pyrauli_circuits: List[Circuit], 
+                              observables: List[SparsePauliOp], 
+                              trunc: Optional[Truncator] = None, 
+                              merge_pol: Optional[SchedulingPolicy] = None, 
+                              trunc_pol: Optional[SchedulingPolicy] = None) -> List[List[float]]:
         """
         Simulates a list of observables for a given pyrauli circuit.
         """
-        exp_values = []
-        for obs in observables:
+        ret = []
+        for olist in observables:
+            exp_values = []
+            for obs in olist:
                 pyrauli_obs = from_qiskit(obs, reverse=True)
-                final_observable = pyrauli_circuit.run(pyrauli_obs)
-                exp_values.append(final_observable.expectation_value())
-        return exp_values
+                for pqc in pyrauli_circuits: 
+                    final_observable = pqc.run(pyrauli_obs)
+                    exp_values.append(final_observable.expectation_value())
+            ret += [exp_values]
+        return ret
 
-    def _unpack_pub(self, pub: Tuple) -> Tuple:
+    def _unpack_pub(self, pub: Tuple) -> Tuple[QuantumCircuit, List[SparsePauliOp], Optional[Any]]:
         """
         Unpacks a pub into its components, ensuring observables are always a list.
         """
         circuit, observables, params = (pub[0], pub[1], pub[2] if len(pub) > 2 else None)
         return circuit, observables if isinstance(observables, list) else [observables], params
 
+    def _assign_parameters(self, circuit: QuantumCircuit, params: Optional[Any]) -> List[QuantumCircuit]:
+        """
+        Assigns parameter values to a circuit.
+
+        This method handles different shapes for the parameter values, including
+        no parameters, a single set of parameters, or multiple sets for
+        parameter sweeping.
+
+        Args:
+            circuit: The circuit with unbound parameters.
+            params: The parameter values to bind. Can be a 1D array for a single
+                binding or a 2D array for multiple bindings.
+
+        Returns:
+            A list of circuits with bound parameters.
+        """
+        if params is None:
+            return [circuit]
+        elif (hasattr(params, 'ndim') and params.ndim == 2) or ((isinstance(params, list) or hasattr(params, 'ndim')) and len(params) > 0 and isinstance(params[0], (list, tuple, dict, ParameterVector))):
+            return [circuit.assign_parameters(e) for e in params]
+        else:
+            return [circuit.assign_parameters(params)]
+
 class PJob(JobV1):
     """
     A JobV1-compliant class for handling jobs from PBackend and PyrauliEstimator.
@@ -141,7 +179,12 @@ class PJob(JobV1):
     This class wraps the execution of the simulation in a manner consistent
     with Qiskit's job management system.
     """
-    def __init__(self, backend, job_id, fn, pubs, **options):
+    def __init__(self, 
+                 backend: BackendV2, 
+                 job_id: str, 
+                 fn: Callable[..., Result], 
+                 pubs: List[Tuple], 
+                 **options: Any) -> None:
         """
         Initializes the PJob.
 
@@ -155,11 +198,11 @@ class PJob(JobV1):
         super().__init__(backend, job_id)
         self._fn = fn
         self._pubs = pubs
-        self._result = None
+        self._result: Optional[Result] = None
         self._status = JobStatus.INITIALIZING
         self._options = options
 
-    def submit(self):
+    def submit(self) -> None:
         """
         Submit the job for execution.
         
@@ -173,7 +216,7 @@ class PJob(JobV1):
             self._status = JobStatus.ERROR
             raise e
 
-    def result(self) -> Result:
+    def result(self) -> Optional[List[Result]]:
         """Return the result of the job."""
         return self._result.results if self._result is not None else None
 
@@ -182,17 +225,38 @@ class PJob(JobV1):
         return self._status
 
     def running(self) -> bool:
-        """Return whether the job is actively running."""
+        """
+        Return whether the job is actively running.
+
+        Returns:
+            True if the job's status is 'RUNNING', False otherwise.
+        """
         return self._status == JobStatus.RUNNING
 
     def cancelled(self) -> bool:
-        """Return whether the job has been cancelled."""
+        """
+        Return whether the job has been cancelled.
+
+        Returns:
+            True if the job's status is 'CANCELLED', False otherwise.
+        """
         return self._status == JobStatus.CANCELLED
 
     def done(self) -> bool:
-        """Return whether the job has successfully run."""
+        """
+        Return whether the job has successfully run.
+
+        Returns:
+            True if the job's status is 'DONE', False otherwise.
+        """
         return self._status == JobStatus.DONE
 
     def in_final_state(self) -> bool:
-        """Return whether the job is in a final job state."""
+        """
+        Return whether the job is in a final job state.
+
+        Returns:
+            True if the job is in a final state (DONE, ERROR, or
+            CANCELLED), False otherwise.
+        """
         return self._status in {JobStatus.DONE, JobStatus.ERROR, JobStatus.CANCELLED}

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

@@ -3,7 +3,7 @@ import pytest
 import numpy as np
 
 # Conditional imports for Qiskit and Aer
-qiskit = pytest.importorskip("qiskit", minversion="1.0", reason="Qiskit >= 1.0 is required")
+qiskit = pytest.importorskip("qiskit", minversion="2.0", reason="Qiskit >= 2.0 is required")
 
 from qiskit.circuit import QuantumCircuit, Parameter, ParameterVector
 from qiskit.circuit.random import random_circuit
@@ -68,7 +68,11 @@ def test_estimator_multiple_observables_per_pub():
     
     job = estimator.run([(qc, observables)])
     result = job.result()
-    
+
+    jobq = StatevectorEstimator().run([(qc, observables)])
+    resultq = jobq.result()[0]
+    assert resultq.data.evs.shape == result[0].data.evs.shape
+
     expected_evs = [p1_to_ev(0.5), p1_to_ev(0.25)]
     assert result[0].data.evs == pytest.approx(expected_evs, abs=1e-6)
 
@@ -92,6 +96,48 @@ def test_estimator_multiobs_multiparams():
     assert result[0].data.evs == pytest.approx([p1_to_ev(0.5), p1_to_ev(0.25)], abs=1e-6)
     assert result[1].data.evs == pytest.approx([p1_to_ev(0.25), p1_to_ev(0.5)], abs=1e-6)
 
+def test_backend_transpile_batch_params_from_doc():
+    """Tests a single circuit against a list of observables in one PUB."""
+    # [qiskit_multiparameters]
+    backend = PBackend(num_qubits=2)
+    pm = generate_preset_pass_manager(optimization_level=1, backend=backend)
+
+    circuit = QuantumCircuit(2)
+    circuit.h(0)
+    circuit.cx(0, 1)
+    circuit.ry(Parameter("a"), 0)
+    circuit.rz(Parameter("b"), 0)
+    circuit.cx(0, 1)
+    circuit.h(0)
+
+    transpiled_circuit = pm.run(circuit)
+
+    params = np.vstack(
+    [
+        np.linspace(-np.pi, np.pi, 100),
+        np.linspace(-4 * np.pi, 4 * np.pi, 100),
+    ]
+    ).T
+
+    observables = [
+        [SparsePauliOp(["XX", "IY"], [0.5, 0.5])],
+        [SparsePauliOp("XX")],
+        [SparsePauliOp("IY")],
+    ]    
+
+    estimator_pub = (transpiled_circuit, observables, params)
+
+    job = backend.run([estimator_pub])
+    result = job.result()
+    # [qiskit_multiparameters]
+
+    jobq = StatevectorEstimator().run([estimator_pub])
+    resultq = jobq.result()[0]
+    assert resultq.data.evs.shape == result[0].data.evs.shape
+
+
+    assert result[0].data.evs == pytest.approx(resultq.data.evs, abs=1e-4)
+    
 def test_noise_model_is_correctly_applied():
     """Confirms the noise model passed to the estimator alters the result."""
     p = 0.1