8. Implementación

\( \newcommand{\bra}[1]{\langle #1|} \) \( \newcommand{\ket}[1]{|#1\rangle} \) \( \newcommand{\braket}[2]{\langle #1|#2\rangle} \) \( \newcommand{\i}{{\color{blue} i}} \) \( \newcommand{\Hil}{{\cal H}} \) \( \newcommand{\cg}[1]{{\rm C}#1} \) \( \newcommand{\lp}{\left(} \) \( \newcommand{\rp}{\right)} \) \( \newcommand{\lc}{\left[} \) \( \newcommand{\rc}{\right]} \) \( \newcommand{\lch}{\left\{} \) \( \newcommand{\rch}{\right\}} \) \( \newcommand{\Lp}{\Bigl(} \) \( \newcommand{\Rp}{\Bigr)} \) \( \newcommand{\Lc}{\Bigl[} \) \( \newcommand{\RC}{\Bigr]} \) \( \newcommand{\Lch}{\Bigl\{} \) \( \newcommand{\Rch}{\Bigr\}} \) \( \newcommand{\rqa}{\quad \Rightarrow \quad} \)

8. Implementación#

Puerta multicontrolada \(Z\) (MCZ).
Difusor genérico.
Oráculo “trivial”.
Oráculos que verifican condiciones.

Qiskit

import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, transpile
from qiskit.visualization import plot_histogram
from qiskit_aer import AerSimulator

Qibo

from qibo import Circuit, gates
import numpy as np

Esta sección se basa en [16].

Puerta multicontrolada \(Z\) (MCZ).#

Vamos a empezar viendo la implementación de la puerta multicontrolada \(Z\) (MCZ), pues la usaremos bastante el las siguientes secciones. Esta puerta podemos construir a partir de la puerta multicontrolada Toffoli (MCT) de forma muy sencilla. Para ello, recordemos que la MCT no es más que una CNOT (es decir, una puerta \(X\)) con varios controles y recordemos también la propiedad

(73)#\[\begin{equation} HXH = Z . \end{equation} \]

Podemos pues construir la MCZ aplicando puertas de Hadammard en el qubit objetivo de la MCT antes y después de la misma.

Qiskit

def mcz(circuit, control_qubits, target_qubit):
    '''
    This funntion implements a multicontroled Z-gate. If all the control_qubits
    are in state |1>, a Z-gate is apply in the qubit called "target_qubit".

    To build this gate we use a multicontrolled Toffoli (mct) gate. To do this, 
    let's first remember that the mct gate is nothing more than a multicontrolled 
    CNOT, which only applies on the target qubit if all the control qubits are 1.

    So, we only need to use the property
        Z = H X H 
    In this way we only have to apply Hadammard gates on the target_qubit before
    and after the mct.

    In summary, the mcz gate adds a pi phase (Z gate) to the |11...1> state.

    Inputs:
        - circuit: Quantum Circuit where we have the "control_reg" and the 
            "target_qubit".

        - control_reg: Qubits that control the gate. It must be one Quantum 
            Register of the previus circuit.

        - target_qubit: Qubit in which we apply the Z gate. It must be one qubit
            of the previus circuit.
    '''
    circuit.h(target_qubit)
    #circuit.mct(control_qubits, target_qubit)  # multi-controlled-toffoli (versiones antiguas de Qiskit)
    circuit.mcx(control_qubits, target_qubit)  # multi-controlled-toffoli
    circuit.h(target_qubit)

Qibo

# On qibo there is a built-in MCZ gate

Difusor genérico.#

Como ya comentamos en la sección Creación de un difusor U_{\Psi_0}., habitualmente en vez de implementar \(U_{\Psi_0}\) implementamos \(-U_{\Psi_0}\). Vimos además que podemos hacer la implementación mediante transformadas de Walsh-Hadamard \(H^{\otimes n}\), puertas \(X^{\otimes n}\) y la puerta \(MCZ\) de la forma de la Ec. (69), es decir

(74)#\[\begin{equation} \boxed{-U_{\Psi_0} = S_{\Psi_0} = H^{\otimes n} S_0 H^{\otimes n} = H^{\otimes n} X^{\otimes n} (MCZ) X^{\otimes n} H^{\otimes n}} \end{equation} \]

Qiskit

def Grover_Diffuser(circuit, target_reg):
    ''' 
    This function apply the Grover's diffuser to a quantum register.

    Imputs:
        - circuit: It is the Quantum Circuit in which we are going to insert 
            the diffuser gate. It must contain the Quantum Register target_reg.
            It can be something like:
            QuantumCircuit(target_reg, classic_reg)

        - target_reg: Quantum Register in witch we are going to apply the 
            diffuser. 

        - n: Number of qubits in the Quantum Register target_reg

    Output:
        The function has no output. It modiffy the original circuit.
    '''

    n = target_reg.size

    # Apply transformation |s> -> |00..0> (H-gates)
    for i in range(n):
        circuit.h(target_reg[i])

    # Apply transformation |00..0> -> |11..1> (X-gates)
    for i in range(n):
        circuit.x(target_reg[i])

    # Do multi-controlled-Z gate
    mcz(circuit, target_reg[list(range(n-1))], target_reg[n-1])

    # Apply transformation |11..1> -> |00..0>
    for i in range(n):
        circuit.x(target_reg[i])

    # Apply transformation |00..0> -> |s>
    for i in range(n):
        circuit.h(target_reg[i])

Qibo

def grover_diffuser_qibo(circuit_qibo,ancilla=0):
    """
    This functions generates the Grover diffuser circuit for nqubits. 

    Inputs:
    ------
        - circuit_qibo: `Circuit`. A qibo circuit to add the Grover diffuser
        - ancilla: `int`. Optional. Number of ancilla qubits, no gate is applied to them. 
    Outputs:
    ------
        - circuit_qibo: `Circuit`. A qibo circuit with the Grover diffuser added
        
    """
    nqubits=circuit_qibo.nqubits-ancilla
    


    #this function assumes the ancilla qubits will be the last in the circuit, should me changed otherwise
    circuit_qibo.add([gates.H(i) for i in range(nqubits)])
    circuit_qibo.add([gates.X(i) for i in range(nqubits)])
    # added H and X gates to all qubits

    circuit_qibo.add(gates.Z(nqubits - 1).controlled_by(*range(nqubits)[0 : len(range(nqubits - 1))]))
    # CZ to all qubits. Target qubit election does not matter

    circuit_qibo.add([gates.X(i) for i in range(nqubits)])
    circuit_qibo.add([gates.H(i) for i in range(nqubits)])
    # added X and H gates to all qubits

    

    return circuit_qibo

La función anterior es genérica: dado un circuito y un registro cuántico, esta función aplica un difusor de Grover en el registro. En la Fig. \ref{Fig_Imple_diffuser} el resultado de aplicar la función anterior sobre un circuito.

Veamos un ejemplo con esta función:

Qiskit

n = 6

quantum_reg = QuantumRegister(n)
classic_reg = ClassicalRegister(n)

circuit = QuantumCircuit(quantum_reg, classic_reg)

Grover_Diffuser(circuit, quantum_reg)

circuit.draw(output='mpl')

Qibo

n=6
circuit_qibo=Circuit(n)
print(grover_diffuser_qibo(circuit_qibo).draw())

/home/dcb/Programs/miniconda/miniconda3/envs/qiskit_qibo_penny_2/lib/python3.11/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to "iqp" in a following release. To silence this warning, specify the current default explicitly as style="clifford", or the new default as style="iqp".
  self._style, def_font_ratio = load_style(self._style)

../../../_images/c63bead7284f9f2ef3c08241393387e578694ad8450752f046d2fffc5edbc770.png

Oráculo “trivial”.#

Vamos a presentar en esta sección un código de para construir un oráculo que cambie el signo de los estados que nosotros le digamos. Este es uno de esos ejemplo típicos que se plantean cuando se habla de Grover, esos en los que sabemos con antelación los estados concretos que queremos buscar. De esta forma, el oráculo que construimos está hecho “ad hoc” para marcar ciertos estado. Precisamente elegimos llamarle a este caso “trivial” porque no entraña ningún misterio, sino que como comentamos, es un caso académico.

El código que se presenta a continuación es muy simple. Partimos de una lista de cadenas binarias de n bits que llamamos M_list_bin_qiskit. Por ejemplo, para \(n=5\)

(75)#\[\begin{equation} \text{M_list_bin_qiskit} = [\text{'} 01101 \text{'}, \text{'} 11000 \text{'}, ...] \end{equation}\]

Nota

Recordemos que en qiskit el bit menos significativo es que va arriaba en el circuito, así que el “qiskit” en el nombre de la lista M_list_bin_qiskit hace referencia que estamos mandando las cadenas el revés. Es decir, para pasarlas a decimal las invertimos:

\[ 01101 \quad \rightarrow \quad 10110 = 22, \qquad 11000 \quad \rightarrow \quad 00011 = 3 \]

Para cambiar el signo de un estado lo que tenemos que hacer es aplicar una MCZ. Como esta solo aplica sobre el estado \(|11\dots 1 \rangle\), lo que hay que hacer es aplicar puertas \(X\) antes y después del la MCZ en los qubit correspondientes a las posiciones donde tenemos un 0 en las cadenas bits.

Qiskit

def Grover_Oracle_trivial(circuit, target_reg, M_list_bin_qiskit): # n, M_list_bin):
    '''
    This function implements a Grover oracle. We call it "trivial" because this
    oracle change the sign of some given states. That is, we know the solution 
    in advance. (For example, we want to find the states |101> and |110> among 
    the 8 possible ones. We know from the begining the states we want to find.)

    We can use the multicontrolled Z gate (mcz) we defined earlier to change the
    sign of any M_list_bin[i] state. Simply apply X gates before and after the 
    mcz on the qubits that are worth zero in M_list_bin[i].

    IMPORTANT !!!: Remember that if we deal with qiskit, the binary strings have
    to 	come upside	down (with the LEASTE SIGNIFICANT BIT AT THE BEGINNING !!!).

    Inputs:
        - circuit: Quantum Circuit

        - target_reg: Quantum Register (with n qubits) in which we are going to 
            search and change the sign of some given states. It must be one 
            Quantum Register of the previus circuit.

        - M_list_bin: Python List with the states that we want to find. The 
            states must be in binary and must have length n (that is, if our 
            "targer_reg" has 4 qubits and we want to find the state |2>, we have
            to pass in this list the number "0010", not "10" !!!)

    '''
    n = target_reg.size

    for m in M_list_bin_qiskit:
        for i in range(len(m)):
            if m[i] == '0':
                circuit.x(target_reg[i])

        mcz(circuit, target_reg[list(range(n-1))], target_reg[n-1])

        for i in range(len(m)):
            if m[i] == '0':
                circuit.x(target_reg[i])

Qibo

def Grover_oracle_trivial_qibo(circuit_qibo, M_list_bin_qibo):
    """
    This functions generates a Grover oracle that phase-tags a list of binary numbers.
    Each number get tagged by a CZ gate applied to all qubits and X gates applied before and after the CZ to the qubits corresponding with '0's in each binary number.

    Inputs:
    ------
        - nqubits: `int`. Number of qubits of the circuit
        - list_desired: `list` of `ints`. The binary form of each int must fit in nqubits bits

    Outputs:
    ------
        - oracle: `circuit`, that phase-tags the desired states
        
    """
    nqubits=circuit_qibo.nqubits
    oracle = Circuit(nqubits)  #starts an empty circuit of nqubits

    for b in M_list_bin_qibo:
        for j, i in enumerate(b): 
            #add a X gate to each qubit corresponding with '0' in the binary number
            if i == "0": 
                oracle.add(gates.X(j))

        oracle.add(gates.Z(nqubits - 1).controlled_by(*range(nqubits)[0 : len(range(nqubits - 1))]))  
        # CZ to all qubits. Target qubit election does not matter

        for j, i in enumerate(b): 
            #add a X gate to each qubit corresponding with '0' in the binary number
            if i == "0":
                oracle.add(gates.X(j))
    circuit_qibo=circuit_qibo+oracle
    return circuit_qibo

Veamos un ejemplo con este código:

Qiskit

# We import functions from the scripts in ..\..\Code folder
n = 5

quantum_reg = QuantumRegister(n)
classic_reg = ClassicalRegister(n)

circuit = QuantumCircuit(quantum_reg, classic_reg)

M_list_bin = [ '01101', '11000']

Grover_Oracle_trivial(circuit, quantum_reg, M_list_bin)

circuit.draw(output='mpl', filename = 'Fig_Imple_oracle_trivial')

Qibo

M_list_bin = [ '01101', '11000']
#To get the same result with Qibo as with Qiskit, we must flip the order of bits in the strings:
M_list_bin_qibo=[i[::-1]for i in (M_list_bin)]


n=5
circuit_qibo=Circuit(n)
print(Grover_oracle_trivial_qibo(circuit_qibo,M_list_bin_qibo).draw())

../../../_images/4eeedbfc4b42c29645c834d2e975cd31a835818fe6c38d922baf1fe555355820.png

8. Implementación

Contents

8. Implementación#

Puerta multicontrolada \(Z\) (MCZ).#

Difusor genérico.#

Oráculo “trivial”.#

Oráculos que verifican condiciones.#

Sudoku 2x2#

El sudoku#

Condiciones y puerta XOR#

Simulación#