Adding Cliffords to QuantumCircuits as Operations

qiskit/circuit/__init__.py

@@ -189,6 +189,7 @@
    Delay
    Instruction
    InstructionSet
+   Operation
    EquivalenceLibrary
 
 Control Flow Operations
@@ -231,6 +232,7 @@
 from .controlledgate import ControlledGate
 from .instruction import Instruction
 from .instructionset import InstructionSet
+from .operation import Operation
 from .barrier import Barrier
 from .delay import Delay
 from .measure import Measure

qiskit/circuit/instruction.py

@@ -42,12 +42,13 @@
 from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
 from qiskit.qobj.qasm_qobj import QasmQobjInstruction
 from qiskit.circuit.parameter import ParameterExpression
+from qiskit.circuit.operation import Operation
 from .tools import pi_check
 
 _CUTOFF_PRECISION = 1e-10
 
 
-class Instruction:
+class Instruction(Operation):
     """Generic quantum instruction."""
 
     # Class attribute to treat like barrier for transpiler, unroller, drawer
@@ -546,6 +547,16 @@ def name(self, name):
         """Set the name."""
         self._name = name
 
+    @property
+    def condition(self):
+        """Returns the condition."""
+        return self._condition
+
+    @condition.setter
+    def condition(self, condition):
+        """Set condition."""
+        self._condition = condition
+
     @property
     def num_qubits(self):
         """Return the number of qubits."""

qiskit/circuit/instructionset.py

@@ -19,8 +19,8 @@
 from typing import Callable, Optional, Tuple, Union
 
 from qiskit.circuit.exceptions import CircuitError
-from .instruction import Instruction
 from .classicalregister import Clbit, ClassicalRegister
+from .operation import Operation
 
 
 # ClassicalRegister is hashable, and generally the registers in a circuit are completely fixed after
@@ -150,8 +150,8 @@ def __getitem__(self, i):
 
     def add(self, gate, qargs, cargs):
         """Add an instruction and its context (where it is attached)."""
-        if not isinstance(gate, Instruction):
-            raise CircuitError("attempt to add non-Instruction" + " to InstructionSet")
+        if not isinstance(gate, Operation):
+            raise CircuitError("attempt to add non-Operation" + " to InstructionSet")
         self.instructions.append(gate)
         self.qargs.append(qargs)
         self.cargs.append(cargs)

qiskit/circuit/operation.py

@@ -59,3 +59,26 @@ def num_qubits(self):
     def num_clbits(self):
         """Number of classical bits."""
         raise NotImplementedError
+
+    @abstractmethod
+    def broadcast_arguments(self, qargs, cargs):
+        """Expanding (broadcasting) arguments."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def _directive(self):
+        """Class attribute to treat like barrier for transpiler, unroller, drawer."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def condition(self):
+        """Condition for when the instruction has a conditional if."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def definition(self):
+        """Definition of the operation in terms of more basic gates."""
+        raise NotImplementedError

qiskit/circuit/quantumcircuit.py

@@ -52,6 +52,7 @@
 from .parametertable import ParameterTable, ParameterView
 from .parametervector import ParameterVector, ParameterVectorElement
 from .instructionset import InstructionSet
+from .operation import Operation
 from .register import Register
 from .bit import Bit
 from .quantumcircuitdata import QuantumCircuitData
@@ -1160,7 +1161,7 @@ def _resolve_classical_resource(self, specifier):
 
     def append(
         self,
-        instruction: Instruction,
+        instruction: Operation,
         qargs: Optional[Sequence[QubitSpecifier]] = None,
         cargs: Optional[Sequence[ClbitSpecifier]] = None,
     ) -> InstructionSet:
@@ -1180,20 +1181,20 @@ def append(
             CircuitError: if object passed is neither subclass nor an instance of Instruction
         """
         # Convert input to instruction
-        if not isinstance(instruction, Instruction) and not hasattr(instruction, "to_instruction"):
-            if issubclass(instruction, Instruction):
+        if not isinstance(instruction, Operation) and not hasattr(instruction, "to_instruction"):
+            if issubclass(instruction, Operation):
                 raise CircuitError(
-                    "Object is a subclass of Instruction, please add () to "
+                    "Object is a subclass of Operation, please add () to "
                     "pass an instance of this object."
                 )
 
             raise CircuitError(
-                "Object to append must be an Instruction or have a to_instruction() method."
+                "Object to append must be an Operation or have a to_instruction() method."
             )
-        if not isinstance(instruction, Instruction) and hasattr(instruction, "to_instruction"):
+        if not isinstance(instruction, Operation) and hasattr(instruction, "to_instruction"):
             instruction = instruction.to_instruction()
