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,40 +1161,40 @@ def _resolve_classical_resource(self, specifier):
 
     def append(
         self,
-        instruction: Instruction,
+        instruction: Operation,
         qargs: Optional[Sequence[QubitSpecifier]] = None,
         cargs: Optional[Sequence[ClbitSpecifier]] = None,
     ) -> InstructionSet:
-        """Append one or more instructions to the end of the circuit, modifying
+        """Append one or more operations to the end of the circuit, modifying
         the circuit in place. Expands qargs and cargs.
 
         Args:
-            instruction (qiskit.circuit.Instruction): Instruction instance to append
+            instruction (qiskit.circuit.Operation): Operation instance to append
             qargs (list(argument)): qubits to attach instruction to
             cargs (list(argument)): clbits to attach instruction to
 
         Returns:
-            qiskit.circuit.Instruction: a handle to the instruction that was just added
+            qiskit.circuit.InstructionSet: a handle to the instruction that was just added
 
         Raises:
-            CircuitError: if object passed is a subclass of Instruction
-            CircuitError: if object passed is neither subclass nor an instance of Instruction
+            CircuitError: if object passed is a subclass of Operation
+            CircuitError: if object passed is neither subclass nor an instance of Operation
         """
         # 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,11 +1219,11 @@ def append(
 
     def _append(
         self,
-        instruction: Instruction,
+        instruction: Operation,
         qargs: Sequence[Qubit],
         cargs: Sequence[Clbit],
-    ) -> Instruction:
-        """Append an instruction to the end of the circuit, modifying the circuit in place.
+    ) -> Operation:
+        """Append an operation to the end of the circuit, modifying the circuit in place.
 
         .. warning::
 
@@ -1242,12 +1243,12 @@ def _append(
             constructs of the control-flow builder interface.
 
         Args:
-            instruction: Instruction instance to append
+            instruction: Operation instance to append
             qargs: Qubits to attach the instruction to.
             cargs: Clbits to attach the instruction to.
 
         Returns:
-            Instruction: a handle to the instruction that was just added
+            Operation: a handle to the instruction that was just added
 
         :meta public:
         """
@@ -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 isinstance(instruction, Instruction):
+            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,8 +75,8 @@ 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)):
-            # If the input is a Terra QuantumCircuit or Instruction we
+        elif isinstance(data, (QuantumCircuit, Operation)):
+            # If the input is a Terra QuantumCircuit or Operation we
             # perform a simulation to construct the unitary operator.
             # This will only work if the circuit or instruction can be
             # defined in terms of unitary gate instructions which have a
@@ -498,7 +498,7 @@ def _einsum_matmul(cls, tensor, mat, indices, shift=0, right_mul=False):
 
     @classmethod
     def _init_instruction(cls, instruction):
-        """Convert a QuantumCircuit or Instruction to an Operator."""
+        """Convert a QuantumCircuit or Operation to an Operator."""
         # Initialize an identity operator of the correct size of the circuit
         if hasattr(instruction, "__array__"):
             return Operator(np.array(instruction, dtype=complex))
@@ -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"):
@@ -544,10 +544,10 @@ def _append_instruction(self, obj, qargs=None):
             # circuit decomposition definition if it exists, otherwise we
             # cannot compose this gate and raise an error.
             if obj.definition is None:
-                raise QiskitError(f"Cannot apply Instruction: {obj.name}")
+                raise QiskitError(f"Cannot apply Operation: {obj.name}")
             if not isinstance(obj.definition, QuantumCircuit):
                 raise QiskitError(
-                    'Instruction "{}" '
+                    'Operation "{}" '
                     "definition is {} but expected QuantumCircuit.".format(
                         obj.name, type(obj.definition)
                     )
@@ -569,7 +569,7 @@ def _append_instruction(self, obj, qargs=None):
             for instr, qregs, cregs in flat_instr:
                 if cregs:
                     raise QiskitError(
-                        f"Cannot apply instruction with classical registers: {instr.name}"
+                        f"Cannot apply operation with classical registers: {instr.name}"
                     )
                 # Get the integer position of the flat register
                 if qargs is None:

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)