qiskit 2.1.0rc1__tar.gz → 2.1.1__tar.gz

{qiskit-2.1.0rc1 → qiskit-2.1.1}/Cargo.lock

@@ -1457,7 +1457,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-accelerate"
-version = "2.1.0-rc1"
+version = "2.1.1"
 dependencies = [
  "approx",
  "hashbrown 0.15.3",
@@ -1481,7 +1481,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-cext"
-version = "2.1.0-rc1"
+version = "2.1.1"
 dependencies = [
  "ahash 0.8.12",
  "cbindgen",
@@ -1499,7 +1499,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-circuit"
-version = "2.1.0-rc1"
+version = "2.1.1"
 dependencies = [
  "ahash 0.8.12",
  "approx",
@@ -1524,7 +1524,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-pyext"
-version = "2.1.0-rc1"
+version = "2.1.1"
 dependencies = [
  "pyo3",
  "qiskit-accelerate",
@@ -1539,7 +1539,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm2"
-version = "2.1.0-rc1"
+version = "2.1.1"
 dependencies = [
  "hashbrown 0.15.3",
  "num-bigint",
@@ -1549,7 +1549,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm3"
-version = "2.1.0-rc1"
+version = "2.1.1"
 dependencies = [
  "ahash 0.8.12",
  "hashbrown 0.15.3",
@@ -1565,7 +1565,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-quantum-info"
-version = "2.1.0-rc1"
+version = "2.1.1"
 dependencies = [
  "ahash 0.8.12",
  "approx",
@@ -1591,7 +1591,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-synthesis"
-version = "2.1.0-rc1"
+version = "2.1.1"
 dependencies = [
  "ahash 0.8.12",
  "approx",
@@ -1624,7 +1624,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-transpiler"
-version = "2.1.0-rc1"
+version = "2.1.1"
 dependencies = [
  "ahash 0.8.12",
  "approx",

{qiskit-2.1.0rc1 → qiskit-2.1.1}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "2.1.0-rc1"
+version = "2.1.1"
 edition = "2021"
 rust-version = "1.79"  # Keep in sync with README.md, rust-toolchain.toml, and tools/install_rust_msrv.sh
 license = "Apache-2.0"

{qiskit-2.1.0rc1 → qiskit-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qiskit
-Version: 2.1.0rc1
+Version: 2.1.1
 Summary: An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.
 Author-email: Qiskit Development Team <qiskit@us.ibm.com>
 License: Apache 2.0

{qiskit-2.1.0rc1 → qiskit-2.1.1}/crates/cext/cbindgen.toml

@@ -13,7 +13,7 @@ after_includes = """
 
 #define QISKIT_VERSION_MAJOR 2
 #define QISKIT_VERSION_MINOR 1
-#define QISKIT_VERSION_PATCH 0
+#define QISKIT_VERSION_PATCH 1
 
 #define QISKIT_VERSION_NUMERIC(M,m,p) ((M)<<16|(m)<<8|(p))
 #define QISKIT_VERSION (QISKIT_VERSION_MAJOR<<16 | QISKIT_VERSION_MINOR<<8 | QISKIT_VERSION_PATCH)

{qiskit-2.1.0rc1 → qiskit-2.1.1}/crates/cext/include/complex.h

@@ -21,7 +21,8 @@ static std::complex<double> qk_complex64_to_native(QkComplex64 *value) {
     return std::complex<double>(value->re, value->im);
 }
 static QkComplex64 qk_complex64_from_native(std::complex<double> *value) {
-    return (QkComplex64){value->real(), value->imag()};
+    QkComplex64 ret = {value->real(), value->imag()};
+    return ret;
 }
 #else //__cplusplus
 #include <complex.h>

{qiskit-2.1.0rc1 → qiskit-2.1.1}/crates/circuit/src/dag_circuit.rs

@@ -3333,7 +3333,8 @@ impl DAGCircuit {
         .collect()
     }
 
-    /// Returns iterator of the successors of a node as DAGOpNodes and DAGOutNodes."""
+    /// Returns iterator of the successors of a node as :class:`.DAGOpNode`\ s and
+    /// :class:`.DAGOutNode`\ s.
     fn successors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
         let successors: PyResult<Vec<_>> = self
             .dag
@@ -3348,7 +3349,8 @@ impl DAGCircuit {
             .unbind())
     }
 
-    /// Returns iterator of the predecessors of a node as DAGOpNodes and DAGInNodes.
+    /// Returns iterator of the predecessors of a node as :class:`.DAGOpNode`\ s and
+    /// :class:`.DAGInNode`\ s.
     fn predecessors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
         let predecessors: PyResult<Vec<_>> = self
             .dag
@@ -3460,7 +3462,11 @@ impl DAGCircuit {
             .unbind())
     }
 
-    /// Returns set of the ancestors of a node as DAGOpNodes and DAGInNodes.
+    /// Returns set of the ancestors of a node as :class:`.DAGOpNode`\ s and :class:`.DAGInNode`\ s.
+    ///
+    /// The ancestors are the set of all nodes that can reach the target node. Whereas the
+    /// :meth:`.DAGCircuit.predecessors` only contains the immediate predecessors, the ancestors
+    /// recursively contain the predecessors of each predecessor.
     #[pyo3(name = "ancestors")]
     fn py_ancestors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PySet>> {
         let ancestors: PyResult<Vec<PyObject>> = self
@@ -3470,7 +3476,11 @@ impl DAGCircuit {
         Ok(PySet::new(py, &ancestors?)?.unbind())
     }
 
-    /// Returns set of the descendants of a node as DAGOpNodes and DAGOutNodes.
+    /// Returns set of the descendants of a node as :class:`.DAGOpNode`\ s and :class:`.DAGOutNode`\ s.
+    ///
+    /// The descendants are the set of all nodes that can be reached from the target node. In
+    /// comparison, :meth:`.DAGCircuit.successors` is an iterator over the immediate successors,
+    /// whereas this method contains all the successors' succesors.
     #[pyo3(name = "descendants")]
     fn py_descendants(&self, py: Python, node: &DAGNode) -> PyResult<Py<PySet>> {
         let descendants: PyResult<Vec<PyObject>> = self
@@ -3480,8 +3490,8 @@ impl DAGCircuit {
         Ok(PySet::new(py, &descendants?)?.unbind())
     }
 
-    /// Returns an iterator of tuples of (DAGNode, [DAGNodes]) where the DAGNode is the current node
-    /// and [DAGNode] is its successors in  BFS order.
+    /// Returns an iterator of tuples of ``(DAGNode, [DAGNodes])`` where the ``DAGNode`` is the
+    /// current node and ``[DAGNodes]`` is a list of the successors in BFS order.
     #[pyo3(name = "bfs_successors")]
     fn py_bfs_successors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
         let successor_index: PyResult<Vec<(PyObject, Vec<PyObject>)>> = self

{qiskit-2.1.0rc1 → qiskit-2.1.1}/crates/circuit/src/parameter_expression.rs

@@ -21,6 +21,7 @@ use num_complex::Complex64;
 use std::collections::hash_map::DefaultHasher;
 use std::fmt;
 use std::hash::{Hash, Hasher};
+use std::sync::Arc;
 
 use pyo3::prelude::*;
 use pyo3::IntoPyObjectExt;
@@ -84,7 +85,7 @@ impl ParameterExpression {
             .replace("__end_sympy_replace__", "$");
 
         ParameterExpression {
-            expr: SymbolExpr::Symbol(Box::new(name)),
+            expr: SymbolExpr::Symbol(Arc::new(name)),
         }
     }
 

{qiskit-2.1.0rc1 → qiskit-2.1.1}/crates/circuit/src/symbol_expr.rs

@@ -10,15 +10,16 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
-/// symbol_expr.rs
-/// symbolic expression engine for parameter expression
-use core::f64;
+//! symbol_expr.rs
+//! symbolic expression engine for parameter expression
+
 use hashbrown::{HashMap, HashSet};
 use std::cmp::Ordering;
 use std::cmp::PartialOrd;
 use std::convert::From;
 use std::fmt;
 use std::ops::{Add, Div, Mul, Neg, Sub};
+use std::sync::Arc;
 
 use num_complex::Complex64;
 
@@ -28,16 +29,16 @@ pub const SYMEXPR_EPSILON: f64 = f64::EPSILON * 8.0;
 /// node types of expression tree
 #[derive(Debug, Clone)]
 pub enum SymbolExpr {
-    Symbol(Box<String>),
+    Symbol(Arc<String>),
     Value(Value),
     Unary {
         op: UnaryOp,
-        expr: Box<SymbolExpr>,
+        expr: Arc<SymbolExpr>,
     },
     Binary {
         op: BinaryOp,
-        lhs: Box<SymbolExpr>,
-        rhs: Box<SymbolExpr>,
+        lhs: Arc<SymbolExpr>,
+        rhs: Arc<SymbolExpr>,
     },
 }
 
@@ -83,20 +84,20 @@ fn _add(lhs: SymbolExpr, rhs: SymbolExpr) -> SymbolExpr {
         match rhs.neg_opt() {
             Some(e) => SymbolExpr::Binary {
                 op: BinaryOp::Sub,
-                lhs: Box::new(lhs),
-                rhs: Box::new(e),
+                lhs: Arc::new(lhs),
+                rhs: Arc::new(e),
             },
             None => SymbolExpr::Binary {
                 op: BinaryOp::Sub,
-                lhs: Box::new(lhs),
-                rhs: Box::new(_neg(rhs)),
+                lhs: Arc::new(lhs),
+                rhs: Arc::new(_neg(rhs)),
             },
         }
     } else {
         SymbolExpr::Binary {
             op: BinaryOp::Add,
-            lhs: Box::new(lhs),
-            rhs: Box::new(rhs),
+            lhs: Arc::new(lhs),
+            rhs: Arc::new(rhs),
         }
     }
 }
@@ -108,20 +109,20 @@ fn _sub(lhs: SymbolExpr, rhs: SymbolExpr) -> SymbolExpr {
         match rhs.neg_opt() {
             Some(e) => SymbolExpr::Binary {
                 op: BinaryOp::Add,
-                lhs: Box::new(lhs),
-                rhs: Box::new(e),
+                lhs: Arc::new(lhs),
+                rhs: Arc::new(e),
             },
             None => SymbolExpr::Binary {
                 op: BinaryOp::Add,
-                lhs: Box::new(lhs),
-                rhs: Box::new(_neg(rhs)),
+                lhs: Arc::new(lhs),
+                rhs: Arc::new(_neg(rhs)),
             },
         }
     } else {
         SymbolExpr::Binary {
             op: BinaryOp::Sub,
-            lhs: Box::new(lhs),
-            rhs: Box::new(rhs),
+            lhs: Arc::new(lhs),
+            rhs: Arc::new(rhs),
         }
     }
 }
@@ -131,8 +132,8 @@ fn _sub(lhs: SymbolExpr, rhs: SymbolExpr) -> SymbolExpr {
 fn _mul(lhs: SymbolExpr, rhs: SymbolExpr) -> SymbolExpr {
     SymbolExpr::Binary {
         op: BinaryOp::Mul,
-        lhs: Box::new(lhs),
-        rhs: Box::new(rhs),
+        lhs: Arc::new(lhs),
+        rhs: Arc::new(rhs),
     }
 }
 
@@ -141,8 +142,8 @@ fn _mul(lhs: SymbolExpr, rhs: SymbolExpr) -> SymbolExpr {
 fn _div(lhs: SymbolExpr, rhs: SymbolExpr) -> SymbolExpr {
     SymbolExpr::Binary {
         op: BinaryOp::Div,
-        lhs: Box::new(lhs),
-        rhs: Box::new(rhs),
+        lhs: Arc::new(lhs),
+        rhs: Arc::new(rhs),
     }
 }
 
@@ -151,8 +152,8 @@ fn _div(lhs: SymbolExpr, rhs: SymbolExpr) -> SymbolExpr {
 fn _pow(lhs: SymbolExpr, rhs: SymbolExpr) -> SymbolExpr {
     SymbolExpr::Binary {
         op: BinaryOp::Pow,
-        lhs: Box::new(lhs),
-        rhs: Box::new(rhs),
+        lhs: Arc::new(lhs),
+        rhs: Arc::new(rhs),
     }
 }
 
@@ -163,7 +164,7 @@ fn _neg(expr: SymbolExpr) -> SymbolExpr {
         Some(e) => e,
         None => SymbolExpr::Unary {
             op: UnaryOp::Neg,
-            expr: Box::new(expr),
+            expr: Arc::new(expr),
         },
     }
 }
@@ -359,7 +360,7 @@ impl SymbolExpr {
             SymbolExpr::Value(e) => SymbolExpr::Value(*e),
             SymbolExpr::Unary { op, expr } => SymbolExpr::Unary {
                 op: op.clone(),
-                expr: Box::new(expr.bind(maps)),
+                expr: Arc::new(expr.bind(maps)),
             },
             SymbolExpr::Binary { op, lhs, rhs } => {
                 let new_lhs = lhs.bind(maps);
@@ -385,7 +386,7 @@ impl SymbolExpr {
             SymbolExpr::Value(e) => SymbolExpr::Value(*e),
             SymbolExpr::Unary { op, expr } => SymbolExpr::Unary {
                 op: op.clone(),
-                expr: Box::new(expr.subs(maps)),
+                expr: Arc::new(expr.subs(maps)),
             },
             SymbolExpr::Binary { op, lhs, rhs } => {
                 let new_lhs = lhs.subs(maps);
@@ -506,16 +507,16 @@ impl SymbolExpr {
                         UnaryOp::Abs => Ok(&(expr.as_ref() * &expr_d)
                             / &SymbolExpr::Unary {
                                 op: op.clone(),
-                                expr: Box::new(expr.as_ref().clone()),
+                                expr: Arc::new(expr.as_ref().clone()),
                             }),
                         UnaryOp::Neg => Ok(SymbolExpr::Unary {
                             op: UnaryOp::Neg,
-                            expr: Box::new(expr_d),
+                            expr: Arc::new(expr_d),
                         }),
                         UnaryOp::Sin => {
                             let lhs = SymbolExpr::Unary {
                                 op: UnaryOp::Cos,
-                                expr: Box::new(expr.as_ref().clone()),
+                                expr: Arc::new(expr.as_ref().clone()),
                             };
                             Ok(lhs * expr_d)
                         }
@@ -531,7 +532,7 @@ impl SymbolExpr {
                         UnaryOp::Cos => {
                             let lhs = SymbolExpr::Unary {
                                 op: UnaryOp::Sin,
-                                expr: Box::new(expr.as_ref().clone()),
+                                expr: Arc::new(expr.as_ref().clone()),
                             };
                             Ok(&-&lhs * &expr_d)
                         }
@@ -547,7 +548,7 @@ impl SymbolExpr {
                         UnaryOp::Tan => {
                             let d = SymbolExpr::Unary {
                                 op: UnaryOp::Cos,
-                                expr: Box::new(expr.as_ref().clone()),
+                                expr: Arc::new(expr.as_ref().clone()),
                             };
                             Ok(&(&expr_d / &d) / &d)
                         }
@@ -558,7 +559,7 @@ impl SymbolExpr {
                         }
                         UnaryOp::Exp => Ok(&SymbolExpr::Unary {
                             op: UnaryOp::Exp,
-                            expr: Box::new(expr.as_ref().clone()),
+                            expr: Arc::new(expr.as_ref().clone()),
                         } * &expr_d),
                         UnaryOp::Log => Ok(&expr_d / expr.as_ref()),
                         UnaryOp::Sign => {
@@ -588,12 +589,12 @@ impl SymbolExpr {
                                 Ok(_mul(
                                     SymbolExpr::Binary {
                                         op: BinaryOp::Pow,
-                                        lhs: Box::new(lhs.as_ref().clone()),
-                                        rhs: Box::new(rhs.as_ref().clone()),
+                                        lhs: Arc::new(lhs.as_ref().clone()),
+                                        rhs: Arc::new(rhs.as_ref().clone()),
                                     },
                                     SymbolExpr::Unary {
                                         op: UnaryOp::Log,
-                                        expr: Box::new(lhs.as_ref().clone()),
+                                        expr: Arc::new(lhs.as_ref().clone()),
                                     },
                                 ))
                             }
@@ -601,18 +602,18 @@ impl SymbolExpr {
                             Ok(rhs.as_ref()
                                 * &SymbolExpr::Binary {
                                     op: BinaryOp::Pow,
-                                    lhs: Box::new(lhs.as_ref().clone()),
-                                    rhs: Box::new(
+                                    lhs: Arc::new(lhs.as_ref().clone()),
+                                    rhs: Arc::new(
                                         rhs.as_ref() - &SymbolExpr::Value(Value::Real(1.0)),
                                     ),
                                 })
                         } else {
                             let new_expr = SymbolExpr::Unary {
                                 op: UnaryOp::Exp,
-                                expr: Box::new(_mul(
+                                expr: Arc::new(_mul(
                                     SymbolExpr::Unary {
                                         op: UnaryOp::Log,
-                                        expr: Box::new(lhs.as_ref().clone()),
+                                        expr: Arc::new(lhs.as_ref().clone()),
                                     },
                                     rhs.as_ref().clone(),
                                 )),
@@ -639,7 +640,7 @@ impl SymbolExpr {
                     },
                     _ => SymbolExpr::Unary {
                         op: op.clone(),
-                        expr: Box::new(ex),
+                        expr: Arc::new(ex),
                     },
                 }
             }
@@ -671,7 +672,7 @@ impl SymbolExpr {
     pub fn sign(&self) -> SymbolExpr {
         SymbolExpr::Unary {
             op: UnaryOp::Sign,
-            expr: Box::new(self.clone()),
+            expr: Arc::new(self.clone()),
         }
     }
 
@@ -778,8 +779,8 @@ impl SymbolExpr {
             SymbolExpr::Binary { op, lhs, rhs } => match op {
                 BinaryOp::Div => SymbolExpr::Binary {
                     op: op.clone(),
-                    lhs: Box::new(*rhs.clone()),
-                    rhs: Box::new(*lhs.clone()),
+                    lhs: rhs.clone(),
+                    rhs: lhs.clone(),
                 },
                 _ => _div(SymbolExpr::Value(Value::Real(1.0)), self.clone()),
             },
@@ -798,7 +799,7 @@ impl SymbolExpr {
         match self {
             SymbolExpr::Symbol(_) => SymbolExpr::Unary {
                 op: UnaryOp::Conj,
-                expr: Box::new(self.clone()),
+                expr: Arc::new(self.clone()),
             },
             SymbolExpr::Value(e) => match e {
                 Value::Complex(c) => SymbolExpr::Value(Value::Complex(c.conj())),
@@ -806,12 +807,12 @@ impl SymbolExpr {
             },
             SymbolExpr::Unary { op, expr } => SymbolExpr::Unary {
                 op: op.clone(),
-                expr: Box::new(expr.conjugate()),
+                expr: Arc::new(expr.conjugate()),
             },
             SymbolExpr::Binary { op, lhs, rhs } => SymbolExpr::Binary {
                 op: op.clone(),
-                lhs: Box::new(lhs.conjugate()),
-                rhs: Box::new(rhs.conjugate()),
+                lhs: Arc::new(lhs.conjugate()),
+                rhs: Arc::new(rhs.conjugate()),
             },
         }
     }
@@ -902,7 +903,7 @@ impl SymbolExpr {
             } => expr.abs(),
             _ => SymbolExpr::Unary {
                 op: UnaryOp::Abs,
-                expr: Box::new(self.clone()),
+                expr: Arc::new(self.clone()),
             },
         }
     }
@@ -911,7 +912,7 @@ impl SymbolExpr {
             SymbolExpr::Value(l) => SymbolExpr::Value(l.sin()),
             _ => SymbolExpr::Unary {
                 op: UnaryOp::Sin,
-                expr: Box::new(self.clone()),
+                expr: Arc::new(self.clone()),
             },
         }
     }
@@ -920,7 +921,7 @@ impl SymbolExpr {
             SymbolExpr::Value(l) => SymbolExpr::Value(l.asin()),
             _ => SymbolExpr::Unary {
                 op: UnaryOp::Asin,
-                expr: Box::new(self.clone()),
+                expr: Arc::new(self.clone()),
             },
         }
     }
@@ -929,7 +930,7 @@ impl SymbolExpr {
             SymbolExpr::Value(l) => SymbolExpr::Value(l.cos()),
             _ => SymbolExpr::Unary {
                 op: UnaryOp::Cos,
-                expr: Box::new(self.clone()),
+                expr: Arc::new(self.clone()),
             },
         }
     }
@@ -938,7 +939,7 @@ impl SymbolExpr {
             SymbolExpr::Value(l) => SymbolExpr::Value(l.acos()),
             _ => SymbolExpr::Unary {
                 op: UnaryOp::Acos,
-                expr: Box::new(self.clone()),
+                expr: Arc::new(self.clone()),
             },
         }
     }
@@ -947,7 +948,7 @@ impl SymbolExpr {
             SymbolExpr::Value(l) => SymbolExpr::Value(l.tan()),
             _ => SymbolExpr::Unary {
                 op: UnaryOp::Tan,
-                expr: Box::new(self.clone()),
+                expr: Arc::new(self.clone()),
             },
         }
     }
@@ -956,7 +957,7 @@ impl SymbolExpr {
             SymbolExpr::Value(l) => SymbolExpr::Value(l.atan()),
             _ => SymbolExpr::Unary {
                 op: UnaryOp::Atan,
-                expr: Box::new(self.clone()),
+                expr: Arc::new(self.clone()),
             },
         }
     }
@@ -965,7 +966,7 @@ impl SymbolExpr {
             SymbolExpr::Value(l) => SymbolExpr::Value(l.exp()),
             _ => SymbolExpr::Unary {
                 op: UnaryOp::Exp,
-                expr: Box::new(self.clone()),
+                expr: Arc::new(self.clone()),
             },
         }
     }
@@ -974,7 +975,7 @@ impl SymbolExpr {
             SymbolExpr::Value(l) => SymbolExpr::Value(l.log()),
             _ => SymbolExpr::Unary {
                 op: UnaryOp::Log,
-                expr: Box::new(self.clone()),
+                expr: Arc::new(self.clone()),
             },
         }
     }
@@ -984,14 +985,14 @@ impl SymbolExpr {
                 SymbolExpr::Value(r) => SymbolExpr::Value(l.pow(r)),
                 _ => SymbolExpr::Binary {
                     op: BinaryOp::Pow,
-                    lhs: Box::new(SymbolExpr::Value(*l)),
-                    rhs: Box::new(rhs.clone()),
+                    lhs: Arc::new(SymbolExpr::Value(*l)),
+                    rhs: Arc::new(rhs.clone()),
                 },
             },
             _ => SymbolExpr::Binary {
                 op: BinaryOp::Pow,
-                lhs: Box::new(self.clone()),
-                rhs: Box::new(rhs.clone()),
+                lhs: Arc::new(self.clone()),
+                rhs: Arc::new(rhs.clone()),
             },
         }
     }
@@ -1765,7 +1766,7 @@ impl SymbolExpr {
                         SymbolExpr::Value(v) => Some(_mul(SymbolExpr::Value(-v), self.clone())),
                         SymbolExpr::Symbol(s) => {
                             if s < e {
-                                Some(_neg(_mul(*expr.clone(), self.clone())))
+                                Some(_neg(_mul(expr.as_ref().clone(), self.clone())))
                             } else {
                                 Some(_neg(_mul(self.clone(), expr.as_ref().clone())))
                             }
@@ -1796,11 +1797,11 @@ impl SymbolExpr {
                         } => match expr.mul_opt(rexpr, recursive) {
                             Some(e) => Some(SymbolExpr::Unary {
                                 op: UnaryOp::Abs,
-                                expr: Box::new(e),
+                                expr: Arc::new(e),
                             }),
                             None => Some(SymbolExpr::Unary {
                                 op: UnaryOp::Abs,
-                                expr: Box::new(_mul(expr.as_ref().clone(), rexpr.as_ref().clone())),
+                                expr: Arc::new(_mul(expr.as_ref().clone(), rexpr.as_ref().clone())),
                             }),
                         },
                         _ => None,
@@ -2254,11 +2255,11 @@ impl SymbolExpr {
                         } => match expr.div_opt(rexpr, recursive) {
                             Some(e) => Some(SymbolExpr::Unary {
                                 op: UnaryOp::Abs,
-                                expr: Box::new(e),
+                                expr: Arc::new(e),
                             }),
                             None => Some(SymbolExpr::Unary {
                                 op: UnaryOp::Abs,
-                                expr: Box::new(_div(expr.as_ref().clone(), rexpr.as_ref().clone())),
+                                expr: Arc::new(_div(expr.as_ref().clone(), rexpr.as_ref().clone())),
                             }),
                         },
                         _ => None,
@@ -2515,7 +2516,7 @@ impl SymbolExpr {
                     },
                     _ => SymbolExpr::Unary {
                         op: op.clone(),
-                        expr: Box::new(opt),
+                        expr: Arc::new(opt),
                     },
                 }
             }
@@ -2552,12 +2553,12 @@ impl SymbolExpr {
             SymbolExpr::Value(e) => e.sympify(),
             SymbolExpr::Unary { op, expr } => SymbolExpr::Unary {
                 op: op.clone(),
-                expr: Box::new(expr.sympify()),
+                expr: Arc::new(expr.sympify()),
             },
             SymbolExpr::Binary { op, lhs, rhs } => SymbolExpr::Binary {
                 op: op.clone(),
-                lhs: Box::new(lhs.sympify()),
-                rhs: Box::new(rhs.sympify()),
+                lhs: Arc::new(lhs.sympify()),
+                rhs: Arc::new(rhs.sympify()),
             },
         }
     }
@@ -2786,7 +2787,7 @@ impl PartialOrd for SymbolExpr {
 
 impl From<&str> for SymbolExpr {
     fn from(v: &str) -> Self {
-        SymbolExpr::Symbol(Box::new(v.to_string()))
+        SymbolExpr::Symbol(Arc::new(v.to_string()))
     }
 }
 
@@ -3227,7 +3228,7 @@ impl Value {
                 SymbolExpr::Value(Value::Real(c.re)),
                 _mul(
                     SymbolExpr::Value(Value::Real(c.im)),
-                    SymbolExpr::Symbol(Box::new("I".to_string())),
+                    SymbolExpr::Symbol(Arc::new("I".to_string())),
                 ),
             ),
             _ => SymbolExpr::Value(*self),