-        if not isinstance(instruction, Instruction):
-            raise CircuitError("object is not an Instruction.")
+        if not isinstance(instruction, Operation):
+            raise CircuitError("object is not an Operation.")
 
         # Make copy of parameterized gate instances
         if hasattr(instruction, "params"):
@@ -1218,7 +1219,7 @@ def append(
 
     def _append(
         self,
-        instruction: Instruction,
+        instruction: Operation,
         qargs: Sequence[Qubit],
         cargs: Sequence[Clbit],
     ) -> Instruction:
@@ -1261,7 +1262,11 @@ def _append(
 
         return instruction
 
-    def _update_parameter_table(self, instruction: Instruction) -> Instruction:
+    def _update_parameter_table(self, instruction: Operation) -> Operation:
+        # A generic Operation object at the moment does not require to have params.
+        if not hasattr(instruction, "params"):
+            return instruction
+
         for param_index, param in enumerate(instruction.params):
             if isinstance(param, (ParameterExpression, QuantumCircuit)):
                 # Scoped constructs like the control-flow ops use QuantumCircuit as a parameter.

qiskit/quantum_info/operators/operator.py

@@ -21,7 +21,7 @@
 import numpy as np
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.instruction import Instruction
+from qiskit.circuit.operation import Operation
 from qiskit.circuit.library.standard_gates import IGate, XGate, YGate, ZGate, HGate, SGate, TGate
 from qiskit.exceptions import QiskitError
 from qiskit.quantum_info.operators.predicates import is_unitary_matrix, matrix_equal
@@ -53,7 +53,7 @@ def __init__(self, data, input_dims=None, output_dims=None):
 
         Args:
             data (QuantumCircuit or
-                  Instruction or
+                  Operation or
                   BaseOperator or
                   matrix): data to initialize operator.
             input_dims (tuple): the input subsystem dimensions.
@@ -75,7 +75,7 @@ def __init__(self, data, input_dims=None, output_dims=None):
         if isinstance(data, (list, np.ndarray)):
             # Default initialization from list or numpy array matrix
             self._data = np.asarray(data, dtype=complex)
-        elif isinstance(data, (QuantumCircuit, Instruction)):
+        elif isinstance(data, (QuantumCircuit, Operation)):
             # If the input is a Terra QuantumCircuit or Instruction we
             # perform a simulation to construct the unitary operator.
             # This will only work if the circuit or instruction can be
@@ -514,7 +514,7 @@ def _init_instruction(cls, instruction):
     @classmethod
     def _instruction_to_matrix(cls, obj):
         """Return Operator for instruction if defined or None otherwise."""
-        if not isinstance(obj, Instruction):
+        if not isinstance(obj, Operation):
             raise QiskitError("Input is not an instruction.")
         mat = None
         if hasattr(obj, "to_matrix"):

qiskit/quantum_info/operators/symplectic/clifford.py

@@ -23,11 +23,12 @@
 from qiskit.quantum_info.operators.scalar_op import ScalarOp
 from qiskit.quantum_info.synthesis.clifford_decompose import decompose_clifford
 from qiskit.quantum_info.operators.mixins import generate_apidocs, AdjointMixin
+from qiskit.circuit.operation import Operation
 from .stabilizer_table import StabilizerTable
 from .clifford_circuits import _append_circuit
 
 
-class Clifford(BaseOperator, AdjointMixin):
+class Clifford(BaseOperator, AdjointMixin, Operation):
     """An N-qubit unitary operator from the Clifford group.
 
     **Representation**
@@ -101,6 +102,10 @@ class Clifford(BaseOperator, AdjointMixin):
            `arXiv:quant-ph/0406196 <https://arxiv.org/abs/quant-ph/0406196>`_
     """
 
+    # Fields that are currently required to add an object as an Operation.
+    condition = None
+    _directive = False
+
     def __array__(self, dtype=None):
         if dtype:
             return np.asarray(self.to_matrix(), dtype=dtype)
@@ -134,6 +139,9 @@ def __init__(self, data, validate=True):
                     "Invalid Clifford. Input StabilizerTable is not a valid symplectic matrix."
                 )
 
+        # When required, we will compute the QuantumCircuit for this Clifford.
+        self._definition = None
+
         # Initialize BaseOperator
         super().__init__(num_qubits=self._table.num_qubits)
 
@@ -540,6 +548,34 @@ def _pad_with_identity(self, clifford, qargs):
 
         return padded
 
+    def broadcast_arguments(self, qargs, cargs):
+        """
+        Broadcasting of the arguments.
+        This code is currently copied from Instruction.
+        This will be cleaned up when broadcasting is moved
+        to a separate model.
+
+        Args:
+            qargs (List): List of quantum bit arguments.
+            cargs (List): List of classical bit arguments.
+
+        Yields:
+            Tuple(List, List): A tuple with single arguments.
+        """
+
+        #  [[q[0], q[1]], [c[0], c[1]]] -> [q[0], c[0]], [q[1], c[1]]
+        flat_qargs = [qarg for sublist in qargs for qarg in sublist]
+        flat_cargs = [carg for sublist in cargs for carg in sublist]
+        yield flat_qargs, flat_cargs
+
+    @property
+    def definition(self):
+        """Computes and returns the circuit for this Clifford."""
+        if self._definition is None:
+            self._definition = self.to_circuit()
+
+        return self._definition
+
 
 # Update docstrings for API docs
 generate_apidocs(Clifford)

qiskit/transpiler/passes/optimization/optimize_cliffords.py

@@ -0,0 +1,85 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Combine consecutive Cliffords over the same qubits."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.quantum_info.operators import Clifford
+
+
+class OptimizeCliffords(TransformationPass):
+    """Combine consecutive Cliffords over the same qubits.
+    This serves as an example of extra capabilities enabled by storing
+    Cliffords natively on the circuit.
+    """
+
+    def run(self, dag):
+        """Run the OptimizeCliffords pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): the DAG to be optimized.
+
+        Returns:
+            DAGCircuit: the optimized DAG.
+        """
+
+        blocks = []
+        prev_node = None
+        cur_block = []
+
+        # Iterate over all nodes and collect consecutive Cliffords over the
+        # same qubits. In this very first proof-of-concept implementation
+        # we require the same ordering of qubits, but this restriction will
+        # be shortly removed. An interesting question is whether we may also
+        # want to compose Cliffords over different sets of qubits, such as
+        # cliff1 over qubits [1, 2, 3] and cliff2 over [2, 3, 4].
+        for node in dag.op_nodes():
+            if isinstance(node.op, Clifford):
+                if prev_node is None:
+                    blocks.append(cur_block)
+                    cur_block = [node]
+                else:
+                    if prev_node.qargs == node.qargs:
+                        cur_block.append(node)
+                    else:
+                        blocks.append(cur_block)
+                        cur_block = [node]
+
+                prev_node = node
+
+            else:
+                # not a clifford
+                blocks.append(cur_block)
+                prev_node = None
+                cur_block = []
+
+        blocks.append(cur_block)
+
+        # Replace every discovered block of cliffords by a single clifford
+        # based on the Cliffords' compose function.
+        for cur_nodes in blocks:
+            # Create clifford functions only out of blocks with at least 2 gates
+            if len(cur_nodes) <= 1:
+                continue
+
+            wire_pos_map = dict((qb, ix) for ix, qb in enumerate(cur_nodes[0].qargs))
+
+            # Construct a linear circuit
+            cliff = cur_nodes[0].op
+            for i, node in enumerate(cur_nodes):
+                if i > 0:
+                    cliff = Clifford.compose(node.op, cliff, front=True)
+
+            # Replace the block by the composed clifford
+            dag.replace_block_with_op(cur_nodes, cliff, wire_pos_map, cycle_check=False)
+
+        return dag

releasenotes/notes/operation-abstract-base-class-c5efe020aa9caf46.yaml

@@ -0,0 +1,15 @@
+---
+
+features:
+  - |
+    A new :class:`.Operation` base class for objects that can be added to a :class:`.QuantumCircuit`.
+    These objects include :class:`.Gate`, :class:`.Reset`, :class:`.Barrier`, :class:.Measure`,
+    and operators such as :class:`.Clifford`.
+  - |
+    A Clifford gate is now added to a quantum circuit as an :class:`.Operation`, without first
+    synthesizing a subcircuit implementing this Clifford gate. The actual synthesis is postponed
+    to a later transpilation pass.
+  - |
+    Added a new transpiler pass :class:`.OptimizeCliffords` that collects blocks of consecutive
+    Clifford gates in a circuit, and replaces each block with a single Clifford object.
+

test/python/circuit/test_instructions.py

@@ -400,7 +400,7 @@ def test_instance_of_instruction(self):
 
         qr = QuantumRegister(2)
         qc = QuantumCircuit(qr)
-        with self.assertRaisesRegex(CircuitError, r"Object is a subclass of Instruction"):
+        with self.assertRaisesRegex(CircuitError, r"Object is a subclass of Operation"):
             qc.append(HGate, qr[:], [])
 
     def test_repr_of_instructions(self):