pyrauli 0.3.2__tar.gz → 0.4.0__tar.gz

{pyrauli-0.3.2 → pyrauli-0.4.0}/CMakeLists.txt

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyrauli
-Version: 0.3.2
+Version: 0.4.0
 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
@@ -687,11 +687,14 @@ Requires-Python: >=3.9
 Provides-Extra: qiskit
 Requires-Dist: qiskit>=2.0.0; extra == "qiskit"
 Requires-Dist: numpy; extra == "qiskit"
+Provides-Extra: symbolic
+Requires-Dist: sympy; extra == "symbolic"
 Provides-Extra: test
 Requires-Dist: pytest>=8.0.0; extra == "test"
 Requires-Dist: pytest-cov>=5.0.0; extra == "test"
 Requires-Dist: pytest-benchmark; extra == "test"
 Requires-Dist: numpy; extra == "test"
+Requires-Dist: sympy; extra == "test"
 Description-Content-Type: text/markdown
 
 # pyrauli: High-Performance Quantum Circuit Simulation

pyrauli-0.4.0/benchmarks/test_benchmark_qaoa.py

@@ -0,0 +1,43 @@
+import pytest
+from pyrauli import SymbolicObservable, SymbolicCircuit
+
+def rzz(qc, q1, q2, v):
+    qc.add_operation("cx", q1, q2)
+    qc.add_operation("rz", q2, v)
+    qc.add_operation("cx", q1, q2)
+
+def rx(qc, q, v):
+    qc.add_operation("h", q)
+    qc.add_operation("rz", q, v)
+    qc.add_operation("h", q)
+    
+@pytest.fixture(scope="module")
+def maxcut_qaoa_N4P1():
+    """Fixture"""
+    obs = SymbolicObservable(["ZZII", "ZIZI", "IZZI", "ZIIZ", "IZIZ", "IIZZ"])
+    qc = SymbolicCircuit(4)
+
+    for i in range(4):
+        qc.add_operation("h", i)
+
+    rzz(qc, 0, 1, "tz")
+    rzz(qc, 0, 3, "tz")
+    rzz(qc, 0, 2, "tz")
+
+    rx(qc, 0, "tx")
+
+    rzz(qc, 1, 2, "tz")
+    rzz(qc, 1, 3, "tz")
+
+    rx(qc, 1, "tx")
+    rzz(qc, 2, 3, "tz")
+
+    rx(qc, 2, "tx")
+    rx(qc, 3, "tx")
+
+    return qc, obs
+
+def test_qaoa_N4P1_run(maxcut_qaoa_N4P1, benchmark):
+    qc, obs = maxcut_qaoa_N4P1
+
+    benchmark(qc.run, obs)

pyrauli-0.4.0/docs/guides/how_to_symbolic.rst

@@ -0,0 +1,99 @@
+.. _how_to_symbolic:
+
+Symbolic Simulation
+===================
+
+`pyrauli` offers a powerful symbolic simulation mode that allows you to work with parameterized quantum circuits. Instead of providing fixed numerical values for parameters like gate angles or noise strengths, you can use symbolic variables. This is particularly useful for tasks like variational algorithms, gradient calculations, and sensitivity analysis, where you need to explore a function's behavior over a range of parameter values.
+
+The Symbolic Toolkit
+--------------------
+
+The symbolic mode is built on three core classes:
+
+* :py:class:`~pyrauli.SymbolicCoefficient`: Represents a mathematical expression that can include variables, constants, and standard mathematical operations.
+* :py:class:`~pyrauli.SymbolicObservable`: An observable whose terms have `SymbolicCoefficient` objects as coefficients.
+* :py:class:`~pyrauli.SymbolicCircuit`: A circuit that can accept `SymbolicCoefficient` objects as parameters for its operations.
+
+Working with `SymbolicCoefficient`
+------------------------------------
+
+The :py:class:`~pyrauli.SymbolicCoefficient` is the fundamental building block. You can create one from a number or a string (which becomes a variable name).
+
+.. literalinclude:: /../tests/snippets/test_symbolic_coefficient_guide.py
+   :language: python
+   :start-after: # [symbolic_init]
+   :end-before: # [symbolic_init]
+   :dedent: 4
+
+These objects support standard mathematical operations, allowing you to build complex expressions.
+
+.. literalinclude:: /../tests/snippets/test_symbolic_coefficient_guide.py
+   :language: python
+   :start-after: # [symbolic_ops]
+   :end-before: # [symbolic_ops]
+   :dedent: 4
+
+Evaluating Expressions
+~~~~~~~~~~~~~~~~~~~~~~
+
+A key feature is the ability to substitute variables with values. There are two ways to do this:
+
+1.  **.evaluate()**: This method substitutes all variables and computes a final floating-point number. It will raise an error if any variables are left unbound.
+2.  **.symbolic_evaluate()**: This method substitutes only the specified variables, returning a new, potentially simpler `SymbolicCoefficient`.
+
+.. literalinclude:: /../tests/snippets/test_symbolic_coefficient_guide.py
+   :language: python
+   :start-after: # [symbolic_evaluate]
+   :end-before: # [symbolic_evaluate]
+   :dedent: 4
+
+Simplifying Expressions
+~~~~~~~~~~~~~~~~~~~~~~~
+
+The :py:meth:`~pyrauli.SymbolicCoefficient.simplified` method applies arithmetic rules (like `x*1=x` or `x+0=x`) to reduce the complexity of an expression.
+
+.. literalinclude:: /../tests/snippets/test_symbolic_coefficient_guide.py
+   :language: python
+   :start-after: # [symbolic_simplify]
+   :end-before: # [symbolic_simplify]
+   :dedent: 4
+
+Constructing a `SymbolicObservable`
+-------------------------------------
+
+A :py:class:`~pyrauli.SymbolicObservable` works just like a regular :py:class:`~pyrauli.Observable`, but its coefficients are symbolic.
+
+.. literalinclude:: /../tests/snippets/test_symbolic_observable_guide.py
+   :language: python
+   :start-after: # [symbolic_obs_init]
+   :end-before: # [symbolic_obs_init]
+   :dedent: 4
+
+The :py:meth:`~pyrauli.SymbolicObservable.simplify` method on an observable will simplify the symbolic coefficients of all its terms. You can also pass a dictionary of variable substitutions to this method.
+
+.. literalinclude:: /../tests/snippets/test_symbolic_observable_guide.py
+   :language: python
+   :start-after: # [symbolic_obs_simplify]
+   :end-before: # [symbolic_obs_simplify]
+   :dedent: 4
+
+Building and Running a `SymbolicCircuit`
+------------------------------------------
+
+The end-to-end workflow is straightforward. You build a :py:class:`~pyrauli.SymbolicCircuit` using variable names for your parameters and then run it on a :py:class:`~pyrauli.SymbolicObservable`. The simulation propagates the symbolic expressions through the circuit according to the rules of quantum mechanics.
+
+.. literalinclude:: /../tests/snippets/test_symbolic_circuit_snippet.py
+   :language: python
+   :start-after: # [symbolic_circuit]
+   :end-before: # [symbolic_circuit]
+   :dedent: 4
+
+The final result is a new :py:class:`~pyrauli.SymbolicObservable`. To get the final expectation value, you call its :py:meth:`~pyrauli.SymbolicObservable.expectation_value` method, which returns a `SymbolicCoefficient`. You can then evaluate this coefficient for any set of concrete parameter values.
+
+.. literalinclude:: /../tests/snippets/test_symbolic_circuit_snippet.py
+   :language: python
+   :start-after: # [symbolic_evaluation]
+   :end-before: # [symbolic_evaluation]
+   :dedent: 4
+
+This workflow allows you to run the simulation once to get a general symbolic result and then analyze that result for many different parameter values without needing to re-run the simulation each time.

