qiskit 1.4.0__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0rc1__cp39-abi3-macosx_11_0_arm64.whl

qiskit/transpiler/passes/synthesis/hls_plugins.py

@@ -250,6 +250,58 @@ MCMT Synthesis
    MCMTSynthesisNoAux
    MCMTSynthesisDefault
 
+   
+Integer comparators
+'''''''''''''''''''
+
+.. list-table:: Plugins for :class:`.IntegerComparatorGate` (key = ``"IntComp"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Description
+      - Auxiliary qubits
+    * - ``"twos"``
+      - :class:`~.IntComparatorSynthesis2s`
+      - use addition with two's complement 
+      - ``n - 1`` clean 
+    * - ``"noaux"``
+      - :class:`~.IntComparatorSynthesisNoAux`
+      - flip the target controlled on all :math:`O(2^l)` allowed integer values
+      - none
+    * - ``"default"``
+      - :class:`~.IntComparatorSynthesisDefault`
+      - use the best algorithm depending on the available auxiliary qubits
+      - any
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   IntComparatorSynthesis2s
+   IntComparatorSynthesisNoAux
+   IntComparatorSynthesisDefault
+
+   
+Sums
+''''
+
+.. list-table:: Plugins for :class:`.WeightedSumGate` (key = ``"WeightedSum"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Description
+      - Auxiliary qubits
+    * - ``"default"``
+      - :class:`.WeightedSumSynthesisDefault`
+      - use a V-chain based synthesis
+      - given ``s`` sum qubits, used ``s - 1 + int(s > 2)`` clean auxiliary qubits
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   WeightedSumSynthesisDefault
+
 
 Pauli Evolution Synthesis
 '''''''''''''''''''''''''
@@ -391,7 +443,7 @@ Multiplier Synthesis
       - Description
     * - ``"cumulative"``
       - :class:`.MultiplierSynthesisH18`
-      - depending on the :class:`.HalfAdderGate` used
+      - depending on the :class:`.AdderGate` used
       - a cumulative adder based on controlled adders
     * - ``"qft"``
       - :class:`.MultiplierSynthesisR17`
@@ -413,6 +465,7 @@ import numpy as np
 import rustworkx as rx
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.operation import Operation
 from qiskit.circuit.library import (
     LinearFunction,
     QFTGate,
@@ -426,9 +479,23 @@ from qiskit.circuit.library import (
     HalfAdderGate,
     FullAdderGate,
     MultiplierGate,
+    WeightedSumGate,
+    GlobalPhaseGate,
+)
+from qiskit.circuit.annotated_operation import (
+    AnnotatedOperation,
+    Modifier,
+    ControlModifier,
+    InverseModifier,
+    PowerModifier,
 )
 from qiskit.transpiler.coupling import CouplingMap
 
+from qiskit.synthesis.arithmetic import (
+    synth_integer_comparator_2s,
+    synth_integer_comparator_greedy,
+    synth_weighted_sum_carry,
+)
 from qiskit.synthesis.clifford import (
     synth_clifford_full,
     synth_clifford_layers,
@@ -470,6 +537,9 @@ from qiskit.synthesis.arithmetic import (
 )
 from qiskit.quantum_info.operators import Clifford
 from qiskit.transpiler.passes.routing.algorithms import ApproximateTokenSwapper
+from qiskit.transpiler.exceptions import TranspilerError
+
+from qiskit._accelerate.high_level_synthesis import synthesize_operation
 from .plugin import HighLevelSynthesisPlugin
 
 
@@ -1247,6 +1317,47 @@ class MCMTSynthesisVChain(HighLevelSynthesisPlugin):
         )
 
 
+class IntComparatorSynthesisDefault(HighLevelSynthesisPlugin):
+    """The default synthesis for ``IntegerComparatorGate``.
+
+    Currently this is only supporting an ancilla-based decomposition.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        num_state_qubits = high_level_object.num_qubits - 1
+        num_aux = num_state_qubits - 1
+        if options.get("num_clean_ancillas", 0) < num_aux:
+            return synth_integer_comparator_greedy(
+                num_state_qubits, high_level_object.value, high_level_object.geq
+            )
+
+        return synth_integer_comparator_2s(
+            num_state_qubits, high_level_object.value, high_level_object.geq
+        )
+
+
+class IntComparatorSynthesisNoAux(HighLevelSynthesisPlugin):
+    """A potentially exponentially expensive comparison w/o auxiliary qubits."""
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        return synth_integer_comparator_greedy(
+            high_level_object.num_state_qubits, high_level_object.value, high_level_object.geq
+        )
+
+
+class IntComparatorSynthesis2s(HighLevelSynthesisPlugin):
+    """An integer comparison based on 2s complement."""
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        num_aux = high_level_object.num_state_qubits - 1
+        if options.get("num_clean_ancillas", 0) < num_aux:
+            return None
+
+        return synth_integer_comparator_2s(
+            high_level_object.num_state_qubits, high_level_object.value, high_level_object.geq
+        )
+
+
 class ModularAdderSynthesisDefault(HighLevelSynthesisPlugin):
     """The default modular adder (no carry in, no carry out qubit) synthesis.
 
@@ -1663,3 +1774,185 @@ class PauliEvolutionSynthesisRustiq(HighLevelSynthesisPlugin):
             upto_phase=upto_phase,
             resynth_clifford_method=resynth_clifford_method,
         )
+
+
+class AnnotatedSynthesisDefault(HighLevelSynthesisPlugin):
+    """Synthesize an :class:`.AnnotatedOperation` using the default synthesis algorithm.
+
+    This plugin name is:``annotated.default`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, AnnotatedOperation):
+            return None
+
+        operation = high_level_object
+        modifiers = high_level_object.modifiers
+
+        # The plugin needs additional information that is not yet passed via the run's method
+        # arguments: namely high-level-synthesis data and options, the global qubits over which
+        # the operation is defined, and the initial state of each global qubit.
+        tracker = options.get("qubit_tracker", None)
+        data = options.get("hls_data", None)
+        input_qubits = options.get("input_qubits", None)
+
+        if data is None or input_qubits is None:
+            raise TranspilerError(
+                "The AnnotatedSynthesisDefault plugin should receive data and input_qubits via options."
+            )
+
+        if len(modifiers) > 0:
+            num_ctrl = sum(
+                mod.num_ctrl_qubits for mod in modifiers if isinstance(mod, ControlModifier)
+            )
+            power = sum(mod.power for mod in modifiers if isinstance(mod, PowerModifier))
+            is_inverted = sum(1 for mod in modifiers if isinstance(mod, InverseModifier)) % 2
+
+            # First, synthesize the base operation of this annotated operation.
+            # As this step cannot use any control qubits as auxiliary qubits, we use a dedicated
+            # tracker (annotated_tracker).
+            # The logic is as follows:
+            # - annotated_tracker.disable control qubits
+            # - if have power or inverse modifiers, annotated_tracker.set_dirty(base_qubits)
+            # - synthesize the base operation using annotated tracker
+            # - main_tracker.set_dirty(base_qubits)
+            #
+            # Note that we need to set the base_qubits to dirty if we have power or inverse
+            # modifiers. For power: even if the power is a positive integer (that is, we need
+            # to repeat the same circuit multiple times), even if the target is initially at |0>,
+            # it will generally not be at |0> after one iteration. For inverse: as we
+            # flip the order of operations, we cannot exploit which qubits are at |0> as "viewed from
+            # the back of the circuit". If we just have control modifiers, we can use the state
+            # of base qubits when synthesizing the controlled operation.
+            #
+            # In addition, all of the other global qubits that are not a part of the annotated
+            # operation can be used as they are in all cases, since we are assuming that all of
+            # the synthesis methods preserve the states of ancilla qubits.
+            annotated_tracker = tracker.copy()
+            control_qubits = input_qubits[:num_ctrl]
+            base_qubits = input_qubits[num_ctrl:]
+            annotated_tracker.disable(control_qubits)  # do not access control qubits
+            if power != 0 or is_inverted:
+                annotated_tracker.set_dirty(base_qubits)
+
+            # Note that synthesize_operation also returns the output qubits on which the
+            # operation is defined, however currently the plugin mechanism has no way
+            # to return these (and instead the upstream code greedily grabs some ancilla
+            # qubits from the circuit). We should refactor the plugin "run" iterface to
+            # return the actual ancilla qubits used.
+            synthesized_base_op_result = synthesize_operation(
+                operation.base_op, input_qubits[num_ctrl:], data, annotated_tracker
+            )
+
+            # The base operation does not need to be synthesized.
+            # For simplicity, we wrap the instruction into a circuit. Note that
+            # this should not deteriorate the quality of the result.
+            if synthesized_base_op_result is None:
+                synthesized_base_op = self._instruction_to_circuit(operation.base_op)
+            else:
+                synthesized_base_op = QuantumCircuit._from_circuit_data(
+                    synthesized_base_op_result[0]
+                )
+            tracker.set_dirty(base_qubits)
+
+            # This step currently does not introduce ancilla qubits. However it makes
+            # a lot of sense to allow this in the future.
+            synthesized = self._apply_annotations(synthesized_base_op, operation.modifiers)
+
+            return synthesized
+
+        return None
+
+    @staticmethod
+    def _apply_annotations(circuit: QuantumCircuit, modifiers: list[Modifier]) -> QuantumCircuit:
+        """
+        Applies modifiers to a quantum circuit.
+        """
+        for modifier in modifiers:
+            if isinstance(modifier, InverseModifier):
+                circuit = circuit.inverse()
+
+            elif isinstance(modifier, ControlModifier):
+                if circuit.num_clbits > 0:
+                    raise TranspilerError(
+                        "AnnotatedSynthesisDefault: cannot control a circuit with classical bits."
+                    )
+
+                # Apply the control modifier to each gate in the circuit.
+                controlled_circuit = QuantumCircuit(modifier.num_ctrl_qubits + circuit.num_qubits)
+                if circuit.global_phase != 0:
+                    controlled_op = GlobalPhaseGate(circuit.global_phase).control(
+                        num_ctrl_qubits=modifier.num_ctrl_qubits,
+                        label=None,
+                        ctrl_state=modifier.ctrl_state,
+                        annotated=False,
+                    )
+                    controlled_qubits = list(range(0, modifier.num_ctrl_qubits))
+                    controlled_circuit.append(controlled_op, controlled_qubits)
+                for inst in circuit:
+                    inst_op = inst.operation
+                    inst_qubits = inst.qubits
+                    controlled_op = inst_op.control(
+                        num_ctrl_qubits=modifier.num_ctrl_qubits,
+                        label=None,
+                        ctrl_state=modifier.ctrl_state,
+                        annotated=False,
+                    )
+                    controlled_qubits = list(range(0, modifier.num_ctrl_qubits)) + [
+                        modifier.num_ctrl_qubits + circuit.find_bit(q).index for q in inst_qubits
+                    ]
+                    controlled_circuit.append(controlled_op, controlled_qubits)
+
+                circuit = controlled_circuit
+
+                if isinstance(circuit, AnnotatedOperation):
+                    raise TranspilerError(
+                        "AnnotatedSynthesisDefault: failed to synthesize the control modifier."
+                    )
+
+            elif isinstance(modifier, PowerModifier):
+                circuit = circuit.power(modifier.power)
+
+            else:
+                raise TranspilerError(f"AnnotatedSynthesisDefault: Unknown modifier {modifier}.")
+
+        return circuit
+
+    @staticmethod
+    def _instruction_to_circuit(op: Operation) -> QuantumCircuit:
+        """Wraps a single operation into a quantum circuit."""
+        circuit = QuantumCircuit(op.num_qubits, op.num_clbits)
+        circuit.append(op, circuit.qubits, circuit.clbits)
+        return circuit
+
+
+class WeightedSumSynthesisDefault(HighLevelSynthesisPlugin):
+    """Synthesize a :class:`.WeightedSumGate` using the default synthesis algorithm.
+
+    This plugin name is:``WeightedSum.default`` which can be used as the key on
+    an :class:`.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    .. note::
+
+        This default plugin requires auxiliary qubits. There is currently no implementation
+        available without auxiliary qubits.
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, WeightedSumGate):
+            return None
+
+        required_auxiliaries = (
+            high_level_object.num_sum_qubits - 1 + int(high_level_object.num_sum_qubits > 2)
+        )
+        if (num_clean := options.get("num_clean_ancillas", 0)) < required_auxiliaries:
+            warnings.warn(
+                f"Cannot synthesize a WeightedSumGate on {high_level_object.num_state_qubits} state "
+                f"qubits with less than {required_auxiliaries} clean auxiliary qubits. Only "
+                f"{num_clean} are available. This will likely lead to a error in HighLevelSynthesis."
+            )
+            return None
+
+        return synth_weighted_sum_carry(high_level_object)

qiskit/transpiler/passes/synthesis/plugin.py

@@ -714,6 +714,10 @@ class HighLevelSynthesisPluginManager:
         plugin_name = op_name + "." + method_name
         return self.plugins[plugin_name].obj
 
+    def op_names(self):
+        """Returns the names of high-level-objects with available synthesis methods."""
+        return list(self.plugins_by_op.keys())
+
 
 def high_level_synthesis_plugin_names(op_name: str) -> List[str]:
     """Return a list of plugin names installed for a given high level object name

qiskit/transpiler/passes/synthesis/solovay_kitaev_synthesis.py

@@ -33,7 +33,7 @@ from qiskit.synthesis.discrete_basis.generate_basis_approximations import (
     generate_basic_approximations,
 )
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.passes.utils.control_flow import trivial_recurse
 
 from .plugin import UnitarySynthesisPlugin
 
@@ -73,7 +73,9 @@ class SolovayKitaev(TransformationPass):
 
         Per default, the basis gate set is ``["t", "tdg", "h"]``:
 
-        .. code-block::
+        .. plot::
+           :include-source:
+           :nofigs:
 
             import numpy as np
             from qiskit.circuit import QuantumCircuit
@@ -110,7 +112,9 @@ class SolovayKitaev(TransformationPass):
 
         For individual basis gate sets, the ``generate_basic_approximations`` function can be used:
 
-        .. code-block::
+        .. plot::
+           :include-source:
+           :nofigs:
 
             from qiskit.synthesis import generate_basic_approximations
             from qiskit.transpiler.passes import SolovayKitaev
@@ -151,6 +155,7 @@ class SolovayKitaev(TransformationPass):
         self.recursion_degree = recursion_degree
         self._sk = SolovayKitaevDecomposition(basic_approximations)
 
+    @trivial_recurse
     def run(self, dag: DAGCircuit) -> DAGCircuit:
         """Run the ``SolovayKitaev`` pass on `dag`.
 
@@ -164,18 +169,19 @@ class SolovayKitaev(TransformationPass):
             TranspilerError: if a gates does not have to_matrix
         """
         for node in dag.op_nodes():
-            if not node.op.num_qubits == 1:
-                continue  # ignore all non-single qubit gates
+
+            # ignore operations on which the algorithm cannot run
+            if (
+                (node.op.num_qubits != 1)
+                or node.is_parameterized()
+                or (not hasattr(node.op, "to_matrix"))
+            ):
+                continue
 
             # we do not check the input matrix as we know it comes from a Qiskit gate, as this
             # we know it will generate a valid SU(2) matrix
             check_input = not isinstance(node.op, Gate)
 
-            if not hasattr(node.op, "to_matrix"):
-                raise TranspilerError(
-                    f"SolovayKitaev does not support gate without to_matrix method: {node.op.name}"
-                )
-
             matrix = node.op.to_matrix()
 
             # call solovay kitaev