Algoritmo cuántico para sistemas lineales de ecuaciones (HHL09): Paso 2 - Preparación de los estados iniciales

^{Esta es una continuación del algoritmo cuántico para sistemas de ecuaciones lineales (HHL09): Paso 2: ¿Qué es ? $|\Psi_0\rangle$}

En el documento: Algoritmo cuántico para sistemas lineales de ecuaciones (Harrow, Hassidim y Lloyd, 2009) , no se proporcionan los detalles de la implementación real del algoritmo. Cómo exactamente se los estados y , es una especie de " recuadro negro " (consulte las páginas 2-3). $|\Psi_0\rangle$ $|b\rangle$

| Ψ_{0} ⟩ = \sqrt{\frac{2}{T}} \sum_{τ = 0}^{T - 1} \sin \frac{π (τ + \frac{1}{2})}{T} | τ ⟩

$|\Psi_0\rangle = \sqrt{\frac{2}{T}}\sum_{\tau = 0}^{T-1}\sin \frac{\pi (\tau+\frac{1}{2})}{T}|\tau\rangle$

| b ⟩ = \sum_{1}^{N} b_{i} | i ⟩

$|b\rangle = \sum_{1}^{N}b_i|i\rangle$

donde es el estado inicial del registro del reloj y es el estado inicial del registro de entrada. $|\Psi_0\rangle$ $|b\rangle$

(Diga) Quiero llevar a cabo su algoritmo en la computadora cuántica IBM de bits. $16$ Y quiero resolver una determinada ecuación donde es una matriz hermitiana con entradas reales y es un vector de columna con entradas reales. $\mathbf{Ax=b}$ $\mathbf{A}$ $4\times 4$ $\mathbf{b}$ $4\times 1$

Tomemos un ejemplo:

A = [\begin{matrix} 1 & 2 & 3 & 4 \\ 2 & 1 & 5 & 6 \\ 3 & 5 & 1 & 7 \\ 4 & 6 & 7 & 1 \end{matrix}]

$\mathbf{A} = \begin{bmatrix} 1 & 2 & 3 & 4 \\ 2 & 1 & 5 & 6 \\ 3 & 5 & 1 & 7 \\ 4 & 6 & 7 & 1 \end{bmatrix}$

b = [\begin{matrix} 1 \\ 2 \\ 3 \\ 4 \end{matrix}]

$\mathbf{b}=\begin{bmatrix} 1 \\ 2 \\ 3 \\ 4 \end{bmatrix}$

Dadas las dimensiones de y , deberíamos necesitar qubits para el registro de entrada y otros qubits para el registro de reloj, suponiendo que queremos que los valores propios sean representado con precisión del y una precisión de hasta bits para los valores propios (esto se ha discutido aquí anteriormente). Por lo tanto , se necesitarán qubits para este propósito (el qubit adicional es el ancilla). $\mathbf{A}$ $\mathbf{b}$ $\lceil{\log_2 4\rceil}=2$ $6$ $90\%$ $3$ $2+6+1=9$ $1$

Preguntas:

Con esta información, ¿es posible crear los estados iniciales y en el IBM versión qubit? $|\Psi_0\rangle$ $|b\rangle$ $16$
Si cree que es demasiado grande para implementarse en las computadoras cuánticas de IBM, incluso podría mostrar un ejemplo de preparación de estado inicial para una matriz Hermitian (o simplemente dar una referencia a dicho ejemplo). $4\times 4$ $2\times 2$ $\mathbf{A}$

Simplemente quiero tener una idea general sobre si esto se puede hacer (es decir, si es posible) en la computadora cuántica IBM de 16 qubits y para qué puertas serán necesarias. Si no es la computadora cuántica IBM de 16 qubits, ¿puede el simulador QISKit utilizado para recrear la preparación del estado inicial de y en el algoritmo de HHL? ¿Hay alguna otra alternativa mejor para hacer esto? $|\Psi_0\rangle$ $|b\rangle$

— Sanchayan Dutta
fuente

Hasta donde sé, IBM no puede hacer HHL porque implica hacer cosas en una superposición de diferentes tiempos, pero no me sorprendería si me equivoco. @ James Woottoon podría conocer mejor la respuesta.

— user1271772

@ user1271772 Yo también lo pensé, pero soy un poco escéptico porque alguien me dijo en el chat que simuló el HHL para

después de esto , en IBM.

4 \times 4

$4\times 4$

— Sanchayan Dutta

Bueno, tal vez la Fig. 4 del artículo de Yudong Cao (el que vinculaste) es todo lo que necesitas entonces.

— user1271772