{pyrauli-0.3.2 → pyrauli-0.4.0}/docs/index.rst

@@ -31,6 +31,7 @@ the library for the first time or need a specific technical detail.
    guides/how_to_complexity
    guides/how_to_qiskit
    guides/how_to_noise
+   guides/how_to_symbolic
 
 .. toctree::
    :maxdepth: 2

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

@@ -5,7 +5,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "pyrauli"
-version = "0.3.2"
+version = "0.4.0"
 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"
@@ -28,11 +28,15 @@ qiskit = [
     "qiskit>=2.0.0",
     "numpy"
 ]
+symbolic = [
+	"sympy"
+]
 test = [
     "pytest>=8.0.0",
     "pytest-cov>=5.0.0",
     "pytest-benchmark",
     "numpy",
+    "sympy"
 ]
 
 [tool.scikit-build.wheel]

{pyrauli-0.3.2 → pyrauli-0.4.0}/src/pyrauli/__init__.py

@@ -12,6 +12,7 @@ from ._core import (
     SchedulingPolicy, NeverPolicy, AlwaysBeforeSplittingPolicy,
     AlwaysAfterSplittingPolicy, Circuit, OperationType, Timing,
     SimulationState, CompressionResult, LambdaPolicy,
+    SymbolicCoefficient, SymbolicPauliTerm, SymbolicObservable, SymbolicNoise, SymbolicNoiseModel, SymbolicTruncator, SymbolicWeightTruncator, SymbolicNeverTruncator, SymbolicMultiTruncator, SymbolicCircuit
 )
 
 __all__ = [
@@ -22,8 +23,24 @@ __all__ = [
     "AlwaysBeforeSplittingPolicy", "AlwaysAfterSplittingPolicy", "Circuit",
     "OperationType", "Timing", "SimulationState", "CompressionResult",
     "LambdaPolicy",
+    "SymbolicCoefficient", "SymbolicObservable", "SymbolicPauliTerm", "SymbolicNoise", "SymbolicNoiseModel", "SymbolicTruncator", "SymbolicWeightTruncator", "SymbolicNeverTruncator", "SymbolicMultiTruncator", "SymbolicCircuit"
+
 ]
 
+try:
+    import sympy
+    def to_sympy(self):
+        """
+        Converts the SymbolicCoefficient to a SymPy expression.
+
+        Returns:
+            A SymPy expression equivalent to the SymbolicCoefficient.
+        """
+        return sympy.sympify(self.to_string())
+    SymbolicCoefficient.to_sympy = to_sympy
+except ImportError:
+    pass
+
 # Conditionally import Qiskit-related functionality
 try:
     from .backend import PBackend

{pyrauli-0.3.2 → pyrauli-0.4.0}/src/pyrauli/_core/bindings.cpp

@@ -16,6 +16,7 @@
 #include "pauli_term.hpp"
 #include "scheduler.hpp"
 #include "truncate.hpp"
+#include "symbolic/coefficient.hpp"
 
 namespace py = pybind11;
 
@@ -27,8 +28,8 @@ using SchedulingPolicyPtr = std::shared_ptr<SchedulingPolicy>;
 
 // Concrete holder types
 using CoeffTruncatorPtr = std::shared_ptr<CoefficientTruncator<coeff_t>>;
-using WeightTruncatorPtr = std::shared_ptr<WeightTruncator>;
-using NeverTruncatorPtr = std::shared_ptr<NeverTruncator>;
+using WeightTruncatorPtr = std::shared_ptr<WeightTruncator<coeff_t>>;
+using NeverTruncatorPtr = std::shared_ptr<NeverTruncator<coeff_t>>;
 using KeepNTruncatorPtr = std::shared_ptr<KeepNTruncator<coeff_t>>;
 using NeverPolicyPtr = std::shared_ptr<NeverPolicy>;
 using AlwaysBeforePolicyPtr = std::shared_ptr<AlwaysBeforeSplittingPolicy>;
@@ -38,6 +39,18 @@ using LambdaPredicate_t = std::function<bool(PauliTermContainer<coeff_t>::NonOwn
 using LambdaTruncator = PredicateTruncator<LambdaPredicate_t>;
 using LambdaTruncatorPtr = std::shared_ptr<LambdaTruncator>;
 
+// Symbolic
+using SymbolicCoeff_t = SymbolicCoefficient<coeff_t>;
+using SymbolicObs_t = Observable<SymbolicCoeff_t>;
+using SymbolicCircuit_t = Circuit<SymbolicCoeff_t>;
+using SymbolicTruncatorPtr = std::shared_ptr<Truncator<SymbolicCoeff_t>>;
+using SymbolicWeightTruncatorPtr = std::shared_ptr<WeightTruncator<SymbolicCoeff_t>>;
+using SymbolicNeverTruncatorPtr = std::shared_ptr<NeverTruncator<SymbolicCoeff_t>>;
+using SymbolicLambdaPredicate_t = std::function<bool(PauliTermContainer<SymbolicCoeff_t>::NonOwningPauliTermPacked const&)>;
+using SymbolicLambdaTruncator = PredicateTruncator<SymbolicLambdaPredicate_t>;
+using SymbolicLambdaTruncatorPtr = std::shared_ptr<SymbolicLambdaTruncator>;
+using sPTC = PauliTermContainer<SymbolicCoeff_t>;
+
 struct LambdaPolicy : public SchedulingPolicy {
     public:
 	using predicate_t = std::function<bool(SimulationState const&, OperationType, Timing)>;
@@ -51,6 +64,11 @@ struct LambdaPolicy : public SchedulingPolicy {
 	predicate_t predicate;
 };
 
+// very very slow. That's why it's not in propauli.
+bool operator==(SymbolicCoeff_t const& lhs, SymbolicCoeff_t const& rhs) {
+	return lhs.to_string() == rhs.to_string();
+}
+
 PYBIND11_MODULE(_core, m) {
 	m.doc() = "Core C++ functionality for pyrauli, wrapped with pybind11";
 
@@ -91,7 +109,9 @@ PYBIND11_MODULE(_core, m) {
 		.def("weight", &Pauli::weight, "Calculates the Pauli weight (1 if not Identity, 0 otherwise).")
 		.def("apply_pauli", &Pauli::apply_pauli,
 		     "Applies a Pauli gate to this operator (in the Heisenberg picture).")
-		.def("apply_unital_noise", &Pauli::apply_unital_noise,
+		.def("apply_unital_noise", &Pauli::apply_unital_noise<coeff_t>,
+		     "Applies a unital noise channel to this operator.")
+		.def("apply_unital_noise", &Pauli::apply_unital_noise<SymbolicCoeff_t>,
 		     "Applies a unital noise channel to this operator.")
 		.def("apply_clifford", &Pauli::apply_clifford,
 		     "Applies a single-qubit Clifford gate to this operator, modifying it in place.")
@@ -187,6 +207,7 @@ PYBIND11_MODULE(_core, m) {
 			return ss.str();
 		});
 
+
 	// NoiseModel class
 	py::class_<Noise<coeff_t>>(m, "Noise", "Defines the strengths of different noise channels.")
 		.def(py::init<>())
@@ -206,11 +227,11 @@ PYBIND11_MODULE(_core, m) {
 	py::class_<CoefficientTruncator<coeff_t>, Truncator<coeff_t>, CoeffTruncatorPtr>(
 		m, "CoefficientTruncator", "Truncator that removes Pauli terms with small coefficients.")
 		.def(py::init<coeff_t>());
-	py::class_<WeightTruncator, Truncator<coeff_t>, WeightTruncatorPtr>(
+	py::class_<WeightTruncator<coeff_t>, Truncator<coeff_t>, WeightTruncatorPtr>(
 		m, "WeightTruncator", "Truncator that removes Pauli terms with high Pauli weight.")
 		.def(py::init<size_t>());
-	py::class_<NeverTruncator, Truncator<coeff_t>, NeverTruncatorPtr>(m, "NeverTruncator",
-									  "A truncator that never removes any terms.")
+	py::class_<NeverTruncator<coeff_t>, 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",
@@ -285,7 +306,7 @@ PYBIND11_MODULE(_core, m) {
 				     "Represents a quantum circuit and provides a high-level simulation interface.")
 		.def(py::init<unsigned, std::shared_ptr<Truncator<coeff_t>>, const NoiseModel<coeff_t>&,
 			      std::shared_ptr<SchedulingPolicy>, std::shared_ptr<SchedulingPolicy>>(),
-		     py::arg("nb_qubits"), py::arg("truncator") = std::make_shared<NeverTruncator>(),
+		     py::arg("nb_qubits"), py::arg("truncator") = std::make_shared<NeverTruncator<coeff_t>>(),
 		     py::arg("noise_model") = NoiseModel<coeff_t>(),
 		     py::arg("merge_policy") = std::make_shared<AlwaysAfterSplittingPolicy>(),
 		     py::arg("truncate_policy") = std::make_shared<AlwaysAfterSplittingPolicy>())
@@ -380,4 +401,309 @@ PYBIND11_MODULE(_core, m) {
 			ss << pt;
 			return ss.str();
 		});
+
+	// Symbolic 
+	py::class_<Variable>(m, "Variable", "Symbolic string variable")
+		.def(py::init<std::string>());
+
+	py::class_<SymbolicCoeff_t>(m, "SymbolicCoefficient", "An easy to use symbolic coefficient.")
+		.def(py::init<coeff_t>(), "Construct from a constant value.")
+		.def(py::init([](const std::string& variable_name) {
+			     return SymbolicCoeff_t{Variable{variable_name}};
+		     }), "Construct from a variable name (string).")
+		.def(py::init<Variable>(), "Construct from a variable.")
+		.def("to_string", &SymbolicCoeff_t::to_string, "Convert to string using a formatting for real.", py::arg("format") = "{:.3f}")
+		.def("evaluate", &SymbolicCoeff_t::evaluate, "Evaluate into a real by replacing variables.", py::arg("variables") = std::unordered_map<std::string, SymbolicCoeff_t>{})
+		.def("symbolic_evaluate", &SymbolicCoeff_t::symbolic_evaluate, "Evaluate into another symbolic coefficient by replacing some variables.", py::arg("variables") = std::unordered_map<std::string, SymbolicCoeff_t>{})
+		.def("simplified", &SymbolicCoeff_t::simplified, "Returns simplified symbolic coefficient using arithmetic rules.")
+       		.def("__repr__", [](SymbolicCoeff_t const& coeff) { return coeff.to_string(); })
+	      	.def(py::self *= py::self)
+	      	.def(py::self += py::self)
+	      	.def(py::self /= py::self)
+	      	.def(py::self -= py::self)
+	     	.def(-py::self)
+	    	.def(py::self + py::self)
+	    	.def(py::self * py::self)
+	    	.def(py::self / py::self)
+	    	.def(py::self - py::self)
+		.def(py::self *= float())
+	      	.def(py::self += float())
+	      	.def(py::self /= float())
+	      	.def(py::self -= float())
+	    	.def(py::self + float())
+	    	.def(py::self * float())
+	    	.def(py::self / float())
+	    	.def(py::self - float())
+	    	.def(float() + py::self)
+	    	.def(float() * py::self)
+	    	.def(float() / py::self)
+	    	.def(float() - py::self)
+
+	   	.def("cos", &SymbolicCoeff_t::cos, "Apply cosinus")
+	   	.def("sin", &SymbolicCoeff_t::sin, "Apply sinus")
+	   	.def("sqrt", &SymbolicCoeff_t::sqrt, "Apply sqrt");
+
+	py::class_<PauliTerm<SymbolicCoeff_t>>(
+		m, "SymbolicPauliTerm",
+		"Represents a single term in an observable, consisting of a Pauli string and a coefficient.")
+		.def(py::init<std::string_view, SymbolicCoeff_t>(), py::arg("pauli_string"), py::arg("coefficient") = SymbolicCoeff_t{1.0f},
+		     "Constructs from a string representation and a coefficient.")
+		.def(py::init([](std::string_view sv, std::string  const& variable_name) {
+			return PauliTerm<SymbolicCoeff_t>{sv, SymbolicCoeff_t{Variable{variable_name}}};
+		     }),
+		     "Constructs from a string representation and a coefficient.")
+		.def(py::init([](std::string_view sv, coeff_t coeff) {
+			     return PauliTerm<SymbolicCoeff_t>{sv, SymbolicCoeff_t{coeff}};
+		     }), "Construct from a constant coefficient")
+		.def("apply_pauli", &PauliTerm<SymbolicCoeff_t>::apply_pauli,
+		     "Applies a Pauli gate to a specific qubit of the term.")
+		.def("apply_clifford", &PauliTerm<SymbolicCoeff_t>::apply_clifford,
+		     "Applies a Clifford gate to a specific qubit of the term.")
+		.def("apply_unital_noise", &PauliTerm<SymbolicCoeff_t>::apply_unital_noise,
+		     "Applies a unital noise channel to a specific qubit of the term.")
+		.def("apply_cx", &PauliTerm<SymbolicCoeff_t>::apply_cx, "Applies a CNOT gate to the term.")
+		.def("apply_rz", &PauliTerm<SymbolicCoeff_t>::apply_rz, "Applies an Rz gate, potentially splitting the term.")
+		.def("apply_amplitude_damping_xy", &PauliTerm<SymbolicCoeff_t>::apply_amplitude_damping_xy,
+		     "Applies the X/Y part of the amplitude damping channel.")
+		.def("apply_amplitude_damping_z", &PauliTerm<SymbolicCoeff_t>::apply_amplitude_damping_z,
+		     "Applies the Z part of the amplitude damping channel, splitting the term.")
+		.def("expectation_value", &PauliTerm<SymbolicCoeff_t>::expectation_value,
+		     "Calculates the expectation value of this single term.")
+		.def("pauli_weight", &PauliTerm<SymbolicCoeff_t>::pauli_weight,
+		     "Calculates the Pauli weight (number of non-identity operators).")
+		.def_property_readonly("coefficient", &PauliTerm<SymbolicCoeff_t>::coefficient, "The coefficient of the term.")
+		.def("__getitem__", [](const PauliTerm<SymbolicCoeff_t>& pt, size_t i) { return pt[i]; })
+		.def("__setitem__", [](PauliTerm<SymbolicCoeff_t>& pt, size_t i, const Pauli& p) { pt[i] = p; })
+		.def("__len__", &PauliTerm<SymbolicCoeff_t>::size)
+		.def(py::self == py::self)
+		.def(py::self != py::self)
+		.def("__repr__", [](const PauliTerm<SymbolicCoeff_t>& pt) {
+			std::stringstream ss;
+			ss << pt;
+			return ss.str();
+		});
+
+	
+	py::class_<SymbolicObs_t>(m, "SymbolicObservable",
+					"Represents a quantum observable symbolically, as a linear combination of Pauli strings.")
+		.def(py::init<std::string_view, SymbolicCoeff_t>(), py::arg("pauli_string"), py::arg("coeff") = SymbolicCoeff_t{1.f},
+		     "Constructs an observable from a single Pauli string.")
+		.def(py::init([](std::string_view sv, std::string const& variable_name) {
+			     return Observable<SymbolicCoeff_t>{sv, SymbolicCoeff_t{Variable{variable_name}}};
+		     }), "Construct from a variable coefficient")
+		.def(py::init([](std::string_view sv, coeff_t coeff) {
+			     return Observable<SymbolicCoeff_t>{sv, SymbolicCoeff_t{coeff}};
+		     }), "Construct from a constant coefficient")
+		.def(py::init<std::initializer_list<std::string_view>>(),
+		     "Constructs an observable from an initializer_list of Pauli strings.")
+		// Use a lambda to correctly initialize from a list of PauliTerm objects
+		.def(py::init([](const std::vector<PauliTerm<SymbolicCoeff_t>>& paulis) {
+			     return Observable<SymbolicCoeff_t>(paulis.begin(), paulis.end());
+		     }),
+		     "Constructs an observable from a list of PauliTerm objects.")
+		.def(py::init([](const std::vector<std::string>& paulis) {
+			     return Observable<SymbolicCoeff_t>(paulis.begin(), paulis.end());
+		     }),
+		     "Constructs an observable from a list of Pauli strings.")
+		.def("apply_pauli", &Observable<SymbolicCoeff_t>::apply_pauli,
+		     "Applies a single-qubit Pauli gate to the observable.")
+		.def("apply_clifford", &Observable<SymbolicCoeff_t>::apply_clifford,
+		     "Applies a single-qubit Clifford gate to the observable.")
+		.def("apply_unital_noise",
+			     &Observable<SymbolicCoeff_t>::apply_unital_noise,
+		     "Applies a single-qubit unital noise channel.")
+		.def(
+			"apply_unital_noise",
+			[](Observable<SymbolicCoeff_t>& self, UnitalNoise noise, size_t qubit, std::string const& strength) {
+				self.apply_unital_noise(noise, qubit, SymbolicCoeff_t(Variable{strength}));
+			},
+			"Applies a single-qubit unital noise channel, using a variable name for the strength.")
+		.def("apply_cx", &Observable<SymbolicCoeff_t>::apply_cx, "Applies a CNOT (CX) gate to the observable.")
+		.def("apply_rz", &Observable<SymbolicCoeff_t>::apply_rz,
+		     "Applies a single-qubit Rz rotation gate to the observable.")
+		.def(
+			"apply_rz",
+			[](Observable<SymbolicCoeff_t>& self, size_t qubit, std::string const& param) {
+				self.apply_rz(qubit, SymbolicCoeff_t(Variable{param}));
+			},
+			"Applies a single-qubit Rz rotation gate to the observable, using a variable name for the angle.")
+		.def("apply_amplitude_damping", &Observable<SymbolicCoeff_t>::apply_amplitude_damping, "Applies an amplitude damping noise channel.")
+		.def(
+			"apply_amplitude_damping",
+			[](Observable<SymbolicCoeff_t>& self, size_t qubit, std::string const& strength) {
+				self.apply_amplitude_damping(qubit, SymbolicCoeff_t(Variable{strength}));
+			},
+			"Applies an amplitude damping noise channel, using a variable name for the strength.")		
+		.def("expectation_value", &Observable<SymbolicCoeff_t>::expectation_value,
+		     "Calculates the expectation value of the observable.")
+		.def("merge", &Observable<SymbolicCoeff_t>::merge, "Merges Pauli terms with identical Pauli strings.")
+		.def("size", &Observable<SymbolicCoeff_t>::size, "Gets the number of Pauli terms in the observable.")
+		.def("simplify", &Observable<SymbolicCoeff_t>::simplify<SymbolicCoeff_t>, py::arg("variable_map") = std::unordered_map<std::string, coeff_t>{}, "Simplify the observable coefficient and replace variables.")
+		.def(
+			"truncate", [](Observable<SymbolicCoeff_t>& obs, SymbolicTruncatorPtr ptr) { return obs.truncate(*ptr); },
+			"Truncates the observable based on a given truncation strategy.")
+		.def(py::self == py::self)
+		.def(py::self != py::self)
+		.def("__getitem__", [](const Observable<SymbolicCoeff_t>& obs, size_t i) { return obs[i]; })
+		.def("__len__", &Observable<SymbolicCoeff_t>::size)
+		.def(
+			"__iter__",
+			[](const Observable<SymbolicCoeff_t>& obs) { return py::make_iterator(obs.begin(), obs.end()); },
+			py::keep_alive<0, 1>())
+		.def("__repr__", [](const Observable<SymbolicCoeff_t>& obs) {
+			std::stringstream ss;
+			ss << obs;
+			return ss.str();
+		});
+
+
+	py::class_<Noise<SymbolicCoeff_t>>(m, "SymbolicNoise", "Defines the strengths of different noise channels.")
+		.def(py::init<>())
+		.def_readwrite("depolarizing_strength", &Noise<SymbolicCoeff_t>::depolarizing_strength)
+		.def_readwrite("dephasing_strength", &Noise<SymbolicCoeff_t>::dephasing_strength)
+		.def_readwrite("amplitude_damping_strength", &Noise<SymbolicCoeff_t>::amplitude_damping_strength);
+
+	py::class_<NoiseModel<SymbolicCoeff_t>>(m, "SymbolicNoiseModel", "A model for applying noise to quantum gates.")
+		.def(py::init<>())
+		.def("add_unital_noise_on_gate",
+			     &NoiseModel<SymbolicCoeff_t>::add_unital_noise_on_gate,
+		     "Adds a unital noise channel to be applied after a specific gate type.")
+		.def(
+			"add_unital_noise_on_gate",
+			[](NoiseModel<SymbolicCoeff_t>& self, QGate gate, UnitalNoise noise, std::string const& strength) {
+				self.add_unital_noise_on_gate(gate, noise, SymbolicCoeff_t(Variable{strength}));
+			},
+			"Adds a unital noise channel to be applied after a specific gate type, using a variable name for strength.")
+		.def("add_amplitude_damping_on_gate",
+			     &NoiseModel<SymbolicCoeff_t>::add_amplitude_damping_on_gate,
+		     "Adds an amplitude damping channel to be applied after a specific gate type.")
+		.def(
+			"add_amplitude_damping_on_gate",
+			[](NoiseModel<SymbolicCoeff_t>& self, QGate gate, std::string const& strength) {
+				self.add_amplitude_damping_on_gate(gate, SymbolicCoeff_t(Variable{strength}));
+			},
+			"Adds an amplitude damping channel to be applied after a specific gate type, using a variable name for strength.");
+	// symbolic truncators
+	py::class_<Truncator<SymbolicCoeff_t>, SymbolicTruncatorPtr>(m, "SymbolicTruncator",
+						     "Abstract base class for defining truncation strategies.");
+	py::class_<WeightTruncator<SymbolicCoeff_t>, Truncator<SymbolicCoeff_t>, SymbolicWeightTruncatorPtr>(
+		m, "SymbolicWeightTruncator", "Truncator that removes Pauli terms with high Pauli weight.")
+		.def(py::init<size_t>());
+	py::class_<NeverTruncator<SymbolicCoeff_t>, Truncator<SymbolicCoeff_t>, SymbolicNeverTruncatorPtr>(
+		m, "SymbolicNeverTruncator", "A truncator that never removes any terms.")
+		.def(py::init<>());
+	//py::class_<PredicateTruncator<SymbolicCoeff_t>, Truncator<SymbolicCoeff_t>, std::shared_ptr<PredicateTruncator<SymbolicLambdaPredicate_t>>>(
+	//	m, "SymbolicLambdaTruncator", "A truncator that uses a Python function as a predicate.")
+	//	.def(py::init<SymbolicLambdaPredicate_t>());
+	py::class_<RuntimeMultiTruncators<SymbolicCoeff_t>, Truncator<SymbolicCoeff_t>,
+		   std::shared_ptr<RuntimeMultiTruncators<SymbolicCoeff_t>>>(
+		m, "SymbolicMultiTruncator", "A truncator that combines multiple truncators at runtime.")
+		.def(py::init<const std::vector<SymbolicTruncatorPtr>&>());
+
+	py::class_<Circuit<SymbolicCoeff_t>>(m, "SymbolicCircuit",
+				     "Represents a quantum circuit and provides a high-level simulation interface.")
+		.def(py::init<unsigned, std::shared_ptr<Truncator<SymbolicCoeff_t>>, const NoiseModel<SymbolicCoeff_t>&,
+			      std::shared_ptr<SchedulingPolicy>, std::shared_ptr<SchedulingPolicy>>(),
+		     py::arg("nb_qubits"), py::arg("truncator") = std::make_shared<NeverTruncator<SymbolicCoeff_t>>(),
+		     py::arg("noise_model") = NoiseModel<SymbolicCoeff_t>(),
+		     py::arg("merge_policy") = std::make_shared<AlwaysAfterSplittingPolicy>(),
+		     py::arg("truncate_policy") = std::make_shared<AlwaysAfterSplittingPolicy>())
+		.def("nb_qubits", &Circuit<SymbolicCoeff_t>::nb_qubits, "Gets the number of qubits in the circuit.")
+		// Use lambdas to resolve templated overloads
+		.def(
+			"add_operation",
+			[](Circuit<SymbolicCoeff_t>& self, std::string op, unsigned q1) { self.add_operation(op, q1); },
+			"Adds a single-qubit gate.", py::arg("op"), py::arg("qubit"))
+		.def(
+			"add_operation",
+			[](Circuit<SymbolicCoeff_t>& self, std::string op, unsigned q1, SymbolicCoeff_t p) {
+				self.add_operation(op, q1, p);
+			},
+			"Adds a single-qubit gate with a parameter.", py::arg("op"), py::arg("qubit"), py::arg("param"))
+		.def(
+			"add_operation",
+			[](Circuit<SymbolicCoeff_t>& self, std::string op, unsigned q1, std::string const& p) {
+				self.add_operation(op, q1, SymbolicCoeff_t(Variable(p)));
+			},
+			"Adds a single-qubit gate with a parameter.", py::arg("op"), py::arg("qubit"), py::arg("param"))
+		.def(
+			"add_operation",
+			[](Circuit<SymbolicCoeff_t>& self, std::string op, unsigned q1, unsigned q2) {
+				self.add_operation(op, q1, q2);
+			},
+			"Adds a two-qubit gate.", py::arg("op"), py::arg("control"), py::arg("target"))
+		.def("run", &Circuit<SymbolicCoeff_t>::run, "Runs the simulation on the circuit.")
+		.def("reset", &Circuit<SymbolicCoeff_t>::reset, "Clears all operations from the circuit.")
+		.def("set_truncator", &Circuit<SymbolicCoeff_t>::set_truncator, "Sets a new truncator for the circuit.")
+		.def("set_merge_policy", &Circuit<SymbolicCoeff_t>::set_merge_policy,
+		     "Sets a new policy for when to merge Pauli terms.")
+		.def("set_truncate_policy", &Circuit<SymbolicCoeff_t>::set_truncate_policy,
+		     "Sets a new policy for when to truncate the observable.");
+
+	py::class_<sPTC::ReadOnlyNonOwningPauliTermPacked>(m, "SymbolicReadOnlyPackedPauliTermView",
+							  "A read-only, non-owning view of a packed Pauli term.")
+		.def_property_readonly("coefficient", &sPTC::ReadOnlyNonOwningPauliTermPacked::coefficient,
+				       "The coefficient of the term.")
+		.def_property_readonly("nb_qubits", &sPTC::ReadOnlyNonOwningPauliTermPacked::size,
+				       "The number of qubits in the term.")
+		.def("pauli_weight", &sPTC::ReadOnlyNonOwningPauliTermPacked::pauli_weight,
+		     "Calculates the Pauli weight (number of non-identity operators).")
+		.def("expectation_value", &sPTC::ReadOnlyNonOwningPauliTermPacked::expectation_value,
+		     "Calculates the expectation value of this single term.")
+		.def(
+			"to_pauli_term",
+			[](const sPTC::ReadOnlyNonOwningPauliTermPacked& self) {
+				return static_cast<PauliTerm<SymbolicCoeff_t>>(self);
+			},
+			"Creates an owning PauliTerm copy from this view.")
+		.def("__len__", &sPTC::ReadOnlyNonOwningPauliTermPacked::size)
+		.def("__getitem__", &sPTC::ReadOnlyNonOwningPauliTermPacked::get_pauli,
+		     "Gets the Pauli operator at a specific qubit index.")
+		.def(py::self == py::self)
+		.def(
+			"__eq__",
+			[](const sPTC::ReadOnlyNonOwningPauliTermPacked& self, const PauliTerm<SymbolicCoeff_t>& other) {
+				return self == other;
+			},
+			"Compares this view with an owning PauliTerm object.")
+		.def("__repr__", [](const sPTC::ReadOnlyNonOwningPauliTermPacked& pt) {
+			std::stringstream ss;
+			ss << pt;
+			return ss.str();
+		});
+
+	py::class_<sPTC::NonOwningPauliTermPacked>(m, "SymbolicPackedPauliTermView",
+						  "A mutable, non-owning view of a packed Pauli term.")
+		.def_property("coefficient", &sPTC::NonOwningPauliTermPacked::coefficient,
+			      &sPTC::NonOwningPauliTermPacked::set_coefficient,
+			      "The coefficient of the term (read/write).")
+		.def_property_readonly("nb_qubits", &sPTC::NonOwningPauliTermPacked::size,
+				       "The number of qubits in the term.")
+		.def("pauli_weight", &sPTC::NonOwningPauliTermPacked::pauli_weight,
+		     "Calculates the Pauli weight (number of non-identity operators).")
+		.def("expectation_value", &sPTC::NonOwningPauliTermPacked::expectation_value,
+		     "Calculates the expectation value of this single term.")
+		.def(
+			"to_pauli_term",
+			[](const sPTC::NonOwningPauliTermPacked& self) { return static_cast<PauliTerm<SymbolicCoeff_t>>(self); },
+			"Creates an owning PauliTerm copy from this view.")
+		.def("add_coeff", &sPTC::NonOwningPauliTermPacked::add_coeff, "Adds a value to the term's coefficient.") 
+		.def("simplify", &sPTC::NonOwningPauliTermPacked::simplify<SymbolicCoeff_t>, "Simplify (in-place) a symbolic pauli term coefficient and replace variables.")
+		.def("__len__", &sPTC::NonOwningPauliTermPacked::size)
+		.def("__getitem__", &sPTC::NonOwningPauliTermPacked::get_pauli,
+		     "Gets the Pauli operator at a specific qubit index.")
+		.def("__setitem__", &sPTC::NonOwningPauliTermPacked::set_pauli,
+		     "Sets the Pauli operator at a specific qubit index.")
+		.def(py::self == py::self)
+		.def(
+			"__eq__",
+			[](const sPTC::NonOwningPauliTermPacked& self, const PauliTerm<SymbolicCoeff_t>& other) {
+				return self == other;
+			},
+			"Compares this view with an owning PauliTerm object.")
+		.def("__repr__", [](const sPTC::NonOwningPauliTermPacked& pt) {
+			std::stringstream ss;
+			ss << pt;
+			return ss.str();
+		});	
 }

pyrauli-0.4.0/tests/snippets/test_symbolic_circuit_noise.py

@@ -0,0 +1,22 @@
+from pyrauli import SymbolicCircuit, SymbolicObservable, SymbolicNoiseModel, UnitalNoise, QGate
+import pytest
+
+def test_symbolic_noise():
+    # [symbolic_noise]
+    # 1. Define a symbolic noise model
+    noise_model = SymbolicNoiseModel()
+    noise_model.add_unital_noise_on_gate(QGate.H, UnitalNoise.Depolarizing, "p_noise")
+
+    # 2. Create a circuit with the noise model
+    circuit = SymbolicCircuit(1, noise_model=noise_model)
+    circuit.add_operation("H", 0)
+
+    # 3. Run the simulation
+    observable = SymbolicObservable("X")
+    final_observable = circuit.run(observable)
+    result = final_observable.expectation_value()
+
+    # 4. Evaluate for different noise levels
+    print(f"Expectation value with no noise: {result.evaluate({'p_noise': 0.0})}")
+    print(f"Expectation value with some noise: {result.evaluate({'p_noise': 0.1})}")
+    # [symbolic_noise]

pyrauli-0.4.0/tests/snippets/test_symbolic_circuit_snippet.py

@@ -0,0 +1,19 @@
+from pyrauli import SymbolicCircuit, SymbolicObservable
+
+def test_symbolic_obs():
+    # [symbolic_circuit]
+    circuit = SymbolicCircuit(1)
+    circuit.add_operation("H", 0)
+    circuit.add_operation("Rz", 0, "theta")
+    circuit.add_operation("H", 0)
+    # [symbolic_circuit]
+
+    observable = SymbolicObservable("Z")
+
+    # [symbolic_evaluation]
+    final_observable = circuit.run(observable)
+    expectation_value = final_observable.expectation_value()
+
+    # Evaluate for a specific angle
+    value = expectation_value.evaluate({"theta": 3.14159 / 4})
+    # [symbolic_evaluation]

pyrauli-0.4.0/tests/snippets/test_symbolic_coefficient_guide.py

@@ -0,0 +1,53 @@
+import pytest
+
+def test_snippet_symbolic_coeff():
+    # [symbolic_init]
+    from pyrauli import SymbolicCoefficient
+
+    # From a constant
+    const_coeff = SymbolicCoefficient(1.23)
+
+    # From a variable name
+    var_coeff = SymbolicCoefficient("theta")
+
+    print(const_coeff)
+    print(var_coeff)
+    # [symbolic_init]
+
+    # [symbolic_ops]
+    a = SymbolicCoefficient("a")
+    b = SymbolicCoefficient("b")
+
+    # Perform standard arithmetic
+    expr = (a * 2 + b) / 3
+    print(f"Expression: {expr}")
+
+    # Use trigonometric functions
+    trig_expr = expr.cos()
+    print(f"Trigonometric Expression: {trig_expr}")
+    # [symbolic_ops]
+
+    # [symbolic_evaluate]
+    expression = SymbolicCoefficient("a") + SymbolicCoefficient("b")
+
+    # Evaluate fully by providing all variables
+    result = expression.evaluate({"a": 2.5, "b": 1.5})
+    print(f"Final scalar value: {result}")
+
+    # Partially evaluate by providing only some variables
+    partial_result = expression.symbolic_evaluate({"a": 2.5})
+    print(f"Partially evaluated expression: {partial_result}")
+    # [symbolic_evaluate]
+
+
+    # [symbolic_simplify]
+    x = SymbolicCoefficient("x")
+
+    # Create a redundant expression
+    expr = (x * 1 + 0) - (x * 0)
+    print(f"Original expression: {expr}")
+
+    # Simplify it
+    simplified_expr = expr.simplified()
+    print(f"Simplified expression: {simplified_expr}")
+    # [symbolic_simplify]

pyrauli-0.4.0/tests/snippets/test_symbolic_observable_guide.py

@@ -0,0 +1,46 @@
+
+def test_symbolic_observable_snippet():
+    # [symbolic_obs_init]
+    from pyrauli import SymbolicObservable, SymbolicPauliTerm
+
+    # From a single Pauli string with a symbolic coefficient
+    obs1 = SymbolicObservable("X", "a")
+    print(obs1)
+
+    # From a list of Pauli strings (default coefficient is 1.0)
+    obs2 = SymbolicObservable(["XX", "YY"])
+    print(obs2)
+
+    # From a list of PauliTerms with symbolic coefficients
+    obs3 = SymbolicObservable([
+        SymbolicPauliTerm("X", "a"),
+        SymbolicPauliTerm("Y", "b")
+    ])
+    print(obs3)
+    # [symbolic_obs_init]
+
+    # [symbolic_obs_simplify]
+    from pyrauli import SymbolicObservable, SymbolicPauliTerm
+
+    # Create an observable with redundant terms
+    obs = SymbolicObservable(["X", "X", "Y"])
+    obs.merge() # ['2.000 * X', '1.000 * Y']
+
+    # Add another term with a symbolic coefficient
+    obs = SymbolicObservable([
+        SymbolicPauliTerm("X", 2.0),
+        SymbolicPauliTerm("Y", 1.0),
+        SymbolicPauliTerm("X", "a")
+    ])
+
+    obs.merge()
+    print(f"Merged observable: {obs}")
+
+    # Simplify the coefficients
+    obs.simplify()
+    print(f"Simplified observable: {obs}")
+
+    # Simplify and substitute a variable
+    obs.simplify({"a": 3.0})
+    print(f"Simplified and substituted observable: {obs}")
+    # [symbolic_obs_simplify]

pyrauli-0.4.0/tests/snippets/test_symbolic_sympy.py

@@ -0,0 +1,24 @@
+# tests/snippets/test_symbolic_sympy.py
+from pyrauli import SymbolicCircuit, SymbolicObservable
+import pytest
+
+sympy = pytest.importorskip("sympy", reason="symbolic extra not installed")
+
+def test_sympy_snippet():
+    # [symbolic_sympy]
+    # Create and run a symbolic circuit as before
+    circuit = SymbolicCircuit(1)
+    circuit.add_operation("H", 0)
+    circuit.add_operation("Rz", 0, "theta")
+    circuit.add_operation("H", 0)
+    observable = SymbolicObservable("Z")
+    final_observable = circuit.run(observable)
+    symbolic_coeff = final_observable.expectation_value()
+
+    # Convert to a SymPy expression
+    sympy_expr = symbolic_coeff.to_sympy()
+
+    # Now you can use SymPy's features
+    theta = sympy.Symbol("theta")
+    print(sympy.diff(sympy_expr, theta))
+    # [symbolic_sympy]

pyrauli-0.4.0/tests/test_symbolic.py

@@ -0,0 +1,12 @@
+import pytest
+
+from pyrauli import SymbolicCoefficient, SymbolicObservable
+
+def test_coeff_ops():
+    x = SymbolicCoefficient(1.)
+    x *= 2.
+    x /= 2
+    x += 1
+    x -= 1
+    assert x.evaluate() == 1.
+

pyrauli-0.4.0/tests/test_symbolic_circuit.py

@@ -0,0 +1,61 @@
+from pyrauli import (
+    SymbolicCircuit,
+    SymbolicObservable,
+    SymbolicNoiseModel,
+    SymbolicWeightTruncator,
+    UnitalNoise,
+    QGate
+)
+import pytest
+
+
+def test_init():
+    SymbolicCircuit(2)
+    SymbolicCircuit(2, truncator=SymbolicWeightTruncator(1))
+
+
+def test_add_operations():
+    circuit = SymbolicCircuit(2)
+    circuit.add_operation("H", 0)
+    circuit.add_operation("CX", 0, 1)
+    circuit.add_operation("Rz", 1, "theta")
+
+
+def test_run_symbolic():
+    circuit = SymbolicCircuit(1)
+    circuit.add_operation("H", 0)
+    circuit.add_operation("Rz", 0, "theta")
+    circuit.add_operation("H", 0)
+
+    obs = SymbolicObservable("Z")
+    final_obs = circuit.run(obs)
+
+    assert final_obs.expectation_value().evaluate({"theta": 0}) == pytest.approx(1.0)
+    assert final_obs.expectation_value().evaluate({"theta": 3.14159}) == pytest.approx(
+        -1.0
+    )
+
+
+def test_with_noise():
+    noise = SymbolicNoiseModel()
+    noise.add_unital_noise_on_gate(QGate.H, UnitalNoise.Depolarizing, "p")
+
+    circuit = SymbolicCircuit(1, noise_model=noise)
+    circuit.add_operation("H", 0)
+
+    obs = SymbolicObservable("X")
+    final_obs = circuit.run(obs)
+
+    # With no noise, H|X> = |Z>, EV = 1
+    assert final_obs.expectation_value().evaluate({"p": 0}) == pytest.approx(1.0)
+    # With full depolarizing, state is mixed, EV = 0
+    assert final_obs.expectation_value().evaluate({"p": 1.0}) == pytest.approx(0.0)
+
+
+def test_reset():
+    circuit = SymbolicCircuit(1)
+    circuit.add_operation("H", 0)
+    circuit.reset()
+    obs = SymbolicObservable("Z")
+    final_obs = circuit.run(obs)
+    assert final_obs[0] == obs[0]

pyrauli-0.4.0/tests/test_symbolic_coefficient.py

@@ -0,0 +1,76 @@
+import pytest
+from pyrauli import SymbolicCoefficient
+from math import pi, cos, sin, sqrt
+import sympy
+
+
+def test_init():
+    assert SymbolicCoefficient(1.0).to_string() == "1.000"
+    assert SymbolicCoefficient("x").to_string() == "x"
+
+
+def test_to_string():
+    assert SymbolicCoefficient(1.234567).to_string("{:.2f}") == "1.23"
+    x = SymbolicCoefficient("x")
+    expr = x * 2 + 3
+    assert expr.to_string() == "(x * 2.000) + 3.000"
+
+
+def test_evaluate():
+    assert SymbolicCoefficient(1.0).evaluate() == 1.0
+    x = SymbolicCoefficient("x")
+    with pytest.raises(ValueError):
+        x.evaluate()  # Test for unbound variable
+    assert x.evaluate({"x": 2.0}) == 2.0
+
+
+def test_symbolic_evaluate():
+    x = SymbolicCoefficient("x")
+    y = SymbolicCoefficient("y")
+    expr = x + y
+    new_expr = expr.symbolic_evaluate({"x": 1})
+    assert new_expr.to_string() == "1.000 + y"
+    assert new_expr.evaluate({"y": 2}) == 3
+
+
+def test_unary_ops():
+    x = SymbolicCoefficient("x")
+    assert (-x).evaluate({"x": 1}) == -1
+    assert x.cos().evaluate({"x": 0}) == cos(0)
+    assert x.sin().evaluate({"x": pi / 2}) == sin(pi / 2)
+    assert x.sqrt().evaluate({"x": 4}) == sqrt(4)
+
+
+def test_binary_ops():
+    x = SymbolicCoefficient("x")
+    y = SymbolicCoefficient("y")
+    assert (x + y).evaluate({"x": 1, "y": 2}) == 3
+    assert (x - 3).evaluate({"x": 1}) == -2
+    assert (x * y).evaluate({"x": 2, "y": 3}) == 6
+    assert (4 / y).evaluate({"y": 2}) == 2
+
+
+def test_long_expression():
+    x = SymbolicCoefficient("x")
+    y = SymbolicCoefficient("y")
+    expr = 2 * (x + y) - (x / 3)
+    assert expr.evaluate({"x": 3, "y": 1}) == pytest.approx(7.0)
+
+
+def test_simplified():
+    x = SymbolicCoefficient("x")
+    expr = (x + 0) * 1
+    simplified_expr = expr.simplified()
+    assert simplified_expr.to_string() == "x"
+
+
+def test_to_sympy():
+    x = SymbolicCoefficient("x")
+    y = SymbolicCoefficient("y")
+    expr = 2 * (x + y)
+    sympy_expr = expr.to_sympy()
+
+    sx = sympy.Symbol("x")
+    sy = sympy.Symbol("y")
+
+    assert str(sympy_expr) == "2.0*x + 2.0*y"

pyrauli-0.4.0/tests/test_symbolic_observable.py

@@ -0,0 +1,88 @@
+import pytest
+from pyrauli import (
+    SymbolicObservable,
+    SymbolicCoefficient,
+    SymbolicPauliTerm,
+    SymbolicWeightTruncator,
+    PauliGate,
+    CliffordGate,
+    UnitalNoise,
+)
+from math import pi
+
+
+def test_init():
+    SymbolicObservable("IXYZ")
+    SymbolicObservable("IXYZ", SymbolicCoefficient("a"))
+    SymbolicObservable(["IXYZ", "ZZZZ"])
+    SymbolicObservable([SymbolicPauliTerm("X", "a"), SymbolicPauliTerm("Z", "b")])
+
+
+def test_apply_pauli():
+    obs = SymbolicObservable("X")
+    obs.apply_pauli(PauliGate.Z, 0)
+    assert str(obs[0]) == "1 * -1 X"
+
+
+def test_apply_clifford():
+    obs = SymbolicObservable("X")
+    obs.apply_clifford(CliffordGate.H, 0)
+    assert str(obs[0]) == "1 * 1 Z"
+
+
+def test_apply_cx():
+    obs = SymbolicObservable("IX")
+    obs.apply_cx(0, 1)
+    assert str(obs[0]) == "1 * 1 IX"
+
+
+def test_apply_rz():
+    obs = SymbolicObservable("X")
+    obs.apply_rz(0, "theta")
+    assert obs.size() == 2
+    assert str(obs[0]) == "1 * cos(theta) X"
+    assert str(obs[1]) == "1 * -sin(theta) Y"
+
+
+def test_apply_unital_noise():
+    obs = SymbolicObservable("X")
+    obs.apply_unital_noise(UnitalNoise.Depolarizing, 0, "p")
+    assert str(obs[0].coefficient.simplified()) == "1 - p"
+
+
+def test_apply_amplitude_damping():
+    obs = SymbolicObservable("Z")
+    obs.apply_amplitude_damping(0, "p")
+    assert obs.size() == 2
+
+
+def test_expectation_value():
+    obs = SymbolicObservable("Z")
+    assert obs.expectation_value().evaluate() == 1
+    obs = SymbolicObservable("X", "a")
+    assert obs.expectation_value().evaluate({"a": 1}) == 0
+
+
+def test_merge():
+    obs = SymbolicObservable([SymbolicPauliTerm("X", "a"), SymbolicPauliTerm("X", "a")])
+    obs.merge()
+    obs.simplify()
+    assert obs.size() == 1
+    assert obs[0].coefficient.to_string() == "a + a"
+
+
+def test_truncate():
+    obs = SymbolicObservable([SymbolicPauliTerm("X", 0.1), SymbolicPauliTerm("Y", 0.9)])
+    truncator = SymbolicWeightTruncator(0)  # Removes all non-identity
+    obs.truncate(truncator)
+    assert obs.size() == 0
+
+
+def test_simplify():
+    obs = SymbolicObservable([SymbolicPauliTerm("X", "a"), SymbolicPauliTerm("X", 1.0)])
+    obs.merge()
+    assert obs[0].coefficient.to_string() == "a + 1.000"
+    obs.simplify()
+    assert obs[0].coefficient.to_string() == "1.000 + a"  # No change
+    obs.simplify({"a": 2.0})
+    assert obs[0].coefficient.to_string() == "3.000"