Qiskit: Implémentation des états d'hypergraphes quantiques

introduction

Lors de l'exécution de calculs quantiques, vous souhaiterez peut-être obtenir l'état initial sous la forme souhaitée. Surtout, cela semble nécessaire pour les réseaux de neurones quantiques.

Et qu'est-ce qui se passerait si

\frac{|000>+|001>-|010>+|011>-|100>-|101>+|110>+|111>}{2 \sqrt{2}}

Ne serait-il pas pratique de trouver rapidement la combinaison de portails à réaliser? L'idée pour y parvenir est l'état d'hypergraphe quantique.

Voir États de l'hypergraphe quantique pour plus d'informations.

Quantum Hypergraph states

Je voudrais expliquer brièvement les états de l'hypergraphe quantique.

\frac{i_0|000>+i_1|001>+i_2|010>+i_3|011>+i_4|100>+i_5|101>+i_6|110>+i_7|111>}{2 \sqrt{2}}  \\
i_k = -1 \ or \ 1
  1. Quand $ | 0 ... 1 ... 0> $ avec un coefficient de $ -1 $ existe, la porte Z est appliquée au qubit avec $ 1 $.
  2. Mettez à jour le coefficient.
  3. Quand $ | 0 ... 1 ... 1 ... 0> $ avec un coefficient de $ -1 $ existe, la porte CZ est appliquée au qubit avec $ 1 $.
  4. Mettez à jour le coefficient.
  5. Quand $ | 0 ... 1 ... 1 ... 1 ... 0> $ avec un coefficient de $ -1 $ existe, la porte CCZ est appliquée au qubit avec $ 1 $.

Pour 3qubit, cela rend tous les coefficients 1.

Exemple

\frac{|000>+|001>-|010>+|011>-|100>-|101>+|110>+|111>}{2 \sqrt{2}}
  1. |010>Quand|100>Le coefficient de-1なので、第二qubitQuand第三qubitにZ gateを作用させます。その結果、
\frac{|000>+|001>+|010>-|011>+|100>+|101>+|110>+|111>}{2 \sqrt{2}}
  1. Puisque le coefficient de $ | 011> $ est $ -1 $, laissez CZ gate travailler sur le premier qubit et le deuxième qubit. Par conséquent,
\frac{|000>+|001>+|010>+|011>+|100>+|101>+|110>-|111>}{2 \sqrt{2}}
  1. Puisque le coefficient de $ | 111> est $ -1 $, laissez CCZ gate travailler sur le 1er qubit, le 2ème qubit et le 3ème qubit. Par conséquent,
\frac{|000>+|001>+|010>+|011>+|100>+|101>+|110>+|111>}{2 \sqrt{2}}

C'est la fin de la construction du circuit.

qhgs.png

Code

Le code est comme suit. Pour être honnête, je ne suis pas bon en Python, il peut donc y avoir du gaspillage. J'apprécierais que vous me disiez s'il existe un moyen efficace d'écrire. Au fait, cette fois, c'est jusqu'à 3qubit, mais je pense que vous pouvez l'augmenter autant que vous le souhaitez.

python


# matplotlib inline
# coding: utf-8

import numpy as np
from math import log2
from copy import deepcopy
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.quantum_info.operators import Operator
import matplotlib.pyplot as plt


def count_ones_by_bin(num):
    bin_num = bin(num)[2:]
    count = 0
    for i in bin_num:
        count += int(i)
    return count


