qiskit 1.3.1__tar.gz → 1.3.2__tar.gz

{qiskit-1.3.1 → qiskit-1.3.2}/Cargo.lock

@@ -1150,7 +1150,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-accelerate"
-version = "1.3.1"
+version = "1.3.2"
 dependencies = [
  "ahash 0.8.11",
  "approx 0.5.1",
@@ -1182,7 +1182,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-circuit"
-version = "1.3.1"
+version = "1.3.2"
 dependencies = [
  "ahash 0.8.11",
  "approx 0.5.1",
@@ -1202,7 +1202,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-pyext"
-version = "1.3.1"
+version = "1.3.2"
 dependencies = [
  "pyo3",
  "qiskit-accelerate",
@@ -1213,7 +1213,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm2"
-version = "1.3.1"
+version = "1.3.2"
 dependencies = [
  "hashbrown 0.14.5",
  "num-bigint",
@@ -1223,7 +1223,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm3"
-version = "1.3.1"
+version = "1.3.2"
 dependencies = [
  "ahash 0.8.11",
  "hashbrown 0.14.5",

{qiskit-1.3.1 → qiskit-1.3.2}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "1.3.1"
+version = "1.3.2"
 edition = "2021"
 rust-version = "1.70"  # Keep in sync with README.md and rust-toolchain.toml.
 license = "Apache-2.0"

{qiskit-1.3.1 → qiskit-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: qiskit
-Version: 1.3.1
+Version: 1.3.2
 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
@@ -94,7 +94,7 @@ To install from source, follow the instructions in the [documentation](https://d
 Now that Qiskit is installed, it's time to begin working with Qiskit. The essential parts of a quantum program are:
 1. Define and build a quantum circuit that represents the quantum state
 2. Define the classical output by measurements or a set of observable operators
-3. Depending on the output, use the primitive function `sampler` to sample outcomes or the `estimator` to estimate values.
+3. Depending on the output, use the Sampler primitive to sample outcomes or the Estimator primitive to estimate expectation values.
 
 Create an example quantum circuit using the `QuantumCircuit` class:
 
@@ -102,22 +102,22 @@ Create an example quantum circuit using the `QuantumCircuit` class:
 import numpy as np
 from qiskit import QuantumCircuit
 
-# 1. A quantum circuit for preparing the quantum state |000> + i |111>
-qc_example = QuantumCircuit(3)
-qc_example.h(0)          # generate superpostion
-qc_example.p(np.pi/2,0)  # add quantum phase
-qc_example.cx(0,1)       # 0th-qubit-Controlled-NOT gate on 1st qubit
-qc_example.cx(0,2)       # 0th-qubit-Controlled-NOT gate on 2nd qubit
+# 1. A quantum circuit for preparing the quantum state |000> + i |111> / √2
+qc = QuantumCircuit(3)
+qc.h(0)             # generate superposition
+qc.p(np.pi / 2, 0)  # add quantum phase
+qc.cx(0, 1)         # 0th-qubit-Controlled-NOT gate on 1st qubit
+qc.cx(0, 2)         # 0th-qubit-Controlled-NOT gate on 2nd qubit
 ```
 
-This simple example makes an entangled state known as a [GHZ state](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state) $(|000\rangle + i|111\rangle)/\sqrt{2}$. It uses the standard quantum gates: Hadamard gate (`h`), Phase gate (`p`), and CNOT gate (`cx`). 
+This simple example creates an entangled state known as a [GHZ state](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state) $(|000\rangle + i|111\rangle)/\sqrt{2}$. It uses the standard quantum gates: Hadamard gate (`h`), Phase gate (`p`), and CNOT gate (`cx`). 
 
-Once you've made your first quantum circuit, choose which primitive function you will use. Starting with `sampler`,
+Once you've made your first quantum circuit, choose which primitive you will use. Starting with the Sampler,
 we use `measure_all(inplace=False)` to get a copy of the circuit in which all the qubits are measured:
 
 ```python
 # 2. Add the classical output in the form of measurement of all qubits
-qc_measured = qc_example.measure_all(inplace=False)
+qc_measured = qc.measure_all(inplace=False)
 
 # 3. Execute using the Sampler primitive
 from qiskit.primitives import StatevectorSampler
@@ -127,7 +127,7 @@ result = job.result()
 print(f" > Counts: {result[0].data["meas"].get_counts()}")
 ```
 Running this will give an outcome similar to `{'000': 497, '111': 503}` which is `000` 50% of the time and `111` 50% of the time up to statistical fluctuations.
-To illustrate the power of Estimator, we now use the quantum information toolbox to create the operator $XXY+XYX+YXX-YYY$ and pass it to the `run()` function, along with our quantum circuit. Note the Estimator requires a circuit _**without**_ measurement, so we use the `qc_example` circuit we created earlier.
+To illustrate the power of the Estimator, we now use the quantum information toolbox to create the operator $XXY+XYX+YXX-YYY$ and pass it to the `run()` function, along with our quantum circuit. Note that the Estimator requires a circuit _**without**_ measurements, so we use the `qc` circuit we created earlier.
 
 ```python
 # 2. Define the observable to be measured 
@@ -137,7 +137,7 @@ operator = SparsePauliOp.from_list([("XXY", 1), ("XYX", 1), ("YXX", 1), ("YYY",
 # 3. Execute using the Estimator primitive
 from qiskit.primitives import StatevectorEstimator
 estimator = StatevectorEstimator()
-job = estimator.run([(qc_example, operator)], precision=1e-3)
+job = estimator.run([(qc, operator)], precision=1e-3)
 result = job.result()
 print(f" > Expectation values: {result[0].data.evs}")
 ```
@@ -150,17 +150,17 @@ The power of quantum computing cannot be simulated on classical computers and yo
 However, running a quantum circuit on hardware requires rewriting to the basis gates and connectivity of the quantum hardware.
 The tool that does this is the [transpiler](https://docs.quantum.ibm.com/api/qiskit/transpiler), and Qiskit includes transpiler passes for synthesis, optimization, mapping, and scheduling.
 However, it also includes a default compiler, which works very well in most examples.
-The following code will map the example circuit to the `basis_gates = ['cz', 'sx', 'rz']` and a linear chain of qubits $0 \rightarrow 1 \rightarrow 2$ with the `coupling_map =[[0, 1], [1, 2]]`.
+The following code will map the example circuit to the `basis_gates = ["cz", "sx", "rz"]` and a linear chain of qubits $0 \rightarrow 1 \rightarrow 2$ with the `coupling_map = [[0, 1], [1, 2]]`.
 
 ```python
 from qiskit import transpile
-qc_transpiled = transpile(qc_example, basis_gates = ['cz', 'sx', 'rz'], coupling_map =[[0, 1], [1, 2]] , optimization_level=3)
+qc_transpiled = transpile(qc, basis_gates=["cz", "sx", "rz"], coupling_map=[[0, 1], [1, 2]], optimization_level=3)
 ```
 
 ### Executing your code on real quantum hardware
 
 Qiskit provides an abstraction layer that lets users run quantum circuits on hardware from any vendor that provides a compatible interface. 
-The best way to use Qiskit is with a runtime environment that provides optimized implementations of `sampler` and `estimator` for a given hardware platform. This runtime may involve using pre- and post-processing, such as optimized transpiler passes with error suppression, error mitigation, and, eventually, error correction built in. A runtime implements `qiskit.primitives.BaseSamplerV2` and `qiskit.primitives.BaseEstimatorV2` interfaces. For example,
+The best way to use Qiskit is with a runtime environment that provides optimized implementations of Sampler and Estimator for a given hardware platform. This runtime may involve using pre- and post-processing, such as optimized transpiler passes with error suppression, error mitigation, and, eventually, error correction built in. A runtime implements `qiskit.primitives.BaseSamplerV2` and `qiskit.primitives.BaseEstimatorV2` interfaces. For example,
 some packages that provide implementations of a runtime primitive implementation are:
 
 * https://github.com/Qiskit/qiskit-ibm-runtime

{qiskit-1.3.1 → qiskit-1.3.2}/README.md

@@ -40,7 +40,7 @@ To install from source, follow the instructions in the [documentation](https://d
 Now that Qiskit is installed, it's time to begin working with Qiskit. The essential parts of a quantum program are:
 1. Define and build a quantum circuit that represents the quantum state
 2. Define the classical output by measurements or a set of observable operators
-3. Depending on the output, use the primitive function `sampler` to sample outcomes or the `estimator` to estimate values.
+3. Depending on the output, use the Sampler primitive to sample outcomes or the Estimator primitive to estimate expectation values.
 
 Create an example quantum circuit using the `QuantumCircuit` class:
 
@@ -48,22 +48,22 @@ Create an example quantum circuit using the `QuantumCircuit` class:
 import numpy as np
 from qiskit import QuantumCircuit
 
-# 1. A quantum circuit for preparing the quantum state |000> + i |111>
-qc_example = QuantumCircuit(3)
-qc_example.h(0)          # generate superpostion
-qc_example.p(np.pi/2,0)  # add quantum phase
-qc_example.cx(0,1)       # 0th-qubit-Controlled-NOT gate on 1st qubit
-qc_example.cx(0,2)       # 0th-qubit-Controlled-NOT gate on 2nd qubit
+# 1. A quantum circuit for preparing the quantum state |000> + i |111> / √2
+qc = QuantumCircuit(3)
+qc.h(0)             # generate superposition
+qc.p(np.pi / 2, 0)  # add quantum phase
+qc.cx(0, 1)         # 0th-qubit-Controlled-NOT gate on 1st qubit
+qc.cx(0, 2)         # 0th-qubit-Controlled-NOT gate on 2nd qubit
 ```
 
-This simple example makes an entangled state known as a [GHZ state](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state) $(|000\rangle + i|111\rangle)/\sqrt{2}$. It uses the standard quantum gates: Hadamard gate (`h`), Phase gate (`p`), and CNOT gate (`cx`). 
+This simple example creates an entangled state known as a [GHZ state](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state) $(|000\rangle + i|111\rangle)/\sqrt{2}$. It uses the standard quantum gates: Hadamard gate (`h`), Phase gate (`p`), and CNOT gate (`cx`). 
 
-Once you've made your first quantum circuit, choose which primitive function you will use. Starting with `sampler`,
+Once you've made your first quantum circuit, choose which primitive you will use. Starting with the Sampler,
 we use `measure_all(inplace=False)` to get a copy of the circuit in which all the qubits are measured:
 
 ```python
 # 2. Add the classical output in the form of measurement of all qubits
-qc_measured = qc_example.measure_all(inplace=False)
+qc_measured = qc.measure_all(inplace=False)
 
 # 3. Execute using the Sampler primitive
 from qiskit.primitives import StatevectorSampler
@@ -73,7 +73,7 @@ result = job.result()
 print(f" > Counts: {result[0].data["meas"].get_counts()}")
 ```
 Running this will give an outcome similar to `{'000': 497, '111': 503}` which is `000` 50% of the time and `111` 50% of the time up to statistical fluctuations.
-To illustrate the power of Estimator, we now use the quantum information toolbox to create the operator $XXY+XYX+YXX-YYY$ and pass it to the `run()` function, along with our quantum circuit. Note the Estimator requires a circuit _**without**_ measurement, so we use the `qc_example` circuit we created earlier.
+To illustrate the power of the Estimator, we now use the quantum information toolbox to create the operator $XXY+XYX+YXX-YYY$ and pass it to the `run()` function, along with our quantum circuit. Note that the Estimator requires a circuit _**without**_ measurements, so we use the `qc` circuit we created earlier.
 
 ```python
 # 2. Define the observable to be measured 
@@ -83,7 +83,7 @@ operator = SparsePauliOp.from_list([("XXY", 1), ("XYX", 1), ("YXX", 1), ("YYY",
 # 3. Execute using the Estimator primitive
 from qiskit.primitives import StatevectorEstimator
 estimator = StatevectorEstimator()
-job = estimator.run([(qc_example, operator)], precision=1e-3)
+job = estimator.run([(qc, operator)], precision=1e-3)
 result = job.result()
 print(f" > Expectation values: {result[0].data.evs}")
 ```
@@ -96,17 +96,17 @@ The power of quantum computing cannot be simulated on classical computers and yo
 However, running a quantum circuit on hardware requires rewriting to the basis gates and connectivity of the quantum hardware.
 The tool that does this is the [transpiler](https://docs.quantum.ibm.com/api/qiskit/transpiler), and Qiskit includes transpiler passes for synthesis, optimization, mapping, and scheduling.
 However, it also includes a default compiler, which works very well in most examples.
-The following code will map the example circuit to the `basis_gates = ['cz', 'sx', 'rz']` and a linear chain of qubits $0 \rightarrow 1 \rightarrow 2$ with the `coupling_map =[[0, 1], [1, 2]]`.
+The following code will map the example circuit to the `basis_gates = ["cz", "sx", "rz"]` and a linear chain of qubits $0 \rightarrow 1 \rightarrow 2$ with the `coupling_map = [[0, 1], [1, 2]]`.
 
 ```python
 from qiskit import transpile
-qc_transpiled = transpile(qc_example, basis_gates = ['cz', 'sx', 'rz'], coupling_map =[[0, 1], [1, 2]] , optimization_level=3)
+qc_transpiled = transpile(qc, basis_gates=["cz", "sx", "rz"], coupling_map=[[0, 1], [1, 2]], optimization_level=3)
 ```
 
 ### Executing your code on real quantum hardware
 
 Qiskit provides an abstraction layer that lets users run quantum circuits on hardware from any vendor that provides a compatible interface. 
-The best way to use Qiskit is with a runtime environment that provides optimized implementations of `sampler` and `estimator` for a given hardware platform. This runtime may involve using pre- and post-processing, such as optimized transpiler passes with error suppression, error mitigation, and, eventually, error correction built in. A runtime implements `qiskit.primitives.BaseSamplerV2` and `qiskit.primitives.BaseEstimatorV2` interfaces. For example,
+The best way to use Qiskit is with a runtime environment that provides optimized implementations of Sampler and Estimator for a given hardware platform. This runtime may involve using pre- and post-processing, such as optimized transpiler passes with error suppression, error mitigation, and, eventually, error correction built in. A runtime implements `qiskit.primitives.BaseSamplerV2` and `qiskit.primitives.BaseEstimatorV2` interfaces. For example,
 some packages that provide implementations of a runtime primitive implementation are:
 
 * https://github.com/Qiskit/qiskit-ibm-runtime

{qiskit-1.3.1 → qiskit-1.3.2}/crates/accelerate/src/circuit_library/pauli_evolution.rs

@@ -192,22 +192,22 @@ fn multi_qubit_evolution(
 /// followed by a CX-chain and then a single Pauli-Z rotation on the last qubit. Then the CX-chain
 /// is uncomputed and the inverse basis transformation applied. E.g. for the evolution under the
 /// Pauli string XIYZ we have the circuit
-///                 ┌───┐┌───────┐┌───┐
-/// 0: ─────────────┤ X ├┤ Rz(2) ├┤ X ├───────────
-///    ┌──────┐┌───┐└─┬─┘└───────┘└─┬─┘┌───┐┌────┐
-/// 1: ┤ √Xdg ├┤ X ├──■─────────────■──┤ X ├┤ √X ├
-///    └──────┘└─┬─┘                   └─┬─┘└────┘
-/// 2: ──────────┼───────────────────────┼────────
-///     ┌───┐    │                       │  ┌───┐
-/// 3: ─┤ H ├────■───────────────────────■──┤ H ├─
-///     └───┘                               └───┘
+///
+///        ┌───┐      ┌───┐┌───────┐┌───┐┌───┐
+///     0: ┤ H ├──────┤ X ├┤ Rz(2) ├┤ X ├┤ H ├────────
+///        └───┘      └─┬─┘└───────┘└─┬─┘└───┘
+///     1: ─────────────┼─────────────┼───────────────
+///        ┌────┐┌───┐  │             │  ┌───┐┌──────┐
+///     2: ┤ √X ├┤ X ├──■─────────────■──┤ X ├┤ √Xdg ├
+///        └────┘└─┬─┘                   └─┬─┘└──────┘
+///     3: ────────■───────────────────────■──────────
 ///
 /// Args:
 ///     num_qubits: The number of qubits in the Hamiltonian.
 ///     sparse_paulis: The Paulis to implement. Given in a sparse-list format with elements
-///         ``(pauli_string, qubit_indices, coefficient)``. An element of the form
-///         ``("IXYZ", [0,1,2,3], 0.2)``, for example, is interpreted in terms of qubit indices as
-///          I_q0 X_q1 Y_q2 Z_q3 and will use a RZ rotation angle of 0.4.
+///         ``(pauli_string, qubit_indices, rz_rotation_angle)``. An element of the form
+///         ``("XIYZ", [0,1,2,3], 2)``, for example, is interpreted in terms of qubit indices as
+///         X_q0 I_q1 Y_q2 Z_q3 and will use a RZ rotation angle of 2.
 ///     insert_barriers: If ``true``, insert a barrier in between the evolution of individual
 ///         Pauli terms.
 ///     do_fountain: If ``true``, implement the CX propagation as "fountain" shape, where each
@@ -244,7 +244,7 @@ pub fn py_pauli_evolution(
         }
 
         paulis.push(pauli);
-        times.push(time); // note we do not multiply by 2 here, this is done Python side!
+        times.push(time); // note we do not multiply by 2 here, this is already done Python side!
         indices.push(tuple.get_item(1)?.extract::<Vec<u32>>()?)
     }
 
@@ -266,12 +266,12 @@ pub fn py_pauli_evolution(
         },
     );
 
-    // When handling all-identity Paulis above, we added the time as global phase.
-    // However, the all-identity Paulis should add a negative phase, as they implement
-    // exp(-i t I). We apply the negative sign here, to only do a single (-1) multiplication,
-    // instead of doing it every time we find an all-identity Pauli.
+    // When handling all-identity Paulis above, we added the RZ rotation angle as global phase,
+    // meaning that we have implemented of exp(i 2t I). However, what we want it to implement
+    // exp(-i t I). To only use a single multiplication, we apply a factor of -0.5 here.
+    // This is faster, in particular as long as the parameter expressions are in Python.
     if modified_phase {
-        global_phase = multiply_param(&global_phase, -1.0, py);
+        global_phase = multiply_param(&global_phase, -0.5, py);
     }
 
     CircuitData::from_packed_operations(py, num_qubits as u32, 0, evos, global_phase)

{qiskit-1.3.1 → qiskit-1.3.2}/crates/accelerate/src/commutation_checker.rs

@@ -28,14 +28,19 @@ use qiskit_circuit::circuit_instruction::{ExtraInstructionAttributes, OperationF
 use qiskit_circuit::dag_node::DAGOpNode;
 use qiskit_circuit::imports::QI_OPERATOR;
 use qiskit_circuit::operations::OperationRef::{Gate as PyGateType, Operation as PyOperationType};
-use qiskit_circuit::operations::{Operation, OperationRef, Param, StandardGate};
+use qiskit_circuit::operations::{
+    get_standard_gate_names, Operation, OperationRef, Param, StandardGate,
+};
 use qiskit_circuit::{BitType, Clbit, Qubit};
 
 use crate::unitary_compose;
 use crate::QiskitError;
 
+// These gates do not commute with other gates, we do not check them.
 static SKIPPED_NAMES: [&str; 4] = ["measure", "reset", "delay", "initialize"];
-static NO_CACHE_NAMES: [&str; 2] = ["annotated", "linear_function"];
+
+// We keep a hash-set of operations eligible for commutation checking. This is because checking
+// eligibility is not for free.
 static SUPPORTED_OP: Lazy<HashSet<&str>> = Lazy::new(|| {
     HashSet::from([
         "rxx", "ryy", "rzz", "rzx", "h", "x", "y", "z", "sx", "sxdg", "t", "tdg", "s", "sdg", "cx",
@@ -43,25 +48,38 @@ static SUPPORTED_OP: Lazy<HashSet<&str>> = Lazy::new(|| {
     ])
 });
 
-const TWOPI: f64 = 2.0 * std::f64::consts::PI;
-
-// map rotation gates to their generators, or to ``None`` if we cannot currently efficiently
-// represent the generator in Rust and store the commutation relation in the commutation dictionary
-static SUPPORTED_ROTATIONS: Lazy<HashMap<&str, Option<OperationRef>>> = Lazy::new(|| {
+// Map rotation gates to their generators (or to ``None`` if we cannot currently efficiently
+// represent the generator in Rust and store the commutation relation in the commutation dictionary)
+// and their pi-periodicity. Here we mean a gate is n-pi periodic, if for angles that are
+// multiples of n*pi, the gate is equal to the identity up to a global phase.
+// E.g. RX is generated by X and 2-pi periodic, while CRX is generated by CX and 4-pi periodic.
+static SUPPORTED_ROTATIONS: Lazy<HashMap<&str, (u8, Option<OperationRef>)>> = Lazy::new(|| {
     HashMap::from([
-        ("rx", Some(OperationRef::Standard(StandardGate::XGate))),
-        ("ry", Some(OperationRef::Standard(StandardGate::YGate))),
-        ("rz", Some(OperationRef::Standard(StandardGate::ZGate))),
-        ("p", Some(OperationRef::Standard(StandardGate::ZGate))),
-        ("u1", Some(OperationRef::Standard(StandardGate::ZGate))),
-        ("crx", Some(OperationRef::Standard(StandardGate::CXGate))),
-        ("cry", Some(OperationRef::Standard(StandardGate::CYGate))),
-        ("crz", Some(OperationRef::Standard(StandardGate::CZGate))),
-        ("cp", Some(OperationRef::Standard(StandardGate::CZGate))),
-        ("rxx", None), // None means the gate is in the commutation dictionary
-        ("ryy", None),
-        ("rzx", None),
-        ("rzz", None),
+        ("rx", (2, Some(OperationRef::Standard(StandardGate::XGate)))),
+        ("ry", (2, Some(OperationRef::Standard(StandardGate::YGate)))),
+        ("rz", (2, Some(OperationRef::Standard(StandardGate::ZGate)))),
+        ("p", (2, Some(OperationRef::Standard(StandardGate::ZGate)))),
+        ("u1", (2, Some(OperationRef::Standard(StandardGate::ZGate)))),
+        ("rxx", (2, None)), // None means the gate is in the commutation dictionary
+        ("ryy", (2, None)),
+        ("rzx", (2, None)),
+        ("rzz", (2, None)),
+        (
+            "crx",
+            (4, Some(OperationRef::Standard(StandardGate::CXGate))),
+        ),
+        (
+            "cry",
+            (4, Some(OperationRef::Standard(StandardGate::CYGate))),
+        ),
+        (
+            "crz",
+            (4, Some(OperationRef::Standard(StandardGate::CZGate))),
+        ),
+        (
+            "cp",
+            (2, Some(OperationRef::Standard(StandardGate::CZGate))),
+        ),
     ])
 });
 
@@ -322,15 +340,17 @@ impl CommutationChecker {
             (qargs1, qargs2)
         };
 
-        let skip_cache: bool = NO_CACHE_NAMES.contains(&first_op.name()) ||
-            NO_CACHE_NAMES.contains(&second_op.name()) ||
-            // Skip params that do not evaluate to floats for caching and commutation library
-            first_params.iter().any(|p| !matches!(p, Param::Float(_))) ||
-            second_params.iter().any(|p| !matches!(p, Param::Float(_)))
-            && !SUPPORTED_OP.contains(op1.name())
-            && !SUPPORTED_OP.contains(op2.name());
-
-        if skip_cache {
+        // For our cache to work correctly, we require the gate's definition to only depend on the
+        // ``params`` attribute. This cannot be guaranteed for custom gates, so we only check
+        // the cache for our standard gates, which we know are defined by the ``params`` AND
+        // that the ``params`` are float-only at this point.
+        let whitelist = get_standard_gate_names();
+        let check_cache = whitelist.contains(&first_op.name())
+            && whitelist.contains(&second_op.name())
+            && first_params.iter().all(|p| matches!(p, Param::Float(_)))
+            && second_params.iter().all(|p| matches!(p, Param::Float(_)));
+
+        if !check_cache {
             return self.commute_matmul(
                 py,
                 first_op,
@@ -629,22 +649,27 @@ fn map_rotation<'a>(
     tol: f64,
 ) -> (&'a OperationRef<'a>, &'a [Param], bool) {
     let name = op.name();
-    if let Some(generator) = SUPPORTED_ROTATIONS.get(name) {
-        // if the rotation angle is below the tolerance, the gate is assumed to
+
+    if let Some((pi_multiple, generator)) = SUPPORTED_ROTATIONS.get(name) {
+        // If the rotation angle is below the tolerance, the gate is assumed to
         // commute with everything, and we simply return the operation with the flag that
-        // it commutes trivially
+        // it commutes trivially.
         if let Param::Float(angle) = params[0] {
-            if (angle % TWOPI).abs() < tol {
+            let periodicity = (*pi_multiple as f64) * ::std::f64::consts::PI;
+            if (angle % periodicity).abs() < tol {
                 return (op, params, true);
             };
         };
 
-        // otherwise, we check if a generator is given -- if not, we'll just return the operation
-        // itself (e.g. RXX does not have a generator and is just stored in the commutations
-        // dictionary)
+        // Otherwise we need to cover two cases -- either a generator is given, in which case
+        // we return it, or we don't have a generator yet, but we know we have the operation
+        // stored in the commutation library. For example, RXX does not have a generator in Rust
+        // yet (PauliGate is not in Rust currently), but it is stored in the library, so we
+        // can strip the parameters and just return the gate.
         if let Some(gate) = generator {
             return (gate, &[], false);
         };
+        return (op, &[], false);
     }
     (op, params, false)
 }

{qiskit-1.3.1 → qiskit-1.3.2}/crates/accelerate/src/synthesis/evolution/pauli_network.rs

@@ -211,7 +211,7 @@ fn inject_rotations(
         if pauli_support_size == 0 {
             // in case of an all-identity rotation, update global phase by subtracting
             // the angle
-            global_phase = radd_param(global_phase, multiply_param(&angles[i], -1.0, py), py);
+            global_phase = radd_param(global_phase, multiply_param(&angles[i], -0.5, py), py);
             hit_paulis[i] = true;
             dag.remove_node(i);
         } else if pauli_support_size == 1 && dag.is_front_node(i) {

{qiskit-1.3.1 → qiskit-1.3.2}/crates/accelerate/src/target_transpiler/mod.rs

@@ -1151,6 +1151,12 @@ impl Target {
 
     /// Checks whether an instruction is supported by the Target based on instruction name and qargs.
     pub fn instruction_supported(&self, operation_name: &str, qargs: Option<&Qargs>) -> bool {
+        // Handle case where num_qubits is None by checking globally supported operations
+        let qargs: Option<&Qargs> = if self.num_qubits.is_none() {
+            None
+        } else {
+            qargs
+        };
         if self.gate_map.contains_key(operation_name) {
             if let Some(_qargs) = qargs {
                 let qarg_set: HashSet<&PhysicalQubit> = _qargs.iter().collect();

{qiskit-1.3.1 → qiskit-1.3.2}/crates/accelerate/src/unitary_synthesis.rs

@@ -372,7 +372,8 @@ fn py_run_main_loop(
                     None,
                     None,
                 )?;
-                out_dag = synth_dag;
+                let out_qargs = dag.get_qargs(packed_instr.qubits);
+                apply_synth_dag(py, &mut out_dag, out_qargs, &synth_dag)?;
             }
         }
     }
@@ -544,6 +545,7 @@ fn get_2q_decomposers_from_target(
     let mut available_2q_props: IndexMap<&str, (Option<f64>, Option<f64>)> = IndexMap::new();
 
     let mut qubit_gate_map = IndexMap::new();
+
     match target.operation_names_for_qargs(Some(&qubits)) {
         Ok(direct_keys) => {
             qubit_gate_map.insert(&qubits, direct_keys);
@@ -596,7 +598,10 @@ fn get_2q_decomposers_from_target(
                         OperationRef::Standard(_) => (),
                         _ => continue,
                     }
-
+                    // Filter out non-2q-gate candidates
+                    if op.operation.num_qubits() != 2 {
+                        continue;
+                    }
                     available_2q_basis.insert(key, replace_parametrized_gate(op.clone()));
 
                     if target.contains_key(key) {

{qiskit-1.3.1 → qiskit-1.3.2}/crates/circuit/src/operations.rs

@@ -431,6 +431,11 @@ static STANDARD_GATE_NAME: [&str; STANDARD_GATE_SIZE] = [
     "rcccx",        // 51 ("rc3x")
 ];
 
+/// Get a slice of all standard gate names.
+pub fn get_standard_gate_names() -> &'static [&'static str] {
+    &STANDARD_GATE_NAME
+}
+
 impl StandardGate {
     pub fn create_py_op(
         &self,
@@ -2340,8 +2345,14 @@ pub fn add_param(param: &Param, summand: f64, py: Python) -> Param {
 }
 
 pub fn radd_param(param1: Param, param2: Param, py: Python) -> Param {
-    match [param1, param2] {
+    match [&param1, &param2] {
         [Param::Float(theta), Param::Float(lambda)] => Param::Float(theta + lambda),
+        [Param::Float(theta), Param::ParameterExpression(_lambda)] => {
+            add_param(&param2, *theta, py)
+        }
+        [Param::ParameterExpression(_theta), Param::Float(lambda)] => {
+            add_param(&param1, *lambda, py)
+        }
         [Param::ParameterExpression(theta), Param::ParameterExpression(lambda)] => {
             Param::ParameterExpression(
                 theta

qiskit-1.3.2/qiskit/VERSION.txt

@@ -0,0 +1 @@
+1.3.2

{qiskit-1.3.1 → qiskit-1.3.2}/qiskit/circuit/__init__.py

@@ -64,6 +64,7 @@ defined as:
 
 
 .. plot::
+   :alt: Circuit diagram output by the previous code.
    :include-source:
 
    from qiskit import QuantumCircuit
@@ -1140,6 +1141,7 @@ If we draw this circuit, we will see that Qiskit places the zeroth qubit on the
 drawing:
 
 .. plot::
+    :alt: Circuit diagram output by the previous code.
     :include-source:
     :context:
     :show-source-link: False

{qiskit-1.3.1 → qiskit-1.3.2}/qiskit/circuit/controlledgate.py

@@ -70,6 +70,7 @@ class ControlledGate(Gate):
         Create a controlled standard gate and apply it to a circuit.
 
         .. plot::
+           :alt: Circuit diagram output by the previous code.
            :include-source:
 
            from qiskit import QuantumCircuit, QuantumRegister
@@ -84,6 +85,7 @@ class ControlledGate(Gate):
         Create a controlled custom gate and apply it to a circuit.
 
         .. plot::
+           :alt: Circuit diagram output by the previous code.
            :include-source:
 
            from qiskit import QuantumCircuit, QuantumRegister

{qiskit-1.3.1 → qiskit-1.3.2}/qiskit/circuit/library/__init__.py

@@ -26,6 +26,7 @@ method and so the circuit library allows users to program at higher levels of ab
 For example, to append a multi-controlled CNOT:
 
 .. plot::
+   :alt: Circuit diagram output by the previous code.
    :include-source:
 
    from qiskit.circuit.library import MCXGate

{qiskit-1.3.1 → qiskit-1.3.2}/qiskit/circuit/library/arithmetic/piecewise_chebyshev.py

@@ -37,6 +37,7 @@ class PiecewiseChebyshev(BlueprintCircuit):
     Examples:
 
         .. plot::
+           :alt: Circuit diagram output by the previous code.
            :include-source:
 
             import numpy as np

{qiskit-1.3.1 → qiskit-1.3.2}/qiskit/circuit/library/basis_change/qft.py

@@ -38,6 +38,7 @@ class QFT(BlueprintCircuit):
     For 4 qubits, the circuit that implements this transformation is:
 
     .. plot::
+       :alt: Diagram illustrating the previously described circuit.
 
        from qiskit.circuit.library import QFT
        from qiskit.visualization.library import _generate_circuit_library_visualization
@@ -48,6 +49,7 @@ class QFT(BlueprintCircuit):
     The respective circuit diagram is:
 
     .. plot::
+       :alt: Diagram illustrating the previously described circuit.
 
        from qiskit.circuit.library import QFT
        from qiskit.visualization.library import _generate_circuit_library_visualization
@@ -64,6 +66,7 @@ class QFT(BlueprintCircuit):
     on 5 qubits with approximation degree 2 yields (the barriers are dropped in this example):
 
     .. plot::
+       :alt: Diagram illustrating the previously described circuit.
 
        from qiskit.circuit.library import QFT
        from qiskit.visualization.library import _generate_circuit_library_visualization

{qiskit-1.3.1 → qiskit-1.3.2}/qiskit/circuit/library/boolean_logic/inner_product.py

@@ -55,6 +55,7 @@ class InnerProduct(QuantumCircuit):
 
     Reference Circuit:
         .. plot::
+           :alt: Diagram illustrating the previously described circuit.
 
            from qiskit.circuit.library import InnerProduct
            from qiskit.visualization.library import _generate_circuit_library_visualization
@@ -121,6 +122,7 @@ class InnerProductGate(Gate):
 
     Reference Circuit:
         .. plot::
+           :alt: Diagram illustrating the previously described circuit.
 
            from qiskit.circuit import QuantumCircuit
            from qiskit.circuit.library import InnerProductGate