qiskit 1.4.2__cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl → 1.4.3__cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl

qiskit/VERSION.txt

@@ -1 +1 @@
-1.4.2
+1.4.3

qiskit/circuit/duration.py

@@ -65,29 +65,29 @@ def convert_durations_to_dt(qc: QuantumCircuit, dt_in_sec: float, inplace=True):
 
     for instruction in circ.data:
         operation = instruction.operation
-        if operation.unit == "dt" or operation.duration is None:
+        if operation._unit == "dt" or operation._duration is None:
             continue
 
-        if not operation.unit.endswith("s"):
-            raise CircuitError(f"Invalid time unit: '{operation.unit}'")
+        if not operation._unit.endswith("s"):
+            raise CircuitError(f"Invalid time unit: '{operation._unit}'")
 
-        duration = operation.duration
-        if operation.unit != "s":
-            duration = apply_prefix(duration, operation.unit)
+        duration = operation._duration
+        if operation._unit != "s":
+            duration = apply_prefix(duration, operation._unit)
 
-        operation.duration = duration_in_dt(duration, dt_in_sec)
-        operation.unit = "dt"
+        operation._duration = duration_in_dt(duration, dt_in_sec)
+        operation._unit = "dt"
 
-    if circ.duration is not None and circ.unit != "dt":
-        if not circ.unit.endswith("s"):
-            raise CircuitError(f"Invalid time unit: '{circ.unit}'")
+    if circ._duration is not None and circ._unit != "dt":
+        if not circ._unit.endswith("s"):
+            raise CircuitError(f"Invalid time unit: '{circ._unit}'")
 
-        duration = circ.duration
-        if circ.unit != "s":
-            duration = apply_prefix(duration, circ.unit)
+        duration = circ._duration
+        if circ._unit != "s":
+            duration = apply_prefix(duration, circ._unit)
 
-        circ.duration = duration_in_dt(duration, dt_in_sec)
-        circ.unit = "dt"
+        circ._duration = duration_in_dt(duration, dt_in_sec)
+        circ._unit = "dt"
 
     if not inplace:
         return circ

qiskit/circuit/library/standard_gates/r.py

@@ -33,9 +33,10 @@ class RGate(Gate):
 
     .. code-block:: text
 
-             ┌──────┐
-        q_0: ┤ R(ϴ) ├
-             └──────┘
+               ┌─────────┐
+        q_0:   ┤ R(θ,ϕ)  ├ 
+               └─────────┘
+
 
     **Matrix Representation:**
 

qiskit/circuit/library/standard_gates/x.py

@@ -306,8 +306,7 @@ class CCXGate(SingletonControlledGate):
     r"""CCX gate, also known as Toffoli gate.
 
     Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
-    with the :meth:`~qiskit.circuit.QuantumCircuit.ccx` and
-    :meth:`~qiskit.circuit.QuantumCircuit.toffoli` methods.
+    with the :meth:`~qiskit.circuit.QuantumCircuit.ccx` method.
 
     **Circuit symbol:**
 

qiskit/circuit/quantumcircuit.py

@@ -1546,8 +1546,8 @@ class QuantumCircuit:
         for instruction in reversed(self.data):
             reverse_circ._append(instruction.replace(operation=instruction.operation.reverse_ops()))
 
-        reverse_circ.duration = self.duration
-        reverse_circ.unit = self.unit
+        reverse_circ._duration = self._duration
+        reverse_circ._unit = self._unit
         return reverse_circ
 
     def reverse_bits(self) -> "QuantumCircuit":
@@ -2620,8 +2620,8 @@ class QuantumCircuit:
         """
         if _standard_gate:
             self._data.append(instruction)
-            self.duration = None
-            self.unit = "dt"
+            self._duration = None
+            self._unit = "dt"
             return instruction
 
         old_style = not isinstance(instruction, CircuitInstruction)
@@ -2643,8 +2643,8 @@ class QuantumCircuit:
             self._data.append_manual_params(instruction, params)
 
         # Invalidate whole circuit duration if an instruction is added
