[PYTHON] Qiskit: Implementierung von Quantenhypergraphzuständen

Einführung

Wenn Sie Quantenberechnungen durchführen, möchten Sie möglicherweise den Anfangszustand in der gewünschten Form erhalten. Insbesondere scheint es für quantenneurale Netze notwendig zu sein.

was, wenn

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

Wäre es nicht bequem, wenn Sie schnell die Kombination der Tore finden könnten? Die Idee, dies zu erreichen, ist Quantum Hypergraph State.

Weitere Informationen finden Sie unter Quantenhypergraph-Status.

Quantum Hypergraph states

Ich möchte kurz die Zustände des Quantenhypergraphen erläutern.

\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. Wenn $ | 0 ... 1 ... 0> $ mit einem Koeffizienten von $ -1 $ existiert, wird das Z-Gatter auf das Qubit mit $ 1 $ angewendet.
  2. Aktualisieren Sie den Koeffizienten.
  3. Wenn $ | 0 ... 1 ... 1 ... 0> $ mit einem Koeffizienten von $ -1 $ existiert, wird das CZ-Gatter auf das Qubit mit $ 1 $ angewendet.
  4. Aktualisieren Sie den Koeffizienten.
  5. Wenn $ | 0 ... 1 ... 1 ... 1 ... 0> $ mit einem Koeffizienten von $ -1 $ existiert, wird das CCZ-Gatter auf das Qubit mit $ 1 $ angewendet.

Für 3 Qubit ergibt dies alle Koeffizienten 1.

Beispiel

\frac{|000>+|001>-|010>+|011>-|100>-|101>+|110>+|111>}{2 \sqrt{2}}
  1. |010>Wann|100>Der Koeffizient von-1なので、第二qubitWann第三qubitにZ gateを作用させます。その結果、
\frac{|000>+|001>+|010>-|011>+|100>+|101>+|110>+|111>}{2 \sqrt{2}}
  1. Da der Koeffizient von $ | 011> $ $ -1 $ ist, lassen Sie das CZ-Gate am ersten und am zweiten Qubit arbeiten. als Ergebnis,
\frac{|000>+|001>+|010>+|011>+|100>+|101>+|110>-|111>}{2 \sqrt{2}}
  1. Da der Koeffizient von $ | 111> $ -1 $ ist, lassen Sie das CCZ-Gate am 1. Qubit, 2. Qubit und 3. Qubit arbeiten. als Ergebnis,
\frac{|000>+|001>+|010>+|011>+|100>+|101>+|110>+|111>}{2 \sqrt{2}}

Dies ist das Ende des Schaltungsaufbaus.

qhgs.png

Code

Der Code lautet wie folgt. Um ehrlich zu sein, bin ich nicht gut in Python, daher kann es zu Verschwendung kommen. Ich würde mich freuen, wenn Sie mir sagen könnten, ob es eine effiziente Art zu schreiben gibt. Übrigens, diesmal sind es bis zu 3 Qubit, aber ich denke, Sie können es so weit erhöhen, wie Sie möchten.

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):
            #Schleife für Zustände
            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'))

das ist alles. Vielen Dank.

Nachtrag

Ich habe einen Fehler ausgespuckt und ihn aktualisiert: 2020/04/12

Recommended Posts

Qiskit: Implementierung von Quantenhypergraphzuständen
Qiskit: Implementierung einer Quantenbolzenmaschine
Qiskit: Implementierung von Quantum Circuit Learning (QCL)
Quantum Computer Implementierung von Quantum Walk 2
Quantum Computer Implementierung von Quantum Walk 3
Quantum Computer Implementierung von Quantum Walk 1
Quantencomputer-Implementierung eines 3-Zustands-Quantenlaufs
Qiskit: Implementierung von QAOA ohne Qiskit Aqua
Qiskit: Realisierung künstlicher Neuronen mit Quantenschaltungen (Implementierung)
Quantenteleportation mit Qiskit!
Implementierung der Fibonacci-Sequenz
Qiskit: Quanten-Fourier-Transformation
Implementierung von TF-IDF mit Gensim
Implementierung von MathJax auf Sphinx
Erklärung und Implementierung von SocialFoceModel
Implementierung der Spieltheorie - Gefangenendilemma -
Implementierung einer unabhängigen Komponentenanalyse
Python-Implementierung des Partikelfilters
Implementierung der schnellen Sortierung in Python
Tiefes Lernen der Verstärkung 2 Implementierung des Lernens der Verstärkung
Implementierung von Scale-Space für SIFT