Controlled gates

[BoxiLi]

@purva-thakre

This is a quick implementation of the controlled gate I described in the meeting agenda. You could work further on it, adding a few more tests and use it as your two-level gates. I tested with some simple cases but I'm not sure if there are still some bugs.

Notice that to use it as a Gate, you also need to define the capital gate name, like CGATE for it in QubitCircuit.propagators() and ``QubitCircuit.propagators_no_expand()`. Let me know if you have questions.

def controlled_gate(
        U, N=2, controls=[0], targets=[1], control_value=[1],
        control=None, target=None):
    """
    Create an N-qubit controlled gate from a single-qubit gate U with the given
    control and target qubits.

    Parameters
    ----------
    U : Qobj
        Arbitrary single-qubit gate.

    N : integer
        The total number of qubits.

    controls : integer or list of integer
        The index of the first control qubit.

    target : integer or list of integer
        The index of the target qubit.

    control_value : integer or list of integer
        The state of the control qubit that activates the gate U.

    Returns
    -------
    result : qobj
        Quantum object representing the controlled-U gate.
    """
    # Compatibility
    if control is not None:
        controls = [control]
    if target is not None:
        targets = [target]
    if isinstance(control_value, int):
        control_value = [control_value]
    num_controls = len(controls)
    num_targets = len(targets)

    # First, assume that the last qubit is the target and control qubits are
    # in the increasing order.
    # Transfer the binary control value to the location of this unitary.
    block_matrices = [np.array([[1,0],[0,1]])] * 2 ** num_controls
    unitary_loc = int("".join(str(s) for s in control_value), 2)
    block_matrices[unitary_loc] = U.full()
    from scipy.linalg import block_diag  # move this to the top of the file
    result = block_diag(*block_matrices)
    result = Qobj(result, dims = [[2] * (num_controls + num_targets)] * 2)

    # Expand it to N qubits and permute qubits labelling
    result = expand_operator(result, N, targets=controls + targets)
    return result

With some quick tests

import numpy as np
from qutip import *
from qutip_qip.decompose._utility import extract_global_phase
from qutip_qip.decompose import decompose_to_rotation_matrices
from qutip_qip.circuit import decomposed_gates_to_circuit
from qutip_qip.operations import *

fid = average_gate_fidelity(  # use np.testing.allclose is probably better
    controlled_gate(sigmax(), N=2, controls=[0], targets=[1], control_value=[1]),
    cnot()
)
assert(abs(fid - 1) < 1.0e-7)
fid = average_gate_fidelity(
    controlled_gate(sigmax(), N=2, controls=[1], targets=[0], control_value=[1]),
    cnot(control=1, target=0)
)
assert(abs(fid - 1) < 1.0e-7)
fid = average_gate_fidelity(
    controlled_gate(sigmax(), N=2, controls=[0], targets=[1], control_value=[0]),
    Qobj(
        [[0, 1, 0, 0,],
        [1, 0, 0, 0,],
        [0, 0, 1, 0,],
        [0, 0, 0, 1,]],
        dims=[[2,2], [2,2]]
    )
)
assert(abs(fid - 1) < 1.0e-7)
fid = average_gate_fidelity(
    controlled_gate(sigmax(), N=3, controls=[2], targets=[1], control_value=[1]),
    tensor([qeye(2), cnot(control=1, target=0)])
)
assert(abs(fid - 1) < 1.0e-7)
fid = average_gate_fidelity(
    controlled_gate(sigmax(), N=3, controls=[2, 0], targets=[1], control_value=[1, 0]),
    controlled_gate(sigmax(), N=3, controls=[0, 2], targets=[1], control_value=[0, 1])
)
assert(abs(fid - 1) < 1.0e-7)

[purva-thakre]

@BoxiLi Thanks for this ! I haven't started working in this yet but looking at your function - there needs to be an option for multiple control value options for larger number of qubits with some way to specify the qubits.

For example : Below is an example 3 qubit gate with target on B controlled by 0 on A and 1 on C.

I will add more options as I go about defining the gate and list them here.

[BoxiLi]

I think this can be generated by

controlled_gate(sigmax(), N=3, controls=[0,2], targets=[1], control_value=[0,1])

?
But anyway try it first when you start that. :)

[BoxiLi]

Basically, the implementation above is compatible with the existing controlled_gate but allow multiple control qubits. In principle, one can also generalize to a U acting on more than one qubits by replacing the definition of block_matrices by

block_matrices = [qeye(target_dims)] * 2 ** num_controls

[BoxiLi]

These lines are just for the compatibility with the exsiting function

    if control is not None:
        controls = [control]
    if target is not None:
        targets = [target]
    if isinstance(control_value, int):
        control_value = [control_value]

[purva-thakre]

@BoxiLi @hodgestar I don't think I will be able to finish off two-qubit decomposition PR by today because of the issues discussed below. I have been able to get the correct numpy array output but I still need to work on the circuit diagram.

I have two questions about using controlled_gate with user_gate. I think I might have misread something in the documentation.

1. Is there a particular reason for UserWarning when a circuit of user defined gates is created ? When defining the gate, I did create the label for it.

Warning : Should I ignore/suppress it and move on if there will be a custom gate label for each iteration of the gray code function ?

UserWarning: Unknown gate CNOT_H warnings.warn("Unknown gate %s" % name)

2. Why does user_gate only take targets and not controls ?

For example, following will output the correct circuit matrix but incorrect diagram with a warning for the gate label.

# U3 definition
def user_gate1():
     H_CNOT = Qobj([[1,0,0,0],[0,1/np.sqrt(2), 0, 1/np.sqrt(2)],[0,0,1,0],[0,1/np.sqrt(2), 0, -1/np.sqrt(2)]])
     return Qobj(H_CNOT, dims=[[2, 2], [2, 2]])

qc1 = QubitCircuit(2, reverse_states=False)
qc1.user_gates = {"CNOT_H"     : user_gate1}
new_gate = Gate("CNOT_H", targets=[0,1])
paulix = Gate("X",targets=0, classical_controls=[0])
cnot1 = Gate("CNOT", controls=0, targets=1)
gate_list = [paulix,cnot1,paulix,new_gate,paulix,cnot1,paulix]
qc1.add_gates(gate_list)
qc1.png

Circuit is output as below.

Expected matrix of the entire circuit is correctly output though :

In the circuit, new_gate is defined with two targets when it should have had controls and targets. Above linked error fails to calculate the output matrix with the new definition specifying targets and controls .

new_gate = Gate("CNOT_H", controls =[1], targets=[0])

Correct circuit

[BoxiLi]

Yeah... if you look at the error message it is from qutip_qip\operations\gates.py:342. Unless you add the gate name to _GATE_NAME_TO_LABEL, this warning will always be there. So it is kind of a bug. There should be an easier way to define a gate label. For now, you can either suppress it leaving an issue or remove that line of warning and make a PR.

[BoxiLi]

Why does user_gate only take targets and not controls ?

In general, it doesn't matter which one is the target which one is the control if a Qobj can be provided. All the qubits are target qubits on which the unitary is applied. The parameter controls is more for convenience. If you have a CNOT with qubit 1 as control, 0 as a target, you can just provide your normal CNOT as Qobj, but with targets=[1,0]. It is the same.

Allowing a controls parameter makes the definition ambiguous. Which dimensions in Qobj are the qubits controlling? One either has to provide another parameter for this or provide some convention e.g., the first few qubits are controls, then targets. Both seem redundant.

[purva-thakre]

Allowing a controls parameter makes the definition ambiguous. Which dimensions in Qobj are the qubits controlling?

That makes sense for the controlled_gate. Thanks ! For now, I will use controlled_gate for the two-qubit case and change it to two-level unitary when that PR gets merged. I can create an issue for this so that I remember to do so.

I think it might be possible to do so for the two-level unitary though. We know the controls and targets from gray code.

[purva-thakre]

@BoxiLi I think I am going to update the paragraph for Custom Gates in the documentation. Is there any other additional information that you want to add besides what you have described in your comment ? (unless I was looking at the wrong spot in the docs)

[BoxiLi]

Is there any other additional information that you want to add besides what you have described in your comment ?

Yeah, you could point out more clearly that only targets are allowed. You can refer to the example of user_gate1, that is exactly the example I made above.

PS: If you do make a PR, could you also remove that Note: Available from QuTiP 4.4? That one is outdated.

[BoxiLi]

Now looking at this discussion, and our meeting yesterday. I realize that the title was wrong. My definition here is for Controlled gates, not two-level matrix. The latter needs a different definition, with arg_value including: row_ind, col_ind, qobj etc.

[purva-thakre]

The latter needs a different definition, with arg_value including: row_ind, col_ind, qobj etc.

Yep, that's how I am defining it.