Controlled-Initialize instruction

Question

I'm trying to build a new instruction for my circuit. This instruction needs both a controller qubit qctl and an arbitrary register qreg. When qctl is set then the Qiskit's initialize function is applied to qreg.

The original Initialize gate (version 10.5) can be found in the official documentation or locally at path: /anaconda3/envs/<environment name>/lib/python3.7/site-packages/qiskit/extensions/initializer.py. It follows a particular procedure which consists of applying a sequence of RY and RZ gates in order to match the desired state.

The idea is:

copy the Initialize instruction, naming it ControlledInitialize;
pass an additional single qubit register qctl to ControlledInitialize;
change all RZ, RY gates with CRZ, CRY gates (the first one is already available, the second one have to be made from scratch).

The problem

It seems that I have passed qctl register in the wrong way, in fact the below minimum example throws the error:

DAGCircuitError: '(qu)bit qctl[0] not found'

Minimum example

import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import BasicAer, execute

# copy here CRY and ControlledInitialize implementation

desired_vector = [ 1 / math.sqrt(2), 0, 0, 1 / math.sqrt(2) ]
qctl = QuantumRegister(1, "qctl")
qreg = QuantumRegister(2, "qreg")
creg = ClassicalRegister(2, "creg")
circuit = QuantumCircuit(qctl, qreg, creg)

circuit.x(qctl)
circuit.controlled_initialize(qctl, desired_vector, qreg)
circuit.measure(qreg, creg)

job = execute(circuit, BasicAer.get_backend('qasm_simulator'), shots=10000)
print('Counts: ', job.result().get_counts(circuit))

The implementation

The whole code can be seen here as .py and here as Jupyter notebook.

CRZ, CRY gates

CRZ is a standard gate, you can use it with

from qiskit.extensions.standard.crz import CrzGate

CRY is present in Aqua module as a function but not as a subclass of Gate class. You can easily derive the gate implementation:

from qiskit.circuit import CompositeGate
from qiskit.circuit import Gate
from qiskit.circuit import QuantumCircuit
from qiskit.circuit import QuantumRegister
from qiskit.circuit.decorators import _op_expand, _to_bits
from qiskit.extensions.standard.u3 import U3Gate
from qiskit.extensions.standard.cx import CnotGate

class CryGate(Gate):
    """controlled-rz gate."""

    def __init__(self, theta):
        """Create new cry gate."""
        super().__init__("cry", 2, [theta]) # 2 = number of qubits

    def _define(self):
        """
        self.u3(theta / 2, 0, 0, q_target)
        self.cx(q_control, q_target)
        self.u3(-theta / 2, 0, 0, q_target)
        self.cx(q_control, q_target)
        """
        definition = []
        q = QuantumRegister(2, "q")
        rule = [
            (U3Gate(self.params[0] / 2, 0, 0), [q[1]], []),
            (CnotGate(), [q[0], q[1]], []),
            (U3Gate(-self.params[0] / 2, 0, 0), [q[1]], []),
            (CnotGate(), [q[0], q[1]], [])
        ]
        for inst in rule:
            definition.append(inst)
        self.definition = definition

    def inverse(self):
        """Invert this gate."""
        return CrzGate(-self.params[0])


@_to_bits(2)
@_op_expand(2)
def cry(self, theta, ctl, tgt):
    """Apply crz from ctl to tgt with angle theta."""
    return self.append(CryGate(theta), [ctl, tgt], [])


QuantumCircuit.cry = cry
CompositeGate.cry = cry