@ user1271772 Sí, pero desafortunadamente, eso solo funcionaría para esa matriz en particular. Estoy buscando una técnica general, para la cual probablemente debería leer ese documento más a fondo.

— Sanchayan Dutta

Como John Watrous lo puso en uno de sus comentarios a una pregunta en la que alguien preguntaba por un circuito específico, "estás pidiendo que la gente haga un trabajo tedioso pero conceptualmente poco interesante". Yudong era un estudiante universitario de ingeniería cuando hizo estos circuitos. Él no tenía más entrenamiento que usted (de hecho, en base a su rápido progreso, probablemente sepa más sobre computación cuántica que él al momento de escribir ese documento). Si él pudiera hacer este circuito, debería poder hacer el circuito correspondiente para cualquier ejemplo de HHL que se presente frente a usted.

— user1271772

Respuestas:

No es posible crear los estados iniciales y en el IBM versión de 16 qubits. Por otro lado, es posible aproximarlos con un error arbitrariamente bajo ¹ ya que las puertas implementadas por los chips de IBM ofrecen esta posibilidad. $\left| \Psi_0\right>$ $\left|b\right>$

Aquí pides 2 estados cuánticos diferentes:

no está restringida en absoluto. El estado está representado por un vector de números complejos que pueden ser cualquier cosa (siempre que el vector tiene norma unitaria). $\left| b \right>$ $\left| b \right>$ $N$
$\left| \Psi_0 \right>$ $\left| b \right>$ $b_i$

$\left|b\right>$ $\left| \Psi_0 \right>$ $\left| \Psi_0 \right>$ $\left| \Psi_0 \right>$

$\left|b\right>$ $\left|\Psi_0\right>$

$\left|\Psi_0\right>$ $\left|\Psi_0\right>$

Para la implementación en QISKit, aquí hay una muestra para inicializar un estado cuántico dado:

import qiskit

statevector_backend = qiskit.get_backend('local_statevector_simulator')

###############################################################
# Make a quantum program for state initialization.
###############################################################
qubit_number = 5
Q_SPECS = {
    "name": "StatePreparation",
    "circuits": [
        {
            "name": "initializerCirc",
            "quantum_registers": [{
                "name": "qr",
                "size": qubit_number
            }],
            "classical_registers": [{
                "name": "cr",
                "size": qubit_number
            }]},
    ],
}
Q_program = qiskit.QuantumProgram(specs=Q_SPECS)

## State preparation
import numpy as np
from qiskit.extensions.quantum_initializer import _initializer

def psi_0_coefficients(qubit_number: int):
    T = 2**qubit_number
    tau = np.arange(T)
    return np.sqrt(2 / T) * np.sin(np.pi * (tau + 1/2) / T)

def get_coeffs(qubit_number: int):
    # Can be changed to anything, the initialize function will take
    # care of the initialisation.
    return np.ones((2**qubit_number,)) / np.sqrt(2**qubit_number)
    #return psi_0_coefficients(qubit_number)

circuit_prep = Q_program.get_circuit("initializerCirc")
qr = Q_program.get_quantum_register("qr")
cr = Q_program.get_classical_register('cr')
coeffs = get_coeffs(qubit_number)
_initializer.initialize(circuit_prep, coeffs, [qr[i] for i in range(len(qr))])

res = qiskit.execute(circuit_prep, statevector_backend).result()
statevector = res.get_statevector("initializerCirc")
print(statevector)

¹ Aquí "error" se refiere al error entre el estado ideal y la aproximación cuando se trata de una computadora cuántica perfecta (es decir, sin decoherencia, sin error de puerta).

— Nelimee
fuente

El algoritmo HHL con una matriz A de 4 x 4 podría ser demasiado grande para la computadora IBM. Probé una versión de juguete más pequeña del algoritmo de acuerdo con el enlace arXiv 1302.1210 Resolución de sistemas de ecuaciones lineales

Le expliqué un poco sobre este circuito aquí en stackexchange: /cs/76525/could-a-quantum-computer-perform-linear-algebra-faster-than-a-classical-computer/ 77036 # 77036

Desafortunadamente, es solo una entrada de 1 qubit con una matriz A = 2 x 2, en la respuesta se proporciona un enlace al circuito de IBM.

— Bram
fuente

El problema con la implementación de 4x4 HHL no es el número de qubits (se necesitan 7 qubits) sino las tasas de error de las puertas cuánticas y los tiempos de decoherencia. Una implementación de un sistema 4x4 usando QISKit está disponible aquí . La implementación sigue a arxiv.org/abs/1110.2232v2 .

— Nelimee

Gran implementación de un 4 x 4 HHL.

— Bram