qiskit 1.3.0rc1__tar.gz → 1.3.0rc2__tar.gz

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qiskit
-Version: 1.3.0rc1
+Version: 1.3.0rc2
 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-1.3.0rc1 → qiskit-1.3.0rc2}/crates/accelerate/src/circuit_library/pauli_evolution.rs

@@ -254,12 +254,7 @@ pub fn py_pauli_evolution(
         |(((i, pauli), qubits), time)| {
             let as_packed = pauli_evolution(pauli, qubits, time, false, do_fountain).map(
                 |(gate, params, qubits)| -> PyResult<Instruction> {
-                    Ok((
-                        gate.into(),
-                        params,
-                        Vec::from_iter(qubits.into_iter()),
-                        Vec::new(),
-                    ))
+                    Ok((gate.into(), params, Vec::from_iter(qubits), Vec::new()))
                 },
             );
 
@@ -294,7 +289,7 @@ pub fn py_pauli_evolution(
 ///     q_3: ┤ X ├──■───────
 ///          └─┬─┘
 ///     q_4: ──■────────────
-///     
+///
 fn cx_chain(
     active_paulis: Vec<(char, Qubit)>,
 ) -> Box<dyn DoubleEndedIterator<Item = StandardInstruction>> {
@@ -308,17 +303,17 @@ fn cx_chain(
 
 /// Build a CX fountain over the active qubits. E.g. with q_1 inactive, this would return
 ///
-////         ┌───┐┌───┐┌───┐
-////    q_0: ┤ X ├┤ X ├┤ X ├
-////         └─┬─┘└─┬─┘└─┬─┘
-////    q_1: ──┼────┼────┼──
-////           │    │    │
-////    q_2: ──■────┼────┼──
-////                │    │
-////    q_3: ───────■────┼──
-////                     │
-////    q_4: ────────────■──
-///     
+///         ┌───┐┌───┐┌───┐
+///    q_0: ┤ X ├┤ X ├┤ X ├
+///         └─┬─┘└─┬─┘└─┬─┘
+///    q_1: ──┼────┼────┼──
+///           │    │    │
+///    q_2: ──■────┼────┼──
+///                │    │
+///    q_3: ───────■────┼──
+///                     │
+///    q_4: ────────────■──
+///
 fn cx_fountain(
     active_paulis: Vec<(char, Qubit)>,
 ) -> Box<dyn DoubleEndedIterator<Item = StandardInstruction>> {

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/crates/accelerate/src/consolidate_blocks.rs

@@ -54,11 +54,12 @@ const MAX_2Q_DEPTH: usize = 20;
 
 #[allow(clippy::too_many_arguments)]
 #[pyfunction]
-#[pyo3(signature = (dag, decomposer, force_consolidate, target=None, basis_gates=None, blocks=None, runs=None))]
+#[pyo3(signature = (dag, decomposer, basis_gate_name, force_consolidate, target=None, basis_gates=None, blocks=None, runs=None))]
 pub(crate) fn consolidate_blocks(
     py: Python,
     dag: &mut DAGCircuit,
     decomposer: &TwoQubitBasisDecomposer,
+    basis_gate_name: &str,
     force_consolidate: bool,
     target: Option<&Target>,
     basis_gates: Option<HashSet<String>>,
@@ -125,7 +126,7 @@ pub(crate) fn consolidate_blocks(
             let inst = dag.dag()[*node].unwrap_operation();
             block_qargs.extend(dag.get_qargs(inst.qubits));
             all_block_gates.insert(*node);
-            if inst.op.name() == decomposer.gate_name() {
+            if inst.op.name() == basis_gate_name {
                 basis_count += 1;
             }
             if !is_supported(

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/crates/accelerate/src/sparse_pauli_op.rs

@@ -10,6 +10,7 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
+use ahash::RandomState;
 use pyo3::exceptions::{PyRuntimeError, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::PyTuple;
@@ -20,6 +21,7 @@ use numpy::prelude::*;
 use numpy::{PyArray1, PyArray2, PyReadonlyArray1, PyReadonlyArray2, PyUntypedArrayMethods};
 
 use hashbrown::HashMap;
+use indexmap::IndexMap;
 use ndarray::{s, ArrayView1, ArrayView2, Axis};
 use num_complex::Complex64;
 use num_traits::Zero;
@@ -298,7 +300,11 @@ impl MatrixCompressedPaulis {
     /// explicitly stored operations, if there are duplicates.  After the summation, any terms that
     /// have become zero are dropped.
     pub fn combine(&mut self) {
-        let mut hash_table = HashMap::<(u64, u64), Complex64>::with_capacity(self.coeffs.len());
+        let mut hash_table =
+            IndexMap::<(u64, u64), Complex64, RandomState>::with_capacity_and_hasher(
+                self.coeffs.len(),
+                RandomState::new(),
+            );
         for (key, coeff) in self
             .x_like
             .drain(..)

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/crates/accelerate/src/synthesis/evolution/pauli_network.rs

@@ -15,7 +15,6 @@ use crate::synthesis::clifford::greedy_synthesis::resynthesize_clifford_circuit;
 use pyo3::prelude::*;
 use pyo3::types::{PyList, PyString, PyTuple};
 use smallvec::{smallvec, SmallVec};
-use std::borrow::Borrow;
 
 use qiskit_circuit::circuit_data::CircuitData;
 use qiskit_circuit::operations::{multiply_param, radd_param, Param, StandardGate};
@@ -334,7 +333,7 @@ pub fn pauli_network_synthesis_inner(
     // go over the input pauli network and extract a list of pauli rotations and
     // the corresponding rotation angles
     for item in pauli_network {
-        let tuple = item.downcast::<PyTuple>()?.borrow();
+        let tuple = item.downcast::<PyTuple>()?;
 
         let sparse_pauli: String = tuple.get_item(0)?.downcast::<PyString>()?.extract()?;
         let qubits: Vec<u32> = tuple.get_item(1)?.extract()?;

qiskit-1.3.0rc2/qiskit/VERSION.txt

@@ -0,0 +1 @@
+1.3.0rc2

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/qiskit/circuit/library/__init__.py

@@ -36,7 +36,7 @@ For example, to append a multi-controlled CNOT:
    circuit.append(gate, [0, 1, 4, 2, 3])
    circuit.draw('mpl')
 
-The library is organized in several sections. The function 
+The library is organized in several sections. The function
 :func:`.get_standard_gate_name_mapping` allows you to see the available standard gates and operations.
 
 .. autofunction:: get_standard_gate_name_mapping
@@ -221,10 +221,10 @@ or of a set of qubit states.
    OrGate
    XOR
    BitwiseXorGate
+   random_bitwise_xor
    InnerProduct
    InnerProductGate
 
-.. autofunction:: random_bitwise_xor
 
 Basis Change Circuits
 =====================
@@ -280,6 +280,9 @@ Adders
    CDKMRippleCarryAdder
    VBERippleCarryAdder
    WeightedAdder
+   ModularAdderGate
+   HalfAdderGate
+   FullAdderGate
 
 Multipliers
 -----------
@@ -290,6 +293,7 @@ Multipliers
 
    HRSCumulativeMultiplier
    RGQFTMultiplier
+   MultiplierGate
 
 Comparators
 -----------
@@ -321,29 +325,40 @@ Other arithmetic functions
 Particular Quantum Circuits
 ===========================
 
+The following gates and quantum circuits define specific
+quantum circuits of interest:
+
 .. autosummary::
    :toctree: ../stubs/
    :template: autosummary/class_no_inherited_members.rst
 
    FourierChecking
-   fourier_checking
    GraphState
    GraphStateGate
    HiddenLinearFunction
-   hidden_linear_function
    IQP
-   iqp
-   random_iqp
    QuantumVolume
-   quantum_volume
    PhaseEstimation
-   phase_estimation
    GroverOperator
-   grover_operator
    PhaseOracle
    PauliEvolutionGate
    HamiltonianGate
    UnitaryOverlap
+
+For circuits that have a well-defined structure it is preferrable
+to use the following functions to construct them:
+
+.. autosummary::
+   :toctree: ../stubs/
+   :template: autosummary/class_no_inherited_members.rst
+
+   fourier_checking
+   hidden_linear_function
+   iqp
+   random_iqp
+   quantum_volume
+   phase_estimation
+   grover_operator
    unitary_overlap
 
 
@@ -362,6 +377,7 @@ a broad set of variational quantum algorithms:
    real_amplitudes
    pauli_two_design
    excitation_preserving
+   qaoa_ansatz
    hamiltonian_variational_ansatz
    evolved_operator_ansatz
 
@@ -386,7 +402,7 @@ They are heavily used in near-term algorithms in e.g. Chemistry, Physics or Opti
 Data encoding circuits
 ======================
 
-The following functions return a parameterized :class:`.QuantumCircuit` to use as data 
+The following functions return a parameterized :class:`.QuantumCircuit` to use as data
 encoding circuits in a series of variational quantum algorithms:
 
 .. autosummary::
@@ -407,6 +423,17 @@ data in quantum states and are used as feature maps for classification.
    PauliFeatureMap
    ZFeatureMap
    ZZFeatureMap
+
+
+Data preparation circuits
+=========================
+
+The following operations are used for state preparation:
+
+.. autosummary::
+   :toctree: ../stubs/
+   :template: autosummary/class_no_inherited_members.rst
+
    StatePreparation
    Initialize
 

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/qiskit/circuit/library/arithmetic/adders/adder.py

@@ -21,7 +21,7 @@ from qiskit.utils.deprecation import deprecate_func
 class Adder(QuantumCircuit):
     r"""Compute the sum of two equally sized qubit registers.
 
-    For two registers :math:`|a\rangle_n` and :math:|b\rangle_n` with :math:`n` qubits each, an
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
     adder performs the following operation
 
     .. math::
@@ -74,7 +74,7 @@ class Adder(QuantumCircuit):
 class HalfAdderGate(Gate):
     r"""Compute the sum of two equally-sized qubit registers, including a carry-out bit.
 
-    For two registers :math:`|a\rangle_n` and :math:|b\rangle_n` with :math:`n` qubits each, an
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
     adder performs the following operation
 
     .. math::
@@ -120,7 +120,7 @@ class HalfAdderGate(Gate):
 class ModularAdderGate(Gate):
     r"""Compute the sum modulo :math:`2^n` of two :math:`n`-sized qubit registers.
 
-    For two registers :math:`|a\rangle_n` and :math:|b\rangle_n` with :math:`n` qubits each, an
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
     adder performs the following operation
 
     .. math::
@@ -166,12 +166,12 @@ class ModularAdderGate(Gate):
 class FullAdderGate(Gate):
     r"""Compute the sum of two :math:`n`-sized qubit registers, including carry-in and -out bits.
 
-    For two registers :math:`|a\rangle_n` and :math:|b\rangle_n` with :math:`n` qubits each, an
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
     adder performs the following operation
 
     .. math::
 
-        |c_{\text{in}\rangle_1 |a\rangle_n |b\rangle_n
+        |c_{\text{in}}\rangle_1 |a\rangle_n |b\rangle_n
         \mapsto |a\rangle_n |c_{\text{in}} + a + b \rangle_{n + 1}.
 
     The quantum register :math:`|a\rangle_n` (and analogously :math:`|b\rangle_n`)

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/qiskit/primitives/utils.py

@@ -82,7 +82,7 @@ def init_observable(observable: BaseOperator | str) -> SparsePauliOp:
     since="1.2",
     additional_msg="Use ``QuantumCircuit.layout`` and ``SparsePauliOp.apply_layout`` "
     + "to adjust an operator for a layout. Otherwise, use ``mthree.utils.final_measurement_mapping``. "
-    + "See https://qiskit-extensions.github.io/mthree/apidocs/utils.html for details.",
+    + "See <https://qiskit.github.io/qiskit-addon-mthree/apidocs/utils> for details.",
 )
 def final_measurement_mapping(circuit: QuantumCircuit) -> dict[int, int]:
     """Return the final measurement mapping for the circuit.

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/qiskit/providers/__init__.py

@@ -160,7 +160,7 @@ steps for writing a provider are:
    interacting with a running job.
 
 For a simple example of a provider, see the
-`qiskit-aqt-provider <https://github.com/Qiskit-Partners/qiskit-aqt-provider>`__
+`qiskit-aqt-provider <https://github.com/qiskit-community/qiskit-aqt-provider>`__
 
 Provider
 --------
@@ -664,7 +664,7 @@ that abstract away the mechanics of getting the best result efficiently, to
 concentrate on higher level applications using these outputs.
 
 For example, if your backends were well suited to leverage
-`mthree <https://github.com/Qiskit-Partners/mthree/>`__ measurement
+`mthree <https://github.com/Qiskit/qiskit-addon-mthree>`__ measurement
 mitigation to improve the quality of the results, you could implement a
 provider-specific :class:`~.Sampler` implementation that leverages the
 ``M3Mitigation`` class internally to run the circuits and return

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/qiskit/quantum_info/states/statevector.py

@@ -476,7 +476,7 @@ class Statevector(QuantumState, TolerancesMixin):
         pauli_phase = (-1j) ** pauli.phase if pauli.phase else 1
 
         if x_mask + z_mask == 0:
-            return pauli_phase * np.linalg.norm(self.data)
+            return pauli_phase * np.linalg.norm(self.data) ** 2
 
         if x_mask == 0:
             return pauli_phase * expval_pauli_no_x(self.data, self.num_qubits, z_mask)

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/qiskit/transpiler/passes/optimization/consolidate_blocks.py

@@ -12,9 +12,11 @@
 
 """Replace each block of consecutive gates by a single Unitary node."""
 from __future__ import annotations
+from math import pi
 
 from qiskit.synthesis.two_qubit import TwoQubitBasisDecomposer
-from qiskit.circuit.library.standard_gates import CXGate, CZGate, iSwapGate, ECRGate
+from qiskit.circuit.library.standard_gates import CXGate, CZGate, iSwapGate, ECRGate, RXXGate
+
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passmanager import PassManager
 from qiskit._accelerate.consolidate_blocks import consolidate_blocks
@@ -27,6 +29,7 @@ KAK_GATE_NAMES = {
     "cz": CZGate(),
     "iswap": iSwapGate(),
     "ecr": ECRGate(),
+    "rxx": RXXGate(pi / 2),
 }
 
 
@@ -70,7 +73,6 @@ class ConsolidateBlocks(TransformationPass):
         if basis_gates is not None:
             self.basis_gates = set(basis_gates)
         self.force_consolidate = force_consolidate
-
         if kak_basis_gate is not None:
             self.decomposer = TwoQubitBasisDecomposer(kak_basis_gate)
         elif basis_gates is not None:
@@ -79,8 +81,12 @@ class ConsolidateBlocks(TransformationPass):
                 self.decomposer = TwoQubitBasisDecomposer(
                     KAK_GATE_NAMES[kak_gates.pop()], basis_fidelity=approximation_degree or 1.0
                 )
+            elif "rzx" in basis_gates:
+                self.decomposer = TwoQubitBasisDecomposer(
+                    CXGate(), basis_fidelity=approximation_degree or 1.0
+                )
             else:
-                self.decomposer = TwoQubitBasisDecomposer(CXGate())
+                self.decomposer = None
         else:
             self.decomposer = TwoQubitBasisDecomposer(CXGate())
 
@@ -103,6 +109,7 @@ class ConsolidateBlocks(TransformationPass):
         consolidate_blocks(
             dag,
             self.decomposer._inner_decomposer,
+            self.decomposer.gate.name,
             self.force_consolidate,
             target=self.target,
             basis_gates=self.basis_gates,

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/qiskit/transpiler/passes/synthesis/high_level_synthesis.py

@@ -382,7 +382,7 @@ class HighLevelSynthesis(TransformationPass):
 
             # If the synthesis changed the operation (i.e. it is not None), store the result.
             if synthesized is not None:
-                synthesized_nodes[node] = (synthesized, synthesized_context)
+                synthesized_nodes[node._node_id] = (synthesized, synthesized_context)
 
             # If the synthesis did not change anything, just update the qubit tracker.
             elif not processed:
@@ -407,8 +407,9 @@ class HighLevelSynthesis(TransformationPass):
         outer_to_local = context.to_local_mapping()
 
         for node in dag.topological_op_nodes():
-            if node in synthesized_nodes:
-                op, op_context = synthesized_nodes[node]
+
+            if op_tuple := synthesized_nodes.get(node._node_id, None):
+                op, op_context = op_tuple
 
                 if isinstance(op, Operation):
                     out.apply_operation_back(op, node.qargs, node.cargs)
@@ -813,6 +814,7 @@ class HighLevelSynthesis(TransformationPass):
             dag._has_calibration_for(node)
             or len(node.qargs) < self._min_qubits
             or node.is_directive()
+            or (self._instruction_supported(node.name, qubits) and not node.is_control_flow())
         ):
             return True
 
@@ -830,15 +832,12 @@ class HighLevelSynthesis(TransformationPass):
             # If all the above constraints hold, and it's already supported or the basis translator
             # can handle it, we'll leave it be.
             and (
-                self._instruction_supported(node.name, qubits)
                 # This uses unfortunately private details of `EquivalenceLibrary`, but so does the
                 # `BasisTranslator`, and this is supposed to just be temporary til this is moved
                 # into Rust space.
-                or (
-                    self._equiv_lib is not None
-                    and equivalence.Key(name=node.name, num_qubits=node.num_qubits)
-                    in self._equiv_lib.keys()
-                )
+                self._equiv_lib is not None
+                and equivalence.Key(name=node.name, num_qubits=node.num_qubits)
+                in self._equiv_lib.keys()
             )
         )
 

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py

@@ -479,10 +479,11 @@ def _parse_basis_gates(basis_gates, backend, inst_map, skip_target):
             if inst not in standard_gates and inst not in default_gates:
                 warnings.warn(
                     category=DeprecationWarning,
-                    message="Providing custom gates through the ``basis_gates`` argument is deprecated "
-                    "for both ``transpile`` and ``generate_preset_pass_manager`` as of Qiskit 1.3.0. "
+                    message=f"Providing non-standard gates ({inst}) through the ``basis_gates`` "
+                    "argument is deprecated for both ``transpile`` and ``generate_preset_pass_manager`` "
+                    "as of Qiskit 1.3.0. "
                     "It will be removed in Qiskit 2.0. The ``target`` parameter should be used instead. "
-                    "You can build a target instance using ``Target.from_configuration()`` and provide"
+                    "You can build a target instance using ``Target.from_configuration()`` and provide "
                     "custom gate definitions with the ``custom_name_mapping`` argument.",
                 )
                 skip_target = True

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/qiskit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qiskit
-Version: 1.3.0rc1
+Version: 1.3.0rc2
 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-1.3.0rc1 → qiskit-1.3.0rc2}/test/python/quantum_info/states/test_statevector.py

@@ -1152,6 +1152,31 @@ class TestStatevector(QiskitTestCase):
         expval = state.expectation_value(op, qubits)
         self.assertAlmostEqual(expval, target)
 
+    def test_expval_identity(self):
+        """Test whether the calculation for identity operator has been fixed"""
+
+        # 1 qubit case test
+        state_1 = Statevector.from_label("0")
+        state_1_n1 = 2 * state_1  # test the same state with different norms
+        state_1_n2 = (1 + 2j) * state_1
+        identity_op_1 = SparsePauliOp.from_list([("I", 1)])
+        expval_state_1 = state_1.expectation_value(identity_op_1)
+        expval_state_1_n1 = state_1_n1.expectation_value(identity_op_1)
+        expval_state_1_n2 = state_1_n2.expectation_value(identity_op_1)
+        self.assertAlmostEqual(expval_state_1, 1.0 + 0j)
+        self.assertAlmostEqual(expval_state_1_n1, 4 + 0j)
+        self.assertAlmostEqual(expval_state_1_n2, 5 + 0j)
+
+        # Let's try a multi-qubit case
+        n_qubits = 3
+        state_coeff = 3 - 4j
+        op_coeff = 2 - 2j
+        state_test = state_coeff * Statevector.from_label("0" * n_qubits)
+        op_test = SparsePauliOp.from_list([("I" * n_qubits, op_coeff)])
+        expval = state_test.expectation_value(op_test)
+        target = op_coeff * np.abs(state_coeff) ** 2
+        self.assertAlmostEqual(expval, target)
+
     @data(*(qargs for i in range(4) for qargs in permutations(range(4), r=i + 1)))
     def test_probabilities_qargs(self, qargs):
         """Test probabilities method with qargs"""

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/test/python/transpiler/test_consolidate_blocks.py

@@ -16,20 +16,28 @@ Tests for the ConsolidateBlocks transpiler pass.
 
 import unittest
 import numpy as np
-
-from qiskit.circuit import QuantumCircuit, QuantumRegister, IfElseOp, Gate
-from qiskit.circuit.library import U2Gate, SwapGate, CXGate, CZGate, UnitaryGate
+from ddt import ddt, data
+
+from qiskit.circuit import QuantumCircuit, QuantumRegister, IfElseOp, Gate, Parameter
+from qiskit.circuit.library import (
+    U2Gate,
+    SwapGate,
+    CXGate,
+    CZGate,
+    UnitaryGate,
+    SXGate,
+    XGate,
+    RZGate,
+)
 from qiskit.converters import circuit_to_dag
-from qiskit.transpiler.passes import ConsolidateBlocks
 from qiskit.quantum_info.operators import Operator
 from qiskit.quantum_info.operators.measures import process_fidelity
-from qiskit.transpiler import PassManager
-from qiskit.transpiler import Target
-from qiskit.transpiler.passes import Collect1qRuns
-from qiskit.transpiler.passes import Collect2qBlocks
+from qiskit.transpiler import PassManager, Target, generate_preset_pass_manager
+from qiskit.transpiler.passes import ConsolidateBlocks, Collect1qRuns, Collect2qBlocks
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
 
 
+@ddt
 class TestConsolidateBlocks(QiskitTestCase):
     """
     Tests to verify that consolidating blocks of gates into unitaries
@@ -571,6 +579,93 @@ class TestConsolidateBlocks(QiskitTestCase):
 
         self.assertEqual(res, qc)
 
+    @data(2, 3)
+    def test_no_kak_gates_in_preset_pm(self, opt_level):
+        """Test correct initialization of ConsolidateBlocks pass when kak_gates aren't found.
+        Reproduces https://github.com/Qiskit/qiskit/issues/13438."""
+
+        qc = QuantumCircuit(2)
+        qc.cz(0, 1)
+        qc.sx([0, 1])
+        qc.cz(0, 1)
+
+        ref_pm = generate_preset_pass_manager(
+            optimization_level=1, basis_gates=["rz", "rzz", "sx", "x", "rx"]
+        )
+        ref_tqc = ref_pm.run(qc)
+        pm = generate_preset_pass_manager(
+            optimization_level=opt_level, basis_gates=["rz", "rzz", "sx", "x", "rx"]
+        )
+        tqc = pm.run(qc)
+        self.assertEqual(ref_tqc, tqc)
+
+    def test_non_cx_basis_gate(self):
+        """Test a non-cx kak gate is consolidated correctly."""
+        qc = QuantumCircuit(2)
+        qc.cz(0, 1)
+        qc.x(0)
+        qc.h(1)
+        qc.z(1)
+        qc.t(1)
+        qc.h(0)
+        qc.t(0)
+        qc.cz(1, 0)
+        qc.sx(0)
+        qc.sx(1)
+        qc.cz(0, 1)
+        qc.sx(0)
+        qc.sx(1)
+        qc.cz(1, 0)
+        qc.x(0)
+        qc.h(1)
+        qc.z(1)
+        qc.t(1)
+        qc.h(0)
+        qc.t(0)
+        qc.cz(0, 1)
+
+        consolidate_pass = ConsolidateBlocks(basis_gates=["sx", "x", "rz", "cz"])
+        res = consolidate_pass(qc)
+        self.assertEqual({"unitary": 1}, res.count_ops())
+        self.assertEqual(Operator.from_circuit(qc), Operator(res.data[0].operation.params[0]))
+
+    def test_non_cx_target(self):
+        """Test a non-cx kak gate is consolidated correctly."""
+        qc = QuantumCircuit(2)
+        qc.cz(0, 1)
+        qc.x(0)
+        qc.h(1)
+        qc.z(1)
+        qc.t(1)
+        qc.h(0)
+        qc.t(0)
+        qc.cz(1, 0)
+        qc.sx(0)
+        qc.sx(1)
+        qc.cz(0, 1)
+        qc.sx(0)
+        qc.sx(1)
+        qc.cz(1, 0)
+        qc.x(0)
+        qc.h(1)
+        qc.z(1)
+        qc.t(1)
+        qc.h(0)
+        qc.t(0)
+        qc.cz(0, 1)
+
+        phi = Parameter("phi")
+        target = Target(num_qubits=2)
+        target.add_instruction(SXGate(), {(0,): None, (1,): None})
+        target.add_instruction(XGate(), {(0,): None, (1,): None})
+        target.add_instruction(RZGate(phi), {(0,): None, (1,): None})
+        target.add_instruction(CZGate(), {(0, 1): None, (1, 0): None})
+
+        consolidate_pass = ConsolidateBlocks(target=target)
+        res = consolidate_pass(qc)
+        self.assertEqual({"unitary": 1}, res.count_ops())
+        self.assertEqual(Operator.from_circuit(qc), Operator(res.data[0].operation.params[0]))
+
 
 if __name__ == "__main__":
     unittest.main()

{qiskit-1.3.0rc1 → qiskit-1.3.0rc2}/test/python/transpiler/test_high_level_synthesis.py

@@ -46,6 +46,7 @@ from qiskit.circuit.library import (
     IGate,
     MCXGate,
     SGate,
+    QAOAAnsatz,
 )
 from qiskit.circuit.library import LinearFunction, PauliEvolutionGate
 from qiskit.quantum_info import Clifford, Operator, Statevector, SparsePauliOp
@@ -664,6 +665,18 @@ class TestHighLevelSynthesisInterface(QiskitTestCase):
             out = hls(circuit)
             self.assertEqual(out.count_ops(), {"u": 1})
 
+    def test_both_basis_gates_and_plugin_specified(self):
+        """Test that a gate is not synthesized when it belongs to basis_gates,
+        regardless of whether there is a plugin method available.
+
+        See: https://github.com/Qiskit/qiskit/issues/13412 for more
+        details.
+        """
+        qc = QAOAAnsatz(SparsePauliOp("Z"), initial_state=QuantumCircuit(1))
+        pm = PassManager([HighLevelSynthesis(basis_gates=["PauliEvolution"])])
+        qct = pm.run(qc)
+        self.assertEqual(qct.count_ops()["PauliEvolution"], 2)
+
 
 class TestPMHSynthesisLinearFunctionPlugin(QiskitTestCase):
     """Tests for the PMHSynthesisLinearFunction plugin for synthesizing linear functions."""