-        self.duration = None
-        self.unit = "dt"
+        self._duration = None
+        self._unit = "dt"
         return instruction.operation if old_style else instruction
 
     @typing.overload
@@ -6584,7 +6584,7 @@ class QuantumCircuit:
         Raises:
             CircuitError: if ``self`` is a not-yet scheduled circuit.
         """
-        if self.duration is None:
+        if self._duration is None:
             # circuit has only delays, this is kind of scheduled
             for instruction in self._data:
                 if not isinstance(instruction.operation, Delay):
@@ -6626,7 +6626,7 @@ class QuantumCircuit:
         Raises:
             CircuitError: if ``self`` is a not-yet scheduled circuit.
         """
-        if self.duration is None:
+        if self._duration is None:
             # circuit has only delays, this is kind of scheduled
             for instruction in self._data:
                 if not isinstance(instruction.operation, Delay):
@@ -6637,7 +6637,7 @@ class QuantumCircuit:
 
         qubits = [self.qubits[q] if isinstance(q, int) else q for q in qubits]
 
-        stops = {q: self.duration for q in qubits}
+        stops = {q: self._duration for q in qubits}
         dones = {q: False for q in qubits}
         for instruction in reversed(self._data):
             for q in qubits:

qiskit/converters/circuit_to_dag.py

@@ -73,6 +73,6 @@ def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_ord
 
     dagcircuit = core_circuit_to_dag(circuit, copy_operations, qubit_order, clbit_order)
 
-    dagcircuit.duration = circuit._duration
-    dagcircuit.unit = circuit._unit
+    dagcircuit._duration = circuit._duration
+    dagcircuit._unit = circuit._unit
     return dagcircuit

qiskit/converters/dag_to_circuit.py

@@ -74,7 +74,6 @@ def dag_to_circuit(dag, copy_operations=True):
     circuit._calibrations_prop = dag._calibrations_prop
 
     circuit._data = circuit_data
-
-    circuit._duration = dag.duration
-    circuit._unit = dag.unit
+    circuit._duration = dag._duration
+    circuit._unit = dag._unit
     return circuit

qiskit/dagcircuit/dagdependency_v2.py

@@ -525,8 +525,6 @@ class _DAGDependencyV2:
         target_dag = _DAGDependencyV2()
         target_dag.name = self.name
         target_dag._global_phase = self._global_phase
-        target_dag.duration = self.duration
-        target_dag.unit = self.unit
         target_dag.metadata = self.metadata
         target_dag._key_cache = self._key_cache
         target_dag.comm_checker = self.comm_checker
@@ -534,6 +532,9 @@ class _DAGDependencyV2:
         target_dag.add_qubits(self.qubits)
         target_dag.add_clbits(self.clbits)
 
+        target_dag.duration = self.duration
+        target_dag.unit = self.unit
+
         for qreg in self.qregs.values():
             target_dag.add_qreg(qreg)
         for creg in self.cregs.values():

qiskit/primitives/statevector_estimator.py

@@ -33,7 +33,7 @@ class StatevectorEstimator(BaseEstimatorV2):
     Simple implementation of :class:`BaseEstimatorV2` with full state vector simulation.
 
     This class is implemented via :class:`~.Statevector` which turns provided circuits into
-    pure state vectors. These states are subsequently acted on by :class:~.SparsePauliOp`,
+    pure state vectors. These states are subsequently acted on by :class:`~.SparsePauliOp`,
     which implies that, at present, this implementation is only compatible with Pauli-based
     observables.
 

qiskit/qpy/binary_io/circuits.py

@@ -776,6 +776,11 @@ def _write_instruction(
         custom_operations[gate_class_name] = instruction.operation
         custom_operations_list.append(gate_class_name)
 
+    elif isinstance(instruction.operation, library.MCMTGate):
+        gate_class_name = instruction.operation.name + "_" + str(uuid.uuid4())
+        custom_operations[gate_class_name] = instruction.operation
+        custom_operations_list.append(gate_class_name)
+
     condition_type = type_keys.Condition.NONE
     condition_register = b""
     condition_value = 0

qiskit/synthesis/discrete_basis/commutator_decompose.py

@@ -53,16 +53,40 @@ def _compute_rotation_axis(matrix: np.ndarray) -> np.ndarray:
     """
     _check_is_so3(matrix)
 
+    # If theta represents the rotation angle, then trace = 1 + 2cos(theta).
     trace = _compute_trace_so3(matrix)
-    theta = math.acos(0.5 * (trace - 1))
-    if math.sin(theta) > 1e-10:
-        x = 1 / (2 * math.sin(theta)) * (matrix[2][1] - matrix[1][2])
-        y = 1 / (2 * math.sin(theta)) * (matrix[0][2] - matrix[2][0])
-        z = 1 / (2 * math.sin(theta)) * (matrix[1][0] - matrix[0][1])
-    else:
+
+    if trace >= 3 - 1e-10:
+        # The matrix is the identity (rotation by 0)
         x = 1.0
         y = 0.0
         z = 0.0
+
+    elif trace <= -1 + 1e-10:
+        # The matrix is the 180-degree rotation
+        squares = (1 + np.diagonal(matrix)) / 2
+        index_of_max = np.argmax(squares)
+
+        if index_of_max == 0:
+            x = math.sqrt(squares[0])
+            y = matrix[0][1] / (2 * x)
+            z = matrix[0][2] / (2 * x)
+        elif index_of_max == 1:
+            y = math.sqrt(squares[1])
+            x = matrix[0][1] / (2 * y)
+            z = matrix[1][2] / (2 * y)
+        else:
+            z = math.sqrt(squares[2])
+            x = matrix[0][2] / (2 * z)
+            y = matrix[1][2] / (2 * z)
+
+    else:
+        # The matrix is the rotation by theta with sin(theta)!=0
+        theta = math.acos(0.5 * (trace - 1))
+        x = 1 / (2 * math.sin(theta)) * (matrix[2][1] - matrix[1][2])
+        y = 1 / (2 * math.sin(theta)) * (matrix[0][2] - matrix[2][0])
+        z = 1 / (2 * math.sin(theta)) * (matrix[1][0] - matrix[0][1])
+
     return np.array([x, y, z])
 
 

qiskit/synthesis/discrete_basis/gate_sequence.py

@@ -55,7 +55,6 @@ class GateSequence:
         self.name = " ".join(self.labels)
         self.global_phase = global_phase
         self.product = so3_matrix
-        self.product_su2 = su2_matrix
 
     def remove_cancelling_pair(self, indices: Sequence[int]) -> None:
         """Remove a pair of indices that cancel each other and *do not* change the matrices."""
@@ -106,6 +105,16 @@ class GateSequence:
 
         return circuit
 
+    def _to_u2(self):
+        """Creates the U2 matrix corresponding to the stored sequence of gates
+        and the global phase.
+        """
+        u2 = np.eye(2, dtype=complex)
+        for mat in self.gates:
+            u2 = mat.to_matrix().dot(u2)
+        u2 = np.exp(1j * self.global_phase) * u2
+        return u2
+
     def to_dag(self):
         """Convert to a :class:`.DAGCircuit`.
 
@@ -149,7 +158,6 @@ class GateSequence:
         so3 = _convert_su2_to_so3(su2)
 
         self.product = so3.dot(self.product)
-        self.product_su2 = su2.dot(self.product_su2)
         self.global_phase = self.global_phase + phase
 
         self.gates.append(gate)
@@ -172,7 +180,6 @@ class GateSequence:
         adjoint.labels = [inv.name for inv in adjoint.gates]
         adjoint.name = " ".join(adjoint.labels)
         adjoint.product = np.conj(self.product).T
-        adjoint.product_su2 = np.conj(self.product_su2).T
         adjoint.global_phase = -self.global_phase
 
         return adjoint
@@ -190,7 +197,6 @@ class GateSequence:
         out.matrices = self.matrices.copy()
         out.global_phase = self.global_phase
         out.product = self.product.copy()
-        out.product_su2 = self.product_su2.copy()
         out.name = self.name
         out._eulers = self._eulers
         return out

qiskit/synthesis/discrete_basis/generate_basis_approximations.py

@@ -76,7 +76,7 @@ def _check_candidate_greedy(candidate, existing_sequences, tol=1e-10):
         return False
 
     for existing in existing_sequences:
-        if matrix_equal(existing.product_su2, candidate.product_su2, ignore_phase=True, atol=tol):
+        if matrix_equal(existing.product, candidate.product, ignore_phase=True, atol=tol):
             # is the new sequence less or more efficient?
             return len(candidate.gates) < len(existing.gates)
     return True

qiskit/synthesis/discrete_basis/solovay_kitaev.py

@@ -24,7 +24,7 @@ from .generate_basis_approximations import generate_basic_approximations, _1q_ga
 class SolovayKitaevDecomposition:
     """The Solovay Kitaev discrete decomposition algorithm.
 
-    This class is called recursively by the transpiler pass, which is why it is separeted.
+    This class is called recursively by the transpiler pass, which is why it is separated.
     See :class:`qiskit.transpiler.passes.SolovayKitaev` for more information.
     """
 
@@ -33,7 +33,7 @@ class SolovayKitaevDecomposition:
     ) -> None:
         """
         Args:
-            basic_approximations: A specification of the basic SU(2) approximations in terms
+            basic_approximations: A specification of the basic SO(3) approximations in terms
                 of discrete gates. At each iteration this algorithm, the remaining error is
                 approximated with the closest sequence of gates in this set.
                 If a ``str``, this specifies a ``.npy`` filename from which to load the
@@ -116,23 +116,33 @@ class SolovayKitaevDecomposition:
         """
         # make input matrix SU(2) and get the according global phase
         z = 1 / np.sqrt(np.linalg.det(gate_matrix))
-        gate_matrix_su2 = GateSequence.from_matrix(z * gate_matrix)
+
+        gate_matrix_su2 = z * gate_matrix
+        gate_matrix_as_sequence = GateSequence.from_matrix(gate_matrix_su2)
         global_phase = np.arctan2(np.imag(z), np.real(z))
 
         # get the decomposition as GateSequence type
-        decomposition = self._recurse(gate_matrix_su2, recursion_degree, check_input=check_input)
+        decomposition = self._recurse(
+            gate_matrix_as_sequence, recursion_degree, check_input=check_input
+        )
 
         # simplify
         _remove_identities(decomposition)
         _remove_inverse_follows_gate(decomposition)
 
+        # adjust to the correct SU(2) phase
+        adjust_phase = (
+            np.pi if _should_adjust_phase(decomposition._to_u2(), gate_matrix_su2) else 0.0
+        )
+
         # convert to a circuit and attach the right phases
         if return_dag:
             out = decomposition.to_dag()
         else:
             out = decomposition.to_circuit()
 
-        out.global_phase = decomposition.global_phase - global_phase
+        out.global_phase += adjust_phase
+        out.global_phase -= global_phase
 
         return out
 
@@ -155,17 +165,20 @@ class SolovayKitaevDecomposition:
             raise ValueError("Shape of U must be (3, 3) but is", sequence.shape)
 
         if n == 0:
-            return self.find_basic_approximation(sequence)
+            res = self.find_basic_approximation(sequence)
 
-        u_n1 = self._recurse(sequence, n - 1, check_input=check_input)
+        else:
+            u_n1 = self._recurse(sequence, n - 1, check_input=check_input)
 
-        v_n, w_n = commutator_decompose(
-            sequence.dot(u_n1.adjoint()).product, check_input=check_input
-        )
+            v_n, w_n = commutator_decompose(
+                sequence.dot(u_n1.adjoint()).product, check_input=check_input
+            )
+
+            v_n1 = self._recurse(v_n, n - 1, check_input=check_input)
+            w_n1 = self._recurse(w_n, n - 1, check_input=check_input)
+            res = v_n1.dot(w_n1).dot(v_n1.adjoint()).dot(w_n1.adjoint()).dot(u_n1)
 
-        v_n1 = self._recurse(v_n, n - 1, check_input=check_input)
-        w_n1 = self._recurse(w_n, n - 1, check_input=check_input)
-        return v_n1.dot(w_n1).dot(v_n1.adjoint()).dot(w_n1.adjoint()).dot(u_n1)
+        return res
 
     def find_basic_approximation(self, sequence: GateSequence) -> GateSequence:
         """Find ``GateSequence`` in ``self._basic_approximations`` that approximates ``sequence``.
@@ -215,3 +228,13 @@ def _remove_identities(sequence):
             sequence.gates.pop(index)
         else:
             index += 1
+
+
+def _should_adjust_phase(computed: np.ndarray, target: np.ndarray) -> bool:
+    """
+    The implemented SolovayKitaevDecomposition has a global phase uncertainty of +-1,
+    due to approximating not the original SU(2) matrix but its projection onto SO(3).
+    This function returns ``True`` if the global phase of the computed approximation
+    should be adjusted (by adding pi) to better much the target.
+    """
+    return np.linalg.norm(-computed - target) < np.linalg.norm(computed - target)

qiskit/transpiler/passes/layout/sabre_layout.py

@@ -305,6 +305,9 @@ class SabreLayout(TransformationPass):
         # the layout and routing together as part of resolving the Sabre result.
         physical_qubits = QuantumRegister(self.coupling_map.size(), "q")
         mapped_dag = DAGCircuit()
+        mapped_dag.name = dag.name
+        mapped_dag.metadata = dag.metadata
+        mapped_dag.global_phase = dag.global_phase
         mapped_dag.add_qreg(physical_qubits)
         mapped_dag.add_clbits(dag.clbits)
         for creg in dag.cregs.values():
@@ -315,7 +318,7 @@ class SabreLayout(TransformationPass):
             mapped_dag.add_captured_var(var)
         for var in dag.iter_declared_vars():
             mapped_dag.add_declared_var(var)
-        mapped_dag.global_phase = dag.global_phase
+
         self.property_set["original_qubit_indices"] = {
             bit: index for index, bit in enumerate(dag.qubits)
         }

qiskit/transpiler/passes/layout/vf2_utils.py

@@ -203,11 +203,8 @@ def build_average_error_map(target, properties, coupling_map):
         coupling_map = target.build_coupling_map()
     if not built and coupling_map is not None:
         for qubit in range(num_qubits):
-            avg_map.add_error(
-                (qubit, qubit),
-                (coupling_map.graph.out_degree(qubit) + coupling_map.graph.in_degree(qubit))
-                / num_qubits,
-            )
+            degree = len(set(coupling_map.graph.neighbors_undirected(qubit)))
+            avg_map.add_error((qubit, qubit), degree / num_qubits)
         for edge in coupling_map.graph.edge_list():
             avg_map.add_error(edge, (avg_map[edge[0], edge[0]] + avg_map[edge[1], edge[1]]) / 2)
             built = True

qiskit/transpiler/passes/scheduling/alap.py

@@ -147,7 +147,7 @@ class ALAPSchedule(BaseSchedulerTransform):
         new_dag._calibrations_prop = dag._calibrations_prop
 
         # set circuit duration and unit to indicate it is scheduled
-        new_dag.duration = circuit_duration
-        new_dag.unit = time_unit
+        new_dag._duration = circuit_duration
+        new_dag._unit = time_unit
 
         return new_dag

qiskit/transpiler/passes/scheduling/alignments/align_measures.py

@@ -129,7 +129,7 @@ class AlignMeasures(TransformationPass):
             return dag
 
         # if circuit is not yet scheduled, schedule with ALAP method
-        if dag.duration is None:
+        if dag._duration is None:
             raise TranspilerError(
                 f"This circuit {dag.name} may involve a delay instruction violating the "
                 "pulse controller alignment. To adjust instructions to "
@@ -201,8 +201,8 @@ class AlignMeasures(TransformationPass):
         new_dag.metadata = dag.metadata
 
         # set circuit duration and unit to indicate it is scheduled
-        new_dag.duration = circuit_duration
-        new_dag.unit = time_unit
+        new_dag._duration = circuit_duration
+        new_dag._unit = time_unit
 
         return new_dag
 

qiskit/transpiler/passes/scheduling/asap.py

@@ -170,6 +170,6 @@ class ASAPSchedule(BaseSchedulerTransform):
         new_dag._calibrations_prop = dag._calibrations_prop
 
         # set circuit duration and unit to indicate it is scheduled
-        new_dag.duration = circuit_duration
-        new_dag.unit = time_unit
+        new_dag._duration = circuit_duration
+        new_dag._unit = time_unit
         return new_dag

qiskit/transpiler/passes/scheduling/dynamical_decoupling.py

@@ -168,7 +168,7 @@ class DynamicalDecoupling(TransformationPass):
         if len(dag.qregs) != 1 or dag.qregs.get("q", None) is None:
             raise TranspilerError("DD runs on physical circuits only.")
 
-        if dag.duration is None:
+        if dag._duration is None:
             raise TranspilerError("DD runs after circuit is scheduled.")
 
         durations = self._update_inst_durations(dag)

qiskit/transpiler/passes/scheduling/padding/base_padding.py

@@ -98,7 +98,7 @@ class BasePadding(TransformationPass):
 
         new_dag.name = dag.name
         new_dag.metadata = dag.metadata
-        new_dag.unit = self.property_set["time_unit"]
+        new_dag._unit = self.property_set["time_unit"]
         new_dag._calibrations_prop = dag._calibrations_prop
         new_dag.global_phase = dag.global_phase
 
@@ -161,7 +161,7 @@ class BasePadding(TransformationPass):
                     prev_node=prev_node,
                 )
 
-        new_dag.duration = circuit_duration
+        new_dag._duration = circuit_duration
 
         return new_dag
 

qiskit/transpiler/passes/scheduling/padding/dynamical_decoupling.py

@@ -348,14 +348,14 @@ class PadDynamicalDecoupling(BasePadding):
 
         if not self.__is_dd_qubit(dag.qubits.index(qubit)):
             # Target physical qubit is not the target of this DD sequence.
-            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
             return
 
         if self._skip_reset_qubits and (
             isinstance(prev_node, DAGInNode) or isinstance(prev_node.op, Reset)
         ):
             # Previous node is the start edge or reset, i.e. qubit is ground state.
-            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
             return
 
         slack = time_interval - np.sum(self._dd_sequence_lengths[qubit])
@@ -363,7 +363,7 @@ class PadDynamicalDecoupling(BasePadding):
 
         if slack <= 0:
             # Interval too short.
-            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
             return
 
         if len(self._dd_sequence) == 1:
@@ -389,7 +389,7 @@ class PadDynamicalDecoupling(BasePadding):
                 sequence_gphase += phase
             else:
                 # Don't do anything if there's no single-qubit gate to absorb the inverse
-                self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+                self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
                 return
 
         def _constrained_length(values):
@@ -425,7 +425,7 @@ class PadDynamicalDecoupling(BasePadding):
             if dd_ind < len(taus):
                 tau = taus[dd_ind]
                 if tau > 0:
-                    self._apply_scheduled_op(dag, idle_after, Delay(tau, dag.unit), qubit)
+                    self._apply_scheduled_op(dag, idle_after, Delay(tau, dag._unit), qubit)
                     idle_after += tau
             if dd_ind < len(self._dd_sequence):
                 gate = self._dd_sequence[dd_ind]

qiskit/transpiler/passes/scheduling/padding/pad_delay.py

@@ -79,4 +79,4 @@ class PadDelay(BasePadding):
             return
 
         time_interval = t_end - t_start
-        self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+        self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)

qiskit/transpiler/passes/synthesis/solovay_kitaev_synthesis.py

@@ -201,7 +201,7 @@ class SolovayKitaevSynthesis(UnitarySynthesisPlugin):
 
     Supported parameters in the dictionary:
 
-    basis_approximations (str | dict):
+    basic_approximations (str | dict):
         The basic approximations for the finding the best discrete decomposition at the root of the
         recursion. If a string, it specifies the ``.npy`` file to load the approximations from.
         If a dictionary, it contains ``{label: SO(3)-matrix}`` pairs. If None, a default based on
@@ -209,19 +209,31 @@ class SolovayKitaevSynthesis(UnitarySynthesisPlugin):
 
     basis_gates (list):
         A list of strings specifying the discrete basis gates to decompose to. If None,
-        defaults to ``["h", "t", "tdg"]``.
+        it defaults to ``["h", "t", "tdg"]``. If ``basic_approximations`` is not None,
+        ``basis_set`` is required to correspond to the basis set that was used to
+        generate it.
 
     depth (int):
         The gate-depth of the basic approximations. All possible, unique combinations of the
         basis gates up to length ``depth`` are considered. If None, defaults to 10.
+        If ``basic_approximations`` is not None, ``depth`` is required to correspond to the
+        depth that was used to generate it.
 
     recursion_degree (int):
         The number of times the decomposition is recursively improved. If None, defaults to 3.
     """
 
-    # we cache an instance of the Solovay-Kitaev class to generate the
-    # computationally expensive basis approximation of single qubit gates only once
+    # Generating basic approximations of single-qubit gates is computationally expensive.
+    # We cache the instance of the Solovay-Kitaev class (which contains the approximations),
+    # as well as the basis gates and the depth (used to generate it).
+    # When the plugin is called again, we check if the specified basis gates and depth are
+    # the same as before. If so, the stored basic approximations are reused, and if not, the
+    # approximations are re-generated. In practice (when the plugin is run as a part of the
+    # UnitarySynthesis transpiler pass), the basis gates and the depth do not change, and
+    # basic approximations are not re-generated.
     _sk = None
+    _basis_gates = None
+    _depth = None
 
     @property
     def max_qubits(self):
@@ -271,27 +283,25 @@ class SolovayKitaevSynthesis(UnitarySynthesisPlugin):
         return False
 
     def run(self, unitary, **options):
+        """Run the SolovayKitaevSynthesis synthesis plugin on the given unitary."""
 
-        # Runtime imports to avoid the overhead of these imports for
-        # plugin discovery and only use them if the plugin is run/used
         config = options.get("config") or {}
-
+        basis_gates = options.get("basis_gates", ["h", "t", "tdg"])
+        depth = config.get("depth", 10)
+        basic_approximations = config.get("basic_approximations", None)
         recursion_degree = config.get("recursion_degree", 3)
 
-        # if we didn't yet construct the Solovay-Kitaev instance, which contains
-        # the basic approximations, do it now
-        if SolovayKitaevSynthesis._sk is None:
-            basic_approximations = config.get("basic_approximations", None)
-            basis_gates = options.get("basis_gates", ["h", "t", "tdg"])
-
-            # if the basic approximations are not generated and not given,
-            # try to generate them if the basis set is specified
+        # Check if we didn't yet construct the Solovay-Kitaev instance (which contains the basic
+        # approximations) or if the basic approximations need need to be recomputed.
+        if (SolovayKitaevSynthesis._sk is None) or (
+            (basis_gates != SolovayKitaevSynthesis._basis_gates)
+            or (depth != SolovayKitaevSynthesis._depth)
+        ):
             if basic_approximations is None:
-                depth = config.get("depth", 10)
                 basic_approximations = generate_basic_approximations(basis_gates, depth)
 
+            SolovayKitaevSynthesis._basis_gates = basis_gates
+            SolovayKitaevSynthesis._depth = depth
             SolovayKitaevSynthesis._sk = SolovayKitaevDecomposition(basic_approximations)
-
         approximate_circuit = SolovayKitaevSynthesis._sk.run(unitary, recursion_degree)
-        dag_circuit = circuit_to_dag(approximate_circuit)
-        return dag_circuit
+        return circuit_to_dag(approximate_circuit)