class QuantumHypergraphState:

    def __init__(self, numqubits, states, qubit_index=None):
        ''' make Quantum HyperGraph State in circuit
        :param circuit:
        :param numqubits: maximum 3
        :param states:
        '''
        self.numqubits = numqubits
        self.states = deepcopy(states)
        if qubit_index is None:
            self.index = [i for i in range(numqubits)]
        else:
            self.index = qubit_index

    def bin_length(self, num):
        bin_num = bin(num)[2:]
        dif_len = self.numqubits - len(bin_num)
        for i in range(dif_len):
            bin_num = '0' + bin_num
        return bin_num

    def get_z_tgt(self, num):
        bin_num = self.bin_length(num)[::-1]
        z_tgt = []
        for i in range(len(bin_num)):
            if int(bin_num[i]) == 1:
                z_tgt.append(i)
        return z_tgt

    def tgt_0(self, num, tgt):
        """
        e.g. tgt = [0]
             num = 011

        """
        bin_num = self.bin_length(num)[::-1]  # 011
        count = 0
        for i in range(len(bin_num)):
            if i in tgt:
                count += int(bin_num[i])
        if count == len(tgt):
            return True
        else:
            return False

    def renew_states(self, tgt):
        for st in range(len(self.states)):
            if self.tgt_0(st, tgt):
                self.states[st] *= -1

    def get_tgt_list(self, idx_list):
        tgt_list = []
        for i in range(len(idx_list)):
            tgt_list.append(self.index[idx_list[i]])
        return tgt_list

    def construct_circuit(self, circuit, inverse=False):
        ccz = Operator([[1, 0, 0, 0, 0, 0, 0, 0],
                        [0, 1, 0, 0, 0, 0, 0, 0],
                        [0, 0, 1, 0, 0, 0, 0, 0],
                        [0, 0, 0, 1, 0, 0, 0, 0],
                        [0, 0, 0, 0, 1, 0, 0, 0],
                        [0, 0, 0, 0, 0, 1, 0, 0],
                        [0, 0, 0, 0, 0, 0, 1, 0],
                        [0, 0, 0, 0, 0, 0, 0, -1]])
        if inverse:
            gate_list = []
        else:
            circuit.h(self.index)
        for num in range(1, self.numqubits + 1):
            #Boucle pour les états
            if num == 1:
                for st in range(len(self.states)):
                    if count_ones_by_bin(st) == num:
                        if self.states[st] == -1:
                            idx = int(log2(st))
                            tgt = self.index[idx]
                            if inverse:
                                gate_list.append(['z', [tgt]])
                            else:
                                circuit.z(tgt)
                            self.renew_states([idx])
            elif num == 2:
                for st in range(len(self.states)):
                    if count_ones_by_bin(st) == num:
                        if self.states[st] == -1:
                            idx_list = self.get_z_tgt(st)
                            tgt_list = self.get_tgt_list(idx_list)
                            if inverse:
                                gate_list.append(['cz', tgt_list])
                            else:
                                circuit.cz(tgt_list[0], tgt_list[1])
                            self.renew_states(idx_list)
            else:
                for st in range(len(self.states)):
                    if count_ones_by_bin(st) == num:
                        if self.states[st] == -1:
                            idx_list = self.get_z_tgt(st)
                            tgt_list = self.get_tgt_list(idx_list)
                            if inverse:
                                gate_list.append(['ccz', tgt_list])
                            else:
                                circuit.unitary(ccz, self.index, label='ccz')
                            self.renew_states(idx_list)

        if inverse:
            gate_list = gate_list[::-1]
            for gate in gate_list:
                if gate[0] == 'ccz':
                    circuit.unitary(ccz, self.index, label='ccz')
                if gate[0] == 'cz':
                    circuit.cz(gate[1][0], gate[1][1])
                if gate[0] == 'z':
                    circuit.z(gate[1][0])
            # circuit.h(self.index)
            circuit.x(self.index)
            return circuit
        else:
            return circuit

    def draw(self):
        print(self.qc.draw(output='mpl'))

c'est tout. Merci beaucoup.

Postscript

Je crachais une erreur alors je l'ai mise à jour: 2020/04/12

Recommended Posts

Qiskit: Implémentation des états d'hypergraphes quantiques
Qiskit: Implémentation de Quantum Boltsman Machine
Qiskit: mise en œuvre de l'apprentissage des circuits quantiques (QCL)
Implémentation informatique quantique de Quantum Walk 2
Implémentation informatique quantique de Quantum Walk 3
Implémentation informatique quantique de Quantum Walk 1
Implémentation informatique quantique de la marche quantique à 3 états
Qiskit: Implémentation de QAOA sans Qiskit Aqua
Qiskit: Réalisation de neurones artificiels avec des circuits quantiques (implémentation)
Téléportation quantique avec Qiskit!
Implémentation de la séquence de Fibonacci
Qiskit: Transformée de Fourier quantique
Implémentation de TF-IDF à l'aide de gensim
Implémentation de MathJax sur Sphinx
Explication et mise en œuvre de SocialFoceModel
Mise en œuvre de la théorie des jeux - Le dilemme du prisonnier -
Mise en œuvre d'une analyse de composants indépendante
Implémentation Python du filtre à particules
Implémentation du tri rapide en Python
Apprentissage par renforcement profond 2 Mise en œuvre de l'apprentissage par renforcement
Implémentation de Scale-Space pour SIFT