Docs
Ir a plataforma

Fundamento teórico Grover

Autor

Retrato de Noguerón Méndez José Antonio
Noguerón Méndez José Antonio Head of Quantum Product

Búsqueda de Grover: amplificación de amplitud y complejidad de consulta oracular

El algoritmo de Grover, propuesto por Lov Grover en 1996, resuelve el problema de búsqueda en bases de datos no ordenadas con una complejidad de \(\mathcal{O}(\sqrt{N})\) consultas al oráculo, frente a las \(\mathcal{O}(N)\) que requiere cualquier algoritmo clásico en el peor caso. Aunque la ventaja es cuadrática en lugar de exponencial, su campo de aplicación es vasto: optimización combinatoria, criptoanálisis, búsqueda de colisiones en funciones hash y aceleración de otros algoritmos cuánticos mediante la técnica de amplificación de amplitud generalizada.

Geométricamente, cada iteración \(G = \mathcal{D}\mathcal{O}\) actúa como una rotación en el plano bidimensional engendrado por el estado uniforme \(|s\rangle\) y la superposición de estados marcados; el ángulo inicial \(\theta = \arcsin(1/\sqrt{N})\) determina la velocidad de precesión hacia el objetivo. En el límite de \(N\) grande, el número óptimo de iteraciones \(\lfloor \pi\sqrt{N}/4 \rfloor\) sigue siendo \(\Theta(\sqrt{N})\), y Bennett et al. probaron que ningún algoritmo cuántico basado en oráculo puede mejorar el orden \(\Omega(\sqrt{N})\) para búsqueda no estructurada. Los histogramas obtenidos en HarmoniQ permiten contrastar esa predicción ideal con modelos de ruido de puerta en registros pequeños.

Intermedio 2 cúbits 11 puertas 1 iteración Hopper / Hermann

Fundamento teórico

El problema de búsqueda no estructurada

Sea \(\mathcal{X} = \{0, 1, \ldots, N-1\}\) un espacio de búsqueda de \(N = 2^n\) elementos y \(f: \mathcal{X} \to \{0,1\}\) una función que marca exactamente un elemento \(x^* \in \mathcal{X}\) con \(f(x^*) = 1\). El objetivo es encontrar \(x^*\) consultando al oráculo \(\mathcal{O}_f\) el mínimo número de veces.

Cualquier algoritmo clásico (determinista o probabilístico) necesita \(\Omega(N)\) consultas para localizar \(x^*\) con alta probabilidad. El algoritmo de Grover requiere únicamente \(\mathcal{O}(\sqrt{N})\) consultas, lo que para \(N = 2^{64}\) representa la diferencia entre \(10^{19}\) y \(\approx 4 \times 10^9\) operaciones.

Amplificación de amplitud

El algoritmo opera iterando dos operadores unitarios sobre el estado inicial de superposición uniforme \(|s\rangle = H^{\otimes n}|0\rangle^{\otimes n} = \frac{1}{\sqrt{N}}\sum_{x}|x\rangle\).

Operador oráculo \(\mathcal{O}\): refleja la fase del estado marcado: \[ \mathcal{O}|x\rangle = (-1)^{f(x)}|x\rangle. \] Geometricamente, esta operación invierte el signo de la componente \(|x^*\rangle\), separándola de la superposición uniforme.

Operador de difusión de Grover \(\mathcal{D}\): realiza la inversión alrededor de la media de las amplitudes: \[ \mathcal{D} = 2|s\rangle\langle s| - I = H^{\otimes n}(2|0\rangle\langle 0| - I)H^{\otimes n}. \] Esta operación amplifica la amplitud del estado marcado a expensas de los estados no marcados. Cada iteración \(G = \mathcal{D} \circ \mathcal{O}\) incrementa la amplitud de \(|x^*\rangle\) en un factor \(\approx \sqrt{N}^{-1}\).

Número óptimo de iteraciones

Después de \(k\) iteraciones de \(G\), la probabilidad de medir \(|x^*\rangle\) es: \[ P(x^*) = \sin^2\!\left((2k+1)\theta\right), \quad \theta = \arcsin\!\left(\frac{1}{\sqrt{N}}\right). \] El número óptimo de iteraciones que maximiza \(P(x^*)\) es: \[ k^* = \left\lfloor\frac{\pi}{4}\sqrt{N}\right\rfloor. \] Para \(N = 4\) (\(n = 2\) cúbits), \(k^* = 1\) y la probabilidad teórica de éxito es exactamente \(1\) (no hay error de búsqueda en el caso ideal). Esta propiedad hace del caso de 2 cúbits el ejemplo pedagógico ideal para introducir Grover sin el factor de aproximación presente en espacios de mayor dimensión.

Geometría en el plano de Grover y error por sobriteración

Sea \(\mathcal{A}\) el subespacio de dimensión dos generado por \(|w\rangle\) (estado marcado normalizado) y \(|s'\rangle\), la superposición uniforme sobre los estados no marcados. El operador de Grover restringido a \(\mathcal{A}\) es una rotación de ángulo \(2\theta\) en dirección determinada por la composición de reflexión respecto de \(|s\rangle\) y respecto de \(|w\rangle\). Por ello, aplicar \(G\) más veces de lo óptimo «pasa de largo» el objetivo y la probabilidad de éxito disminuye; este fenómeno es observable numéricamente al variar el número de iteraciones en simuladores.

Para \(N=4\) y una solución, \(\theta = \pi/6\) y una única iteración alcanza probabilidad unitaria en el modelo ideal; el ejemplo de dos cúbits de esta guía es, por tanto, el caso marginal donde la aproximación continua coincide exactamente con la dinámica finita.

Cota inferior cuántica y marco de amplificación de amplitud

Bennett, Bernstein, Brassard y Vazirani demostraron que, para búsqueda no estructurada en el modelo de oráculo, \(\Omega(\sqrt{N})\) consultas son necesarias incluso para algoritmos cuánticos. Grover alcanza asintóticamente esa cota, de modo que el algoritmo es óptimo en orden de magnitud. La generalización de Brassard–Høyer–Mosca–Tapp encapsula \(G\) dentro de la amplificación de amplitud, subrutina estándar en estimación de fase y conteo cuántico.

\[ G = (2|s\rangle\langle s| - I)(I - 2|w\rangle\langle w|), \qquad |s\rangle = \frac{1}{\sqrt{N}}\sum_x |x\rangle. \]

Circuito cuántico (2 cúbits, búsqueda de \(|11\rangle\))

El circuito busca el elemento marcado \(x^* = |11\rangle\) en el espacio \(\{|00\rangle, |01\rangle, |10\rangle, |11\rangle\}\). Con \(N=4\) y \(k^*=1\), la probabilidad de éxito es 1 en el caso ideal.

El oráculo de fase para \(|11\rangle\) es la puerta CZ (Z controlada): aplica una fase \(-1\) al estado \(|11\rangle\) y deja invariantes los demás. El operador de difusión se descompone en la secuencia \(H^{\otimes 2} \cdot X^{\otimes 2} \cdot \text{CZ} \cdot X^{\otimes 2} \cdot H^{\otimes 2}\).

┌──────────────┐ ┌──────────────────────────┐ q₀: ─[H]──────────┤ Oráculo ├──┤ Difusión ├── ┤M├ q₁: ─[H]──────────┤ CZ ├──┤ H·X·CZ·X·H ├── ┤M├ └──────────────┘ └──────────────────────────┘ Descomposición completa de las 11 puertas: q₀: [H] ─── ─── [H] [X] ─── ─── [X] [H] ─── ┤M├ q₁: [H] ─── Z ─── [H] [X] ─── Z ─── [X] [H] ─── ┤M├ Super. Oráculo ─────── Difusión ───────

Superposición: H en \(q_0\) y \(q_1\) prepara la superposición uniforme \(\frac{1}{2}(|00\rangle + |01\rangle + |10\rangle + |11\rangle)\).

Oráculo (CZ): aplica fase \(-1\) a \(|11\rangle\), produciendo \(\frac{1}{2}(|00\rangle + |01\rangle + |10\rangle - |11\rangle)\).

Difusión: la secuencia \(H^{\otimes 2} \cdot X^{\otimes 2} \cdot \text{CZ} \cdot X^{\otimes 2} \cdot H^{\otimes 2}\) implementa la reflexión alrededor del estado promedio, amplificando \(|11\rangle\) a amplitud 1 en una sola iteración.

Implementación en HarmoniQ

La secuencia completa de 11 puertas implementa: superposición inicial (2 H), oráculo CZ (1 CZ), y difusión de Grover (2 H + 2 X + 1 CZ + 2 X + 2 H = 9 puertas), sumando en total 11 operaciones unitarias. Se utiliza la puerta "cz" del SDK para la puerta Z controlada.

Swift

Grover.swift

import HarmoniQ

// Búsqueda de |11⟩ en {|00⟩, |01⟩, |10⟩, |11⟩} — 1 iteración de Grover
let gates: [Gate] = [
    // 1. Superposición uniforme
    Gate(name: "h",  targets: [0]),
    Gate(name: "h",  targets: [1]),
    // 2. Oráculo: CZ marca |11⟩ con fase −1
    Gate(name: "cz", targets: [1], controls: [0]),
    // 3. Difusión de Grover: H·X·CZ·X·H
    Gate(name: "h",  targets: [0]),
    Gate(name: "h",  targets: [1]),
    Gate(name: "x",  targets: [0]),
    Gate(name: "x",  targets: [1]),
    Gate(name: "cz", targets: [1], controls: [0]),
    Gate(name: "x",  targets: [0]),
    Gate(name: "x",  targets: [1]),
    Gate(name: "h",  targets: [0]),
    Gate(name: "h",  targets: [1]),
]

do {
    let result = try await HarmoniQ.quantum.executeCircuit(
        provider: "hopper",
        shots:    1024,
        qubits:   2,
        bits:     2,
        gates:    gates,
        basis:    "Z"
    )
    // Esperado: "|11" con probabilidad ≈ 1
    print("Elemento encontrado:", result.mostFrequent)
    print("Distribución:", result.counts)
} catch {
    print("Error:", error)
}

Kotlin

Grover.kt

import com.planq.harmoniq.HarmoniQ
import com.planq.harmoniq.model.Gate

val gates = listOf(
    // Superposición
    Gate(name = "h",  targets = listOf(0)),
    Gate(name = "h",  targets = listOf(1)),
    // Oráculo
    Gate(name = "cz", targets = listOf(1), controls = listOf(0)),
    // Difusión
    Gate(name = "h",  targets = listOf(0)),
    Gate(name = "h",  targets = listOf(1)),
    Gate(name = "x",  targets = listOf(0)),
    Gate(name = "x",  targets = listOf(1)),
    Gate(name = "cz", targets = listOf(1), controls = listOf(0)),
    Gate(name = "x",  targets = listOf(0)),
    Gate(name = "x",  targets = listOf(1)),
    Gate(name = "h",  targets = listOf(0)),
    Gate(name = "h",  targets = listOf(1)),
)

viewModelScope.launch {
    val result = HarmoniQ.quantum.executeCircuit(
        provider = "hopper",
        shots    = 1024,
        qubits   = 2,
        bits     = 2,
        gates    = gates,
        basis    = "Z"
    )
    Log.d("Grover", "Encontrado: ${result.mostFrequent}")
    Log.d("Grover", "Distribución: ${result.counts}")
}

React / TypeScript

grover.ts

import { HarmoniQ } from './lib/quantum'
import type { Gate } from '@planq/harmoniq'

const gates: Gate[] = [
  // Superposición
  { name: 'h',  targets: [0] },
  { name: 'h',  targets: [1] },
  // Oráculo: marca |11⟩
  { name: 'cz', targets: [1], controls: [0] },
  // Difusión de Grover
  { name: 'h',  targets: [0] },
  { name: 'h',  targets: [1] },
  { name: 'x',  targets: [0] },
  { name: 'x',  targets: [1] },
  { name: 'cz', targets: [1], controls: [0] },
  { name: 'x',  targets: [0] },
  { name: 'x',  targets: [1] },
  { name: 'h',  targets: [0] },
  { name: 'h',  targets: [1] },
]

const result = await HarmoniQ.quantum.executeCircuit({
  provider: 'hopper',
  shots:    1024,
  qubits:   2,
  bits:     2,
  gates,
  basis:    'Z',
})
// Esperado: "11" con alta probabilidad
console.log('Encontrado:', result.mostFrequent)
console.log('Distribución:', result.counts)

Python

grover.py

from harmoniq import HarmoniQ, Gate

gates = [
    # Superposición
    Gate(name="h",  targets=[0]),
    Gate(name="h",  targets=[1]),
    # Oráculo: marca |11⟩ con fase −1
    Gate(name="cz", targets=[1], controls=[0]),
    # Difusión de Grover
    Gate(name="h",  targets=[0]),
    Gate(name="h",  targets=[1]),
    Gate(name="x",  targets=[0]),
    Gate(name="x",  targets=[1]),
    Gate(name="cz", targets=[1], controls=[0]),
    Gate(name="x",  targets=[0]),
    Gate(name="x",  targets=[1]),
    Gate(name="h",  targets=[0]),
    Gate(name="h",  targets=[1]),
]

result = HarmoniQ.quantum.execute_circuit(
    provider="hopper",
    shots=1024,
    qubits=2,
    bits=2,
    gates=gates,
    basis="Z",
)

print("Elemento encontrado:", result.most_frequent)  # "11"
print("Distribución:", result.counts)

# En Jupyter: result.plot_histogram()

Análisis de resultados

Para el caso de 2 cúbits con un único elemento marcado, la única iteración de Grover debería producir el estado \(|11\rangle\) con probabilidad teórica 1. Los resultados típicos con el backend Hopper son:

EstadoProbabilidad idealConteo típico (1024 shots)
|11⟩ (marcado)1.000940 – 1024
|00⟩0.0000 – 20
|01⟩0.0000 – 20
|10⟩0.0000 – 20

El circuito de Grover emplea 11 puertas, de las cuales 2 son CZ (puertas de dos cúbits). La fidelidad acumulada por error de puerta es aproximadamente: \[ F_{\text{total}} \approx F_{1Q}^{9} \cdot F_{2Q}^{2} \approx 0.998^{9} \times 0.985^{2} \approx 0.952, \] donde \(F_{1Q} = 0.998\) y \(F_{2Q} = 0.985\) son las fidelidades de puerta de Hopper. Esto explica por qué el conteo de |11⟩ se sitúa entre 940 y 1024 en lugar de 1024 exacto.

Para buscar un elemento diferente, basta con modificar el oráculo. Por ejemplo, para marcar \(|00\rangle\), el oráculo sería X⊗X, CZ, X⊗X (aplica X antes y después del CZ para trasladar la fase al estado \(|00\rangle\)).

Referencias y lecturas recomendadas

La selección siguiente orienta al lector hacia monografías y recursos cuya rigurosidad ha sido contrastada por la comunidad científica; complementa la bibliografía citada al pie de esta guía.

Bibliografía citada

  1. [1]
    Grover, L. K. (1996). A fast quantum mechanical algorithm for database search. Proceedings of the 28th Annual ACM Symposium on Theory of Computing (STOC), 212–219.
  2. [2]
    Grover, L. K. (1997). Quantum mechanics helps in searching for a needle in a haystack. Physical Review Letters, 79(2), 325–328.
  3. [3]
    Brassard, G., Høyer, P., Mosca, M., & Tapp, A. (2002). Quantum amplitude amplification and estimation. Contemporary Mathematics, 305, 53–74.
  4. [4]
    Nielsen, M. A., & Chuang, I. L. (2010). Quantum Computation and Quantum Information. Cambridge University Press. Sección 6.1.
  5. [5]
    Bennett, C. H., Bernstein, E., Brassard, G., & Vazirani, U. (1997). Strengths and Weaknesses of Quantum Computing. SIAM Journal on Computing, 26(5), 1510–1523.

Descargar artículo

Título
Búsqueda de Grover: amplificación de amplitud y complejidad de consulta oracular
Fecha de elaboración
Autores
Noguerón Méndez José Antonio Head of Quantum Product
Descargar artículo