ControlledGate
class ControlledGate(name, num_qubits, params, label=None, num_ctrl_qubits=1, definition=None, ctrl_state=None)
Controlled unitary gate.
Create a new ControlledGate. In the new gate the first num_ctrl_qubits of the gate are the controls.
Parameters
- name (
str) – The name of the gate. - num_qubits (
int) – The number of qubits the gate acts on. - params (
List) – A list of parameters for the gate. - label (
Optional[str]) – An optional label for the gate. - num_ctrl_qubits (
Optional[int]) – Number of control qubits. - definition (
Optional[List[Tuple[Gate,List[Qubit],List[Clbit]]]]) – A list of gate rules for implementing this gate. The elements of the list are tuples of (Gate(), [qubit_list], [clbit_list]). - ctrl_state (
Union[int,str,None]) – The control state in decimal or as a bitstring (e.g. ‘111’). If specified as a bitstring the length must equal num_ctrl_qubits, MSB on left. If None, use 2**num_ctrl_qubits-1.
Raises
- CircuitError – If
num_ctrl_qubits>=num_qubits. - CircuitError – ctrl_state < 0 or ctrl_state > 2**num_ctrl_qubits.
Examples:
Create a controlled standard gate and apply it to a circuit.
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import HGate
qr = QuantumRegister(3)
qc = QuantumCircuit(qr)
c3h_gate = HGate().control(2)
qc.append(c3h_gate, qr)
qc.draw()
q0_0: ──■──
│
q0_1: ──■──
┌─┴─┐
q0_2: ┤ H ├
└───┘Create a controlled custom gate and apply it to a circuit.
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import HGate
qc1 = QuantumCircuit(2)
qc1.x(0)
qc1.h(1)
custom = qc1.to_gate().control(2)
qc2 = QuantumCircuit(4)
qc2.append(custom, [0, 3, 1, 2])
qc2.draw()
q_0: ──────■───────
┌─────┴──────┐
q_1: ┤0 ├
│ circuit12 │
q_2: ┤1 ├
└─────┬──────┘
q_3: ──────■───────
Attributes
ctrl_state
Type: int
Return the control state of the gate as a decimal integer.
Return type
int
decompositions
Get the decompositions of the instruction from the SessionEquivalenceLibrary.
definition
Type: List
Return definition in terms of other basic gates. If the gate has open controls, as determined from self.ctrl_state, the returned definition is conjugated with X without changing the internal _definition.
Return type
List
label
Type: str
Return gate label
Return type
str
params
return instruction params.
Methods
add_decomposition
ControlledGate.add_decomposition(decomposition)
Add a decomposition of the instruction to the SessionEquivalenceLibrary.
assemble
broadcast_arguments
ControlledGate.broadcast_arguments(qargs, cargs)
Validation and handling of the arguments and its relationship.
For example, cx([q[0],q[1]], q[2]) means cx(q[0], q[2]); cx(q[1], q[2]). This method yields the arguments in the right grouping. In the given example:
in: [[q[0],q[1]], q[2]],[]
outs: [q[0], q[2]], []
[q[1], q[2]], []The general broadcasting rules are:
If len(qargs) == 1:
[q[0], q[1]] -> [q[0]],[q[1]]If len(qargs) == 2:
[[q[0], q[1]], [r[0], r[1]]] -> [q[0], r[0]], [q[1], r[1]] [[q[0]], [r[0], r[1]]] -> [q[0], r[0]], [q[0], r[1]] [[q[0], q[1]], [r[0]]] -> [q[0], r[0]], [q[1], r[0]]If len(qargs) >= 3:
[q[0], q[1]], [r[0], r[1]], ...] -> [q[0], r[0], ...], [q[1], r[1], ...]
Parameters
- qargs (
List) – List of quantum bit arguments. - cargs (
List) – List of classical bit arguments.
Return type
Tuple[List, List]
Returns
A tuple with single arguments.
Raises
CircuitError – If the input is not valid. For example, the number of arguments does not match the gate expectation.
c_if
ControlledGate.c_if(classical, val)
Add classical condition on register classical and value val.
control
ControlledGate.control(num_ctrl_qubits=1, label=None, ctrl_state=None)
Return controlled version of gate. See ControlledGate for usage.
Parameters
- num_ctrl_qubits (
Optional[int]) – number of controls to add to gate (default=1) - label (
Optional[str]) – optional gate label - ctrl_state (
Union[int,str,None]) – The control state in decimal or as a bitstring (e.g. ‘111’). If None, use 2**num_ctrl_qubits-1.
Returns
Controlled version of gate. This default algorithm uses num_ctrl_qubits-1 ancillae qubits so returns a gate of size num_qubits + 2*num_ctrl_qubits - 1.
Return type
Raises
QiskitError – unrecognized mode or invalid ctrl_state
copy
ControlledGate.copy(name=None)
Copy of the instruction.
Parameters
name (str) – name to be given to the copied circuit, if None then the name stays the same.
Returns
a copy of the current instruction, with the name
updated if it was provided
Return type
inverse
ControlledGate.inverse()
Invert this gate by calling inverse on the base gate.
Return type
is_parameterized
ControlledGate.is_parameterized()
Return True .IFF. instruction is parameterized else False
mirror
ControlledGate.mirror()
For a composite instruction, reverse the order of sub-gates.
This is done by recursively mirroring all sub-instructions. It does not invert any gate.
Returns
a fresh gate with sub-gates reversed
Return type
power
ControlledGate.power(exponent)
Creates a unitary gate as gate^exponent.
Parameters
exponent (float) – Gate^exponent
Returns
To which to_matrix is self.to_matrix^exponent.
Return type
Raises
CircuitError – If Gate is not unitary
qasm
ControlledGate.qasm()
Return a default OpenQASM string for the instruction.
Derived instructions may override this to print in a different format (e.g. measure q[0] -> c[0];).
repeat
ControlledGate.repeat(n)
Creates an instruction with gate repeated n amount of times.
Parameters
n (int) – Number of times to repeat the instruction
Returns
Containing the definition.
Return type
Raises
CircuitError – If n < 1.
to_matrix
ControlledGate.to_matrix()
Return a Numpy.array for the gate unitary matrix.
Raises
CircuitError – If a Gate subclass does not implement this method an exception will be raised when this base class method is called.
Return type
ndarray