Síntesis de circuitos

qiskit.synthesis.synth_cnot_count_full_pmh(state, section_size=None)

Sintetizar circuitos lineales reversibles para arquitectura todo a todo utilizando el método de Patel, Markov y Hayes.

Esta función es una implementación del algoritmo de Patel, Markov y Hayes de [1] para la síntesis óptima de circuitos lineales reversibles para arquitectura todo-a-todo, como se especifica en una matriz $n \times n$.

Parámetros

• state (list[list[bool]] | ndarray[bool]) – $n \times n$ Matriz booleana invertible, que describe el estado del circuito de entrada.
• section_size (int | None) – El tamaño de cada sección en el algoritmo Patel-Markov-Hayes [1]. Si None se elige para ser $\max(2, \alpha\log_2(n))$ con $\alpha = 0.56$, que aproximadamente minimiza el límite superior en el número de operaciones de fila dado en [1] Ec. (3).

Devuelve

Un circuito sólo CX que implementa la transformación lineal.

Eleva

ValueError - Cuando section_size es mayor que el número de columnas.

Tipo de retorno

QuantumCircuit

Referencias

1. Patel, Ketan N., Igor L. Markov, y John P. Hayes, Optimal synthesis of linear reversible circuits, Quantum Information & Computation 8.3 (2008): 282-294. arXiv:quant-ph/0302002 [quant-ph]

qiskit.synthesis.synth_cnot_depth_line_kms(mat)

Sintetizar circuito lineal reversible para arquitecturas lineales de vecino más cercano utilizando el método Kutin, Moulton, Smithline.

Algoritmo de síntesis para circuitos lineales reversibles de [1], sección 7. Este algoritmo sintetiza cualquier circuito lineal reversible de $n$ qubits sobre una arquitectura lineal de vecino más cercano utilizando puertas CX con profundidad como máximo $5n$.

Parámetros

mat (ndarray[bool]) – Una matriz booleana invertible.

Devuelve

El circuito cuántico sintetizado.

Eleva

QiskitError - si mat no es invertible.

Tipo de retorno

QuantumCircuit

Referencias

1. Kutin, S., Moulton, D. P., Smithline, L., Computación a distancia, Chicago J. Theor. Comput. Sci., vol. 2007, (2007), arXiv:quant-ph/0701194

qiskit.synthesis.synth_cz_depth_line_mr(mat)

Síntesis de un circuito CZ para la conectividad del vecino más próximo lineal (LNN), basado en Maslov y Roetteler.

Nótese que este método invierte el orden de los qubits en el circuito, y devuelve un circuito que contiene CXGates y puertas de fase (SGate, SdgGate o ZGate).

Parámetros

mat (ndarray) – una matriz cuadrada de tipo booleano en la diagonal superior que representa el circuito CZ. mat[i][j]=1 for i<j representa una cz(i,j) puerta. Solo se lee el triángulo superior; la diagonal y el triángulo inferior no tienen ningún efecto.

Devuelve

Una implementación del circuito CZ de profundidad $2n+2$ para conectividad LNN.

Tipo de retorno

QuantumCircuit

Referencias

1. Dmitri Maslov, Martin Roetteler, Circuitos estabilizadores más cortos mediante la descomposición de Bruhat y transformaciones cuánticas de circuitos, arXiv:1705.09176.

qiskit.synthesis.synth_cx_cz_depth_line_my(mat_x, mat_z)

Síntesis conjunta de un circuito -CZ-CX- para conectividad de vecino más próximo lineal (LNN), con profundidad de 2 qubits como máximo 5n, basado en Maslov y Yang. Este método calcula el circuito CZ dentro del circuito CX mediante inserciones de puertas de fase.

Parámetros

• mat_z (ndarray) – una matriz simétrica booleana que representa un circuito CZ. mat_z[i][j]=1 representa una puerta cz(i,j)
• mat_x (ndarray) – una matriz booleana invertible que representa un circuito CX.

Devuelve

Una implementación de circuito de un circuito CX que sigue a un circuito CZ, denotado como circuito -CZ-CX-, en profundidad de dos qubits a lo sumo 5n, para conectividad LNN.

Tipo de retorno

QuantumCircuit

Referencias

1. Kutin, S., Moulton, D. P., Smithline, L., Computación a distancia, Chicago J. Theor. Comput. Sci., vol. 2007, (2007), arXiv:quant-ph/0701194
2. Dmitri Maslov, Willers Yang, Los circuitos CNOT necesitan poca ayuda para implementar transformaciones Clifford arbitrarias libres de Hadamard que generan, arXiv:2210.16195.

qiskit.synthesis.synth_cnot_phase_aam(cnots, angles, section_size=2)

Esta función es una implementación del algoritmo GraySynth de Amy, Azimadeh y Mosca.

GraySynth es un algoritmo heurístico descrito en [[1] ] para sintetizar redes de paridad pequeñas. Se inspira en los códigos Gray. Dado un conjunto de cadenas binarias $S$ (denominadas cnots «a continuación»), el algoritmo sintetiza una red de paridad para $S$ eligiendo repetidamente un índice $i$ para expandir y, a continuación, aplicando una recursión efectiva sobre los cofactores $S_0$ y $S_1$, que consisten en las cadenas $y \in S$, con $y_i = 0$ o $1$ respectivamente. A medida que se expande recursivamente un subconjunto $S$, se aplican cx puertas de manera que un bit de destino designado contenga la paridad (parcial) $\chi_y(x)$, donde $y_i = 1$ si y solo si $y'_i = 1$ para todo $y' \in S$. Si $S$ contiene un único elemento $\{y'\}$, entonces $y = y'$, y el bit de destino contiene el valor $\chi_{y'}(x)$ tal y como se desea.

En particular, en lugar de descomputar esta secuencia de cx (CNOT) compuertas cuando se termina de sintetizar un subconjunto $S$, el algoritmo mantiene la invariante de que las paridades restantes a computar se expresan sobre el estado actual de bits. Esto permite al algoritmo evitar el "retroceso" inherente a los métodos no basados en el cálculo.

El algoritmo se describe detalladamente en la sección 4 de [1].

Parámetros

• cnots (list[list[int]]) –

  Una matriz cuyas columnas son las paridades a sintetizar e. g.:

  [[0, 1, 1, 1, 1, 1],
   [1, 0, 0, 1, 1, 1],
   [1, 0, 0, 1, 0, 0],
   [0, 0, 1, 0, 1, 0]]

  corresponde a:

  x1^x2 + x0 + x0^x3 + x0^x1^x2 + x0^x1^x3 + x0^x1

• angles (list[str]) – Una lista que contiene todas las puertas de desfase que deben aplicarse, en el mismo orden que en cnots. Un número se interpreta como el ángulo de $p(angle)$, de lo contrario los elementos tienen que ser 't', 'tdg', 's', 'sdg' o 'z'.

• section_size (int) – El tamaño de cada sección en el algoritmo Patel-Markov-Hayes. section_size debe ser un factor del número de qubits.

Devuelve

El circuito cuántico descompuesto.

Eleva

QiskitError - cuando las dimensiones de cnots y angles no están alineadas.

Tipo de retorno

QuantumCircuit

Referencias

1. Matthew Amy, Parsiad Azimzadeh y Michele Mosca. Sobre la complejidad controlada-NOT de los circuitos de fase controlada-NOT., Ciencia y tecnología cuánticas 4.1 (2018): 015002. arXiv:1712.01859

qiskit.synthesis.synth_permutation_depth_lnn_kms(pattern)

Sintetizar un circuito de permutación para una arquitectura lineal de vecino más cercano utilizando el método Kutin, Moulton, Smithline.

Este es el algoritmo de síntesis de permutación de [1], sección 6. Sintetiza cualquier permutación de n qubits sobre una arquitectura lineal de vecino más próximo utilizando puertas SWAP con una profundidad máxima de $n$ y un tamaño máximo de $n(n-1)/2$ (donde tanto la profundidad como el tamaño se miden con respecto a los SWAP).

Parámetros

pattern (list[int] | ndarray[int]) – Patrón de permutación, que describe qué qubits ocupan las posiciones 0, 1, 2, etc. después de aplicar la permutación. Es decir, pattern[k] = m cuando la permutación asigna el qubit m a la posición k. Por ejemplo, el patrón [2, 4, 3, 0, 1] significa que el qubit 2 va a la posición 0, el qubit 4 va a la posición 1, etc.

Devuelve

El circuito cuántico sintetizado.

Tipo de retorno

QuantumCircuit

Referencias

1. Samuel A. Kutin, David Petrie Moulton y Lawren M. Smithline. Computación a distancia., arXiv:quant-ph/0701194v1

qiskit.synthesis.synth_permutation_basic(pattern)

Sintetizar un circuito de permutación para una arquitectura totalmente conectada utilizando la ordenación.

Más concretamente, si la permutación de entrada es un ciclo de longitud m, entonces se crea un circuito cuántico con m-1 SWAPs (y de profundidad m-1); si la permutación de entrada consiste en varios ciclos disjuntos, entonces cada ciclo se trata esencialmente de forma independiente.

Parámetros

pattern (list[int] | ndarray[int]) – Patrón de permutación, que describe qué qubits ocupan las posiciones 0, 1, 2, etc. después de aplicar la permutación. Es decir, pattern[k] = m cuando la permutación asigna el qubit m a la posición k. Por ejemplo, el patrón [2, 4, 3, 0, 1] significa que el qubit 2 va a la posición 0, el qubit 4 va a la posición 1, etc.

Devuelve

El circuito cuántico sintetizado.

Tipo de retorno

QuantumCircuit

qiskit.synthesis.synth_permutation_acg(pattern)

Sintetizar un circuito de permutación para una arquitectura totalmente conectada utilizando el método de Alon, Chung, Graham.

Esto produce un circuito cuántico de profundidad 2 (medido en número de SWAPs).

Esta aplicación se basa en la proposición 4.1 de la referencia [1], cuya demostración detallada figura en el teorema 2 de la referencia [2]

Parámetros

pattern (list[int] | ndarray[int]) – Patrón de permutación, que describe qué qubits ocupan las posiciones 0, 1, 2, etc. después de aplicar la permutación. Es decir, pattern[k] = m cuando la permutación asigna el qubit m a la posición k. Por ejemplo, el patrón [2, 4, 3, 0, 1] significa que el qubit 2 va a la posición 0, el qubit 4 va a la posición 1, etc.

Devuelve

El circuito cuántico sintetizado.

Tipo de retorno

QuantumCircuit

Referencias

1. N. Alon, F. R. K. Chung y R. L. Graham. Recorrido de permutaciones en grafos mediante emparejamientos., Actas del vigésimo quinto simposio anual de la ACM sobre teoría de la computación(1993). Páginas 583-591. (Resumen ampliado) 10.1145/167088.167239
2. N. Alon, F. R. K. Chung y R. L. Graham. Recorrido de permutaciones en grafos mediante emparejamientos., (Documento completo)

qiskit.synthesis.synth_permutation_reverse_lnn_kms(num_qubits)

Sintetizar la permutación inversa para arquitecturas lineales de vecino más cercano utilizando el método Kutin, Moulton, Smithline.

Algoritmo de síntesis para la permutación inversa de [1], sección 5. Este algoritmo sintetiza la permutación inversa en $n$ qubits sobre una arquitectura lineal de vecino más cercano utilizando puertas CX con profundidad $2 * n + 2$.

Parámetros

num_qubits (int) – El número de qubits.

Devuelve

El circuito cuántico sintetizado.

Tipo de retorno

QuantumCircuit

Referencias

1. Kutin, S., Moulton, D. P., Smithline, L., Computación a distancia, Chicago J. Theor. Comput. Sci., vol. 2007, (2007), arXiv:quant-ph/0701194

qiskit.synthesis.synth_clifford_full(clifford, method=None)

Descomponer un operador Clifford en un operador QuantumCircuit.

Para $N \leq 3$ qubits esto se basa en la descomposición óptima del coste CX de la referencia [1]. Para $N > 3$ qubits esto se hace usando la rutina general de compilación codiciosa no óptima de la referencia [3], que normalmente produce un mejor coste CX comparado con el método AG en [2].

Parámetros

• clifford (Clifford) – Un operador Clifford.
• method (str | None) – un método de síntesis ('AG' o 'greedy'). Si se establece, esto anula la descomposición óptima para los qubits de tipo $N \leq 3$.

Devuelve

Una implementación en circuito del Clifford.

Tipo de retorno

QuantumCircuit

Referencias

1. S. Bravyi, D. Maslov, Los circuitos sin Hadamard exponen la estructura del grupo Clifford, arXiv:2003.09412 [quant-ph]
2. S. Aaronson, D. Gottesman, Improved Simulation of Stabilizer Circuits, Phys. Rev. A 70, 052328 (2004). arXiv:quant-ph/0406196
3. Sergey Bravyi, Shaohan Hu, Dmitri Maslov, Ruslan Shaydulin, Optimización de circuitos Clifford con plantillas y puertas Pauli simbólicas, arXiv:2105.02291 [quant-ph]

qiskit.synthesis.synth_clifford_ag(clifford)

Descomponer un operador Clifford en un operador QuantumCircuit basado en el método Aaronson-Gottesman [1].

Parámetros

clifford (Clifford) – Un operador Clifford.

Devuelve

Una implementación en circuito del Clifford.

Tipo de retorno

QuantumCircuit

Referencias

1. S. Aaronson, D. Gottesman, Improved Simulation of Stabilizer Circuits, Phys. Rev. A 70, 052328 (2004). arXiv:quant-ph/0406196

qiskit.synthesis.synth_clifford_bm(clifford)

Descomposición óptima del coste CX de un Clifford operador sobre 2 qubits o 3 qubits en un QuantumCircuit basada en el método Bravyi-Maslov [1].

Parámetros

clifford (Clifford) – Un operador Clifford.

Devuelve

Una implementación en circuito del Clifford.

Eleva

QiskitError - si Clifford está en más de 3 qubits.

Tipo de retorno

QuantumCircuit

Referencias

1. S. Bravyi, D. Maslov, Los circuitos sin Hadamard exponen la estructura del grupo Clifford, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_clifford_greedy(clifford)

Descomponer un operador Clifford en un operador QuantumCircuit basado en el compilador greedy Clifford que se describe en el Apéndice A de Bravyi, Hu, Maslov y Shaydulin [1].

Este método suele producir mejores costes CX que el método Aaronson-Gottesman.

Nótese que esta función sólo implementa el compilador Clifford codicioso del Apéndice A de [1], y no las optimizaciones de plantillas y puertas Pauli simbólicas que se mencionan en el mismo artículo.

Parámetros

clifford (Clifford) – Un operador Clifford.

Devuelve

Una implementación en circuito del Clifford.

Eleva

QiskitError - si falla la eliminación gaussiana simpléctica.

Tipo de retorno

QuantumCircuit

Referencias

1. Sergey Bravyi, Shaohan Hu, Dmitri Maslov, Ruslan Shaydulin, Optimización de circuitos Clifford con plantillas y puertas Pauli simbólicas, arXiv:2105.02291 [quant-ph]

qiskit.synthesis.synth_clifford_layers(cliff, cx_synth_func=<function _default_cx_synth_func>, cz_synth_func=<function _default_cz_synth_func>, cx_cz_synth_func=None, cz_func_reverse_qubits=False, validate=False)

Síntesis de a Clifford en capas, proporciona una descomposición similar a la síntesis descrita en el Lemma 8 de Bravyi y Maslov [1].

Por ejemplo, un circuito Clifford de 5 qubits se descompone en las siguientes capas:

     ┌─────┐┌─────┐┌────────┐┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
q_0: ┤0    ├┤0    ├┤0       ├┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_1: ┤1    ├┤1    ├┤1       ├┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_2: ┤2 S2 ├┤2 CZ ├┤2 CX_dg ├┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_3: ┤3    ├┤3    ├┤3       ├┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_4: ┤4    ├┤4    ├┤4       ├┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
     └─────┘└─────┘└────────┘└─────┘└─────┘└─────┘└─────┘└────────┘

Esta descomposición es para las funciones por defecto cz_synth_func y cx_synth_func , con otras funciones se puede ver una descomposición ligeramente diferente.

Parámetros

• cliff (Clifford) – Un operador Clifford.
• cx_synth_func (Callable[[ndarray], QuantumCircuit]) – Una función para descomponer el subcircuito CX. Toma como entrada una matriz booleana invertible y genera una salida QuantumCircuit.
• cz_synth_func (Callable[[ndarray], QuantumCircuit]) – Una función para descomponer el subcircuito CZ. Obtiene como entrada una matriz simétrica booleana, y como salida un QuantumCircuit.
• cx_cz_synth_func (Callable) – opcional, una función para descomponer ambos subcircuitos CZ y CX.
• validate (Boolean) – si es True, valida el proceso de síntesis.
• cz_func_reverse_qubits (Boolean) – Verdadero sólo si cz_synth_func es synth_cz_depth_line_mr()ya que esta función devuelve un circuito que invierte el orden de los qubits.

Devuelve

Una implementación en circuito del Clifford.

Tipo de retorno

QuantumCircuit

Referencias

1. S. Bravyi, D. Maslov, Los circuitos sin Hadamard exponen la estructura del grupo Clifford, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_clifford_depth_lnn(cliff)

Síntesis de una Clifford en capas para la conectividad del vecino más próximo lineal.

La profundidad del circuito n-qubit sintetizado está limitada por $7n+2$, que no es óptima. Debería sustituirse por un algoritmo mejor que proporcione una profundidad limitada por $7n-4$ [3].

Parámetros

cliff (Clifford) – un operador Clifford.

Devuelve

una implementación en circuito del Clifford.

Tipo de retorno

QuantumCircuit

Referencias

1. S. Bravyi, D. Maslov, Los circuitos sin Hadamard exponen la estructura del grupo Clifford, arXiv:2003.09412 [quant-ph]
2. Dmitri Maslov, Martin Roetteler, Circuitos estabilizadores más cortos mediante la descomposición de Bruhat y transformaciones cuánticas de circuitos, arXiv:1705.09176.
3. Dmitri Maslov, Willers Yang, Los circuitos CNOT necesitan poca ayuda para implementar transformaciones Clifford arbitrarias libres de Hadamard que generan, arXiv:2210.16195.

qiskit.synthesis.synth_cnotdihedral_full(elem)

Descomponer un elemento CNOTDihedral elemento en un QuantumCircuit.

Para $N \leq 2$ qubits esto se basa en la descomposición óptima del coste CX de la referencia [1]. Para $N > 2$ qubits esto se hace utilizando la rutina general de compilación no óptima de la referencia [2].

Parámetros

elem (CNOTDihedral) – A CNOTDihedral elemento.

Devuelve

Una implementación en circuito del CNOTDihedral elemento.

Tipo de retorno

QuantumCircuit

Referencias

1. Shelly Garion y Andrew W. Cross, Synthesis of CNOT-Dihedral circuits with optimal number of two qubit gates, Quantum 4(369), 2020
2. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin y Jay M. Gambetta, Scalable randomized benchmarking of non-Clifford gates, npj Quantum Inf 2, 16012 (2016).

qiskit.synthesis.synth_cnotdihedral_two_qubits(elem)

Descomponer un CNOTDihedral elemento en un único qubit y dos qubits en un QuantumCircuit. Esta descomposición tiene un número óptimo de CXGates.

Parámetros

elem (CNOTDihedral) – A CNOTDihedral elemento.

Devuelve

Una implementación en circuito del CNOTDihedral elemento.

Eleva

QiskitError – si el elemento no es de 1 o 2 qubits CNOTDihedral.

Tipo de retorno

QuantumCircuit

Referencias

1. Shelly Garion y Andrew W. Cross, Sobre la estructura del grupo CNOT-Dihedral, arXiv:2006.12042 [quant-ph]

qiskit.synthesis.synth_cnotdihedral_general(elem)

Descomponer un elemento CNOTDihedral elemento en un QuantumCircuit.

Descomponer un general CNOTDihedral elementos. El número de puertas CX no es necesariamente óptimo. Para una descomposición de un elemento 1-qubit o 2-qubit, llámese synth_cnotdihedral_two_qubits().

Parámetros

elem (CNOTDihedral) – A CNOTDihedral elemento.

Devuelve

Una implementación en circuito del CNOTDihedral elemento.

Eleva

QiskitError - si el elemento no puede descomponerse en un circuito.

Tipo de retorno

QuantumCircuit

Referencias

1. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin y Jay M. Gambetta, Scalable randomized benchmarking of non-Clifford gates, npj Quantum Inf 2, 16012 (2016).

qiskit.synthesis.synth_stabilizer_layers(stab, cz_synth_func=<function _default_cz_synth_func>, cz_func_reverse_qubits=False, validate=False)

Síntesis de un estado estabilizador en capas.

Ofrece una descomposición similar a la síntesis descrita en el Lema 8 de la referencia [1], sin el subcircuito inicial libre de Hadamard que no afecta al estado del estabilizador.

Por ejemplo, un estado estabilizador de 5 qubits se descompone en las siguientes capas:

     ┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
q_0: ┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
     │     ││     ││     ││     ││        │
q_1: ┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
     │     ││     ││     ││     ││        │
q_2: ┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
     │     ││     ││     ││     ││        │
q_3: ┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
     │     ││     ││     ││     ││        │
q_4: ┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
     └─────┘└─────┘└─────┘└─────┘└────────┘

Parámetros

• stab (StabilizerState) – Un estado estabilizador.
• cz_synth_func (Callable[[ndarray], QuantumCircuit]) – Una función para descomponer el subcircuito CZ. Obtiene como entrada una matriz simétrica booleana, y como salida un QuantumCircuit.
• cz_func_reverse_qubits (bool) – True sólo si cz_synth_func es synth_cz_depth_line_mr()ya que esta función devuelve un circuito que invierte el orden de los qubits.
• validate (bool) – Si True, valida el proceso de síntesis.

Devuelve

Una implementación en circuito del estado estabilizador.

Eleva

QiskitError - si la entrada no es StabilizerState.

Tipo de retorno

QuantumCircuit

Referencias

1. S. Bravyi, D. Maslov, Los circuitos sin Hadamard exponen la estructura del grupo Clifford, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_stabilizer_depth_lnn(stab)

Síntesis de un estado estabilizador n-qubit para conectividad lineal-vecino más próximo, en profundidad 2-qubit $2n+2$ y dos capas CX distintas, utilizando CXGates y puertas de fase (SGate, SdgGate o ZGate).

Parámetros

stab (StabilizerState) – Un estado estabilizador.

Devuelve

Una implementación en circuito del estado estabilizador.

Tipo de retorno

QuantumCircuit

Referencias

1. S. Bravyi, D. Maslov, Los circuitos sin Hadamard exponen la estructura del grupo Clifford, arXiv:2003.09412 [quant-ph]
2. Dmitri Maslov, Martin Roetteler, Circuitos estabilizadores más cortos mediante la descomposición de Bruhat y transformaciones cuánticas de circuitos, arXiv:1705.09176.

qiskit.synthesis.synth_circuit_from_stabilizers(stabilizers, allow_redundant=False, allow_underconstrained=False, invert=False)

Síntesis de un circuito que genera un estado estabilizado por los estabilizadores mediante eliminación gaussiana con puertas Clifford. Si los estabilizadores están poco limitados, y allow_underconstrained es True, el circuito emitirá uno de los estados estabilizados por los estabilizadores. Basado en la aplicación de estímulos.

Parámetros

• stabilizers (Collection[str]) – Lista de cadenas estabilizadoras
• allow_redundant (bool) – Permitir estabilizadores redundantes (es decir, que algunos estabilizadores puedan ser productos de otros)
• allow_underconstrained (bool) – Permitir un conjunto de estabilizadores con restricciones insuficientes (es decir, los estabilizadores no especifican un estado único)
• invert (bool) – Circuito inverso de retorno

Devuelve

Un circuito que genera un estado estabilizado por stabilizers.

Eleva

QiskitError - si los estabilizadores no son válidos, no conmutan o son contradictorios entre sí, si la lista está poco restringida y allow_underconstrained es False, o si la lista es redundante y allow_redundant es False.

Tipo de retorno

QuantumCircuit

Referencias

1. https://github.com/quantumlib/Stim/blob/c0dd0b1c8125b2096cd54b6f72884a459e47fe3e/src/stim/stabilizers/conversions.inl#L469
2. https://quantumcomputing.stackexchange.com/questions/12721/how-to-calculate-destabilizer-group-of-toric-and-other-codes

qiskit.synthesis.gridsynth_rz(angle, epsilon=1e-10)

Rotación RZ aproximada utilizando el algoritmo de Ross-Selinger.

El algoritmo se describe en [1]. El código fuente (en Rust) está disponible en https://github.com/qiskit-community/rsgridsynth.

Parámetros

• angle (float) – Especifica el ángulo de rotación RZ.
• epsilon (float) – El error de aproximación permitido.

Devuelve

Un circuito de un qubit que se aproxima a RZ(angle).

Tipo de retorno

QuantumCircuit

Referencias:

[1] Neil J. Ross, Peter Selinger, Aproximación óptima sin ancilla de Clifford+T de rotaciones z,

arXiv:1403.2975

qiskit.synthesis.gridsynth_unitary(matrix, epsilon=1e-10)

Aproximar una matriz unitaria de 1 qubit utilizando el algoritmo de Ross-Selinger.

El algoritmo se describe en [1]. El código fuente (en Rust) está disponible en https://github.com/qiskit-community/rsgridsynth.

Parámetros

• matrix (ndarray) – Una matriz unitaria e $2 imes 2$.
• epsilon (float) – El error de aproximación permitido.

Devuelve

Un circuito de un qubit que se aproxima a matrix.

Tipo de retorno

QuantumCircuit

Referencias:

[1] Neil J. Ross, Peter Selinger, Aproximación óptima sin ancilla de Clifford+T de rotaciones z,

arXiv:1403.2975

qiskit.synthesis.generate_basic_approximations(basis_gates, depth, filename=None)

Genera una lista de GateSequences con las puertas en basis_gates.

Parámetros

• basis_gates (list[str |Gate]) – Las puertas a partir de las cuales se crearán las secuencias de puertas.
• depth (int) – La profundidad máxima de las aproximaciones.
• filename (str | None) – Si se proporciona, las aproximaciones básicas se almacenan en este archivo.

Devuelve

Lista de GateSequences que utilizan las puertas en basis_gates.

Eleva

ValueError - Si basis_gates contiene un identificador de puerta no válido.

Tipo de retorno

lista [GateSequence]

qiskit.synthesis.synth_qft_line(num_qubits, do_swaps=True, approximation_degree=0)

Construye un circuito para la Transformada Cuántica de Fourier utilizando la conectividad lineal de vecinos.

La construcción se basa en la figura 2.b de Fowler et al. [1].

Parámetros

• num_qubits (int) – Número de qubits sobre los que actúa la transformada cuántica de Fourier.
• approximation_degree (int) – El grado de aproximación (0 para ninguna aproximación). Es posible implementar la QFT aproximadamente ignorando las rotaciones de fase controlada con el ángulo por debajo de un umbral. Este tema se trata con más detalle en https://arxiv.org/abs/quant-ph/9601018 o https://arxiv.org/abs/quant-ph/0403071.
• do_swaps (bool) – Si sintetizar la operación "QFT" o "QFT-con-reversión".

Devuelve

Un circuito que implementa la operación QFT.

Tipo de retorno

QuantumCircuit

Referencias

1. A. G. Fowler, S. J. Devitt y L. C. L. Hollenberg, Implementation of Shor's algorithm on a linear nearest neighbour qubit array, Quantum Info. Comput. 4, 4 (julio de 2004), 237-251. arXiv:quant-ph/0402196 [quant-ph]

qiskit.synthesis.synth_qft_full(num_qubits, do_swaps=True, approximation_degree=0, insert_barriers=False, inverse=False, name=None)

Construye un circuito para la Transformada Cuántica de Fourier utilizando la conectividad todo-a-todo.

Parámetros

• num_qubits (int) – Número de qubits sobre los que actúa la transformada cuántica de Fourier.
• do_swaps (bool) – Si sintetizar la operación "QFT" o "QFT-con-reversión".
• approximation_degree (int) – El grado de aproximación (0 para ninguna aproximación). Es posible implementar la QFT aproximadamente ignorando las rotaciones de fase controlada con el ángulo por debajo de un umbral. Este tema se trata con más detalle en https://arxiv.org/abs/quant-ph/9601018 o https://arxiv.org/abs/quant-ph/0403071.
• insert_barriers (bool) – Si True, se insertan barreras para mejorar la visualización.
• inverse (bool) – Si True, se construye la transformada cuántica de Fourier inversa.
• name (str | None) – El nombre del circuito.

Devuelve

Un circuito que implementa la operación QFT.

Tipo de retorno

QuantumCircuit

qiskit.synthesis.qs_decomposition(mat, opt_a1=None, opt_a2=None, decomposer_1q=None, decomposer_2q=None, *, _depth=0)

Descompone una matriz unitaria en puertas de uno y dos qubits utilizando la Descomposición Cuántica de Shannon, basada en la Descomposición ZXZ en Bloques.

Esta descomposición se describe en Krol y Al-Ars [2] y mejora el método de Shende et al. [1].

  ┌───┐              ┌───┐     ┌───┐
 ─┤   ├─      ────□──┤ H ├──□──┤ H ├──□──
  │   │    ≃    ┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
/─┤   ├─      ──┤ C ├─────┤ B ├─────┤ A ├
  └───┘         └───┘     └───┘     └───┘

El número de CXGates generado con la descomposición sin optimizaciones es el mismo que el del método sin optimizaciones en [1] :

Si opt_a1 = True, el recuento de CX se reduce, mejorando [1], en:

Guardar dos CXGates en lugar de uno en cada paso de la recursión.

Si opt_a2 = True, el recuento de CX se reduce, como en [1], en:

Por lo tanto, el número de CXGates generados con la descomposición con optimizaciones es

Parámetros

• mat (ndarray) – matriz unitaria para descomponer
• opt_a1 (bool | None) – si intentar la optimización A.1 de [1, 2]. Esto debería eliminar 2 cx por llamada.
• opt_a2 (bool | None) – si intentar la optimización A.2 de [1, 2]. Esto descompone los unitarios de dos qubits en una puerta diagonal y un unitario de dos cx y reduce el recuento total de cx en $4^{n-2} - 1$. Esta optimización no debe realizarse si el unitario original está controlado.
• decomposer_1q (Callable[[ndarray], QuantumCircuit] | None) – Descomponedor opcional de « 1Q ». Si es «None», utiliza OneQubitEulerDecomposer.
• decomposer_2q (Callable[[ndarray], QuantumCircuit] | None) – Descomponedor opcional de « 2Q ». Si es «None», utiliza TwoQubitBasisDecomposer.

Devuelve

Circuito cuántico descompuesto.

Tipo de retorno

QuantumCircuit

Referencias

1. Shende, Bullock, Markov, Síntesis de circuitos lógicos cuánticos, arXiv:0406176 [quant-ph]
2. Krol, Al-Ars, Beyond Quantum Shannon: Circuit Construction for General n-Qubit Gates Based on Block ZXZ-Decomposition, arXiv:2403.13692

qiskit.synthesis.two_qubit_cnot_decompose(*args, **kwargs)

Se trata de una instancia de TwoQubitBasisDecomposer que siempre utiliza cx como puerta KAK para la descomposición de la base. Puede utilizar esta función como un acceso rápido a cx-based 2-qubit decompositions.

Parámetros

• unitary (Operator or np.ndarray) – La 4x4 unitaria para sintetizar.
• basis_fidelity (float or None) – Si se tiene en cuenta la fidelidad supuesta para las aplicaciones de CXGate.
• approximate (bool) – Si True aproximado si basis_fidelity es menor que 1.0.

Devuelve

El circuito sintetizado del unitario de entrada.

Tipo de retorno

QuantumCircuit

qiskit.synthesis.synth_mcmt_vchain(gate, num_ctrl_qubits, num_target_qubits, ctrl_state=None)

Sintetizar MCMT utilizando una cadena en V.

Esto utiliza una cadena de puertas CCX, utilizando num_ctrl_qubits - 1 qubits auxiliares.

Por ejemplo, una puerta H de 3 controles y 2 objetivos se sintetizará como:

q_0: ──■────────────────────────■──
       │                        │
q_1: ──■────────────────────────■──
       │                        │
q_2: ──┼────■──────────────■────┼──
       │    │  ┌───┐       │    │
q_3: ──┼────┼──┤ H ├───────┼────┼──
       │    │  └─┬─┘┌───┐  │    │
q_4: ──┼────┼────┼──┤ H ├──┼────┼──
     ┌─┴─┐  │    │  └─┬─┘  │  ┌─┴─┐
q_5: ┤ X ├──■────┼────┼────■──┤ X ├
     └───┘┌─┴─┐  │    │  ┌─┴─┐└───┘
q_6: ─────┤ X ├──■────■──┤ X ├─────
          └───┘          └───┘

Parámetros

• gate (Gate) – Puerta base que se aplicará a los objetivos.
• num_ctrl_qubits (int) – Número de qubits de control.
• num_target_qubits (int) – Número de qubits objetivo.
• ctrl_state (int | None) – Estado de control opcional como número entero.

Devuelve

El circuito sintetizado para la puerta MCMT.

Tipo de retorno

QuantumCircuit

qiskit.synthesis.synth_mcmt_xgate(num_ctrl_qubits, num_target_qubits, ctrl_state=None)

Sintetiza la puerta MCMT X.

Utiliza una estructura de circuito especial que es eficiente para las puertas MCMT X. No requiere qubits auxiliares y se beneficia de descomposiciones MCX eficientes.

E.g. una puerta X de 3 controles y 3 objetivos se sintetizará como:

q_0: ─────────────■────────────
                  |
q_1: ─────────────■────────────
                  |
q_2: ─────────────■────────────
                ┌─┴─┐
q_3: ────────■──┤ X ├──■───────
           ┌─┴─┐└───┘┌─┴─┐
q_4: ───■──┤ X ├─────┤ X ├──■──
      ┌─┴─┐└───┘     └───┘┌─┴─┐
q_5: ─┤ X ├───────────────┤ X ├
      └───┘               └───┘

Parámetros

• num_ctrl_qubits (int) – Número de qubits de control.
• num_target_qubits (int) – Número de qubits objetivo.
• ctrl_state (int | None) – Estado de control opcional como número entero.

Devuelve

El circuito sintetizado para la puerta MCMT X.

Tipo de retorno

QuantumCircuit

qiskit.synthesis.synth_mcx_1_clean_kg24(num_ctrl_qubits)

Sintetiza una puerta X multicontrolada con controles de tipo $k\ge 3$ utilizando un qubit auxiliar limpio de tipo $1$, de modo que se obtenga un circuito con puertas Toffoli de tipo$2k-3$ o puertas CX de tipo $6k-6$ y una profundidad de $O(k)$, tal y como se describe en la sección. 5.1 de [1]. En el caso de $k\le 2$, el circuito devuelto consta de una sola puerta X, CX o CCX (que se corresponden con $k = 0, 1, 2$, respectivamente) y no utiliza qubits auxiliares.

Parámetros

num_ctrl_qubits (int) – El número de qubits de control.

Devuelve

El circuito cuántico sintetizado.

Eleva

QiskitError – si num_ctrl_qubits es ilegal.

Tipo de retorno

QuantumCircuit

Referencias

1. Khattar y Gidney, Auge de ancilas condicionalmente limpias para optimizar circuitos cuánticos arXiv:2407.17966

qiskit.synthesis.synth_mcx_1_dirty_kg24(num_ctrl_qubits)

Sintetiza una puerta X multicontrolada con controles del tipo $k\ge 3$ utilizando un qubit auxiliar «dirty» del tipo $1$, de modo que se obtenga un circuito con puertas Toffoli del tipo $4k-8$ o puertas CX del tipo $12k-18$, y una profundidad $O(k)$, tal y como se describe en la sección. 5.3 de [1]. En el caso de $k\le 2$, el circuito devuelto consta de una sola puerta X, CX o CCX (que se corresponden con $k = 0, 1, 2$, respectivamente) y no utiliza qubits auxiliares.

Parámetros

num_ctrl_qubits (int) – El número de qubits de control.

Devuelve

El circuito cuántico sintetizado.

Eleva

QiskitError – si num_ctrl_qubits es ilegal.

Tipo de retorno

QuantumCircuit

Referencias

1. Khattar y Gidney, Auge de ancilas condicionalmente limpias para optimizar circuitos cuánticos arXiv:2407.17966

qiskit.synthesis.synth_mcx_2_clean_kg24(num_ctrl_qubits)

Sintetizar una puerta X multicontrolada con controles de tipo $k\ge 3$ utilizando qubits auxiliares $2$ que generen un circuito con puertas Toffoli de tipo $2k-3$ o puertas CX de tipo $6k-6$, y una profundidad de $O(\log(k))$, tal y como se describe en la sección. 5.2 de [1]. En el caso de $k\le 2$, el circuito devuelto consta de una sola puerta X, CX o CCX (que se corresponden con $k = 0, 1, 2$, respectivamente) y no utiliza qubits auxiliares.

Parámetros

num_ctrl_qubits (int) – El número de qubits de control.

Devuelve

El circuito cuántico sintetizado.

Eleva

QiskitError – si num_ctrl_qubits es ilegal.

Tipo de retorno

QuantumCircuit

Referencias

1. Khattar y Gidney, Auge de ancilas condicionalmente limpias para optimizar circuitos cuánticos arXiv:2407.17966

qiskit.synthesis.synth_mcx_2_dirty_kg24(num_ctrl_qubits)

Sintetiza una puerta X multicontrolada con controles de tipo $k\ge 3$ utilizando qubits auxiliares $2$ en estado «dirty», de modo que se obtenga un circuito con puertas Toffoli de tipo $4k-8$ o puertas CX de tipo $12k-18$ y una profundidad de $O(\log(k))$, tal y como se describe en la sección. 5.4 de [1]. En el caso de $k\le 2$, el circuito devuelto consta de una sola puerta X, CX o CCX (que se corresponden con $k = 0, 1, 2$, respectivamente) y no utiliza qubits auxiliares.

Parámetros

num_ctrl_qubits (int) – El número de qubits de control.

Devuelve

El circuito cuántico sintetizado.

Eleva

QiskitError – si num_ctrl_qubits es ilegal.

Tipo de retorno

QuantumCircuit

Referencias

1. Khattar y Gidney, Auge de ancilas condicionalmente limpias para optimizar circuitos cuánticos arXiv:2407.17966

qiskit.synthesis.synth_mcx_n_dirty_i15(num_ctrl_qubits, relative_phase=False, action_only=False)

Sintetizar una puerta X multicontrolada con controles $k$ basados en el artículo de Iten et al. [1].

Para $k\ge 4$, el método utiliza $k - 2$ qubits auxiliares «dirty», lo que da lugar a un circuito con $2 * k - 1$ qubits y, como máximo, $8 * k - 6$ puertas CX. En el caso de $k\le 3$, se utilizan en su lugar circuitos eficientes diseñados expresamente que no requieren qubits auxiliares.

Parámetros

• num_ctrl_qubits (int) – El número de qubits de control.
• relative_phase (bool) – cuando se establece en True, el método aplica la puerta X multicontrolada optimizada hasta una fase relativa, de forma que, por el lema 8 de [1], las fases relativas de action part se cancelan con las fases de reset part.
• action_only (bool) – cuando se fija en True, el método sólo aplica el action part del lema 8 de [1].

Devuelve

El circuito cuántico sintetizado.

Eleva

QiskitError – si num_ctrl_qubits es ilegal.

Tipo de retorno

QuantumCircuit

Referencias

1. Iten y otros. et al., Circuitos cuánticos para isometrías, Phys. Rev. A 93, 23 de marzo de 2018 (2016), arXiv:1501.06911

qiskit.synthesis.synth_mcx_n_clean_m15(num_ctrl_qubits)

Sintetiza una puerta X multicontrolada con controles de tipo $k\ge 3$ utilizando qubits auxiliares $k - 2$ limpios, de modo que se obtenga un circuito con qubits de tipo $2 * k - 1$ y, como máximo, puertas CX de tipo $6 * k - 6$, según Maslov [1]. En el caso de $k\le 2$, el circuito devuelto consta de una sola puerta X, CX o CCX (que se corresponden con $k = 0, 1, 2$, respectivamente) y no utiliza qubits auxiliares.

Parámetros

num_ctrl_qubits (int) – El número de qubits de control.

Devuelve

El circuito cuántico sintetizado.

Eleva

QiskitError – si num_ctrl_qubits es ilegal.

Tipo de retorno

QuantumCircuit

Referencias

1. Maslov., Física. Rev. A 93, 022311 (2016), arXiv:1508.03273

qiskit.synthesis.synth_mcx_1_clean_b95(num_ctrl_qubits)

Sintetiza una puerta X multicontrolada con controles de tipo $k\ge 3$ utilizando un único qubit auxiliar limpio, de modo que se obtenga un circuito con $k + 2$ qubits y, como máximo, $16 * k - 24$ puertas CX, por [1], [2]. En el caso de $k\le 2$, el circuito devuelto consta de una sola puerta X, CX o CCX (que se corresponden con $k = 0, 1, 2$, respectivamente) y no utiliza qubits auxiliares.

Parámetros

num_ctrl_qubits (int) – El número de qubits de control.

Devuelve

El circuito cuántico sintetizado.

Eleva

QiskitError – si num_ctrl_qubits es ilegal.

Tipo de retorno

QuantumCircuit

Referencias

1. Barenco et. al., Compuertas elementales para la computación cuántica, Phys.Rev. A52 3457 (1995), arXiv:quant-ph/9503016
2. Iten y otros. et al., Circuitos cuánticos para isometrías, Phys. Rev. A 93, 23 de marzo de 2018 (2016), arXiv:1501.06911

qiskit.synthesis.synth_mcx_noaux_v24(num_ctrl_qubits)

Sintetiza una puerta X multicontrolada con controles $k$ basados en la implementación para MCPhaseGate.

A su vez, la puerta MCPhase utiliza la descomposición para unitarios especiales multicontrolados descrita en [1].

Produce un circuito cuántico con $k + 1$ qubits. El número de puertas CX es cuadrático en $k$.

Parámetros

num_ctrl_qubits (int) – El número de qubits de control.

Devuelve

El circuito cuántico sintetizado.

Eleva

QiskitError – si num_ctrl_qubits es ilegal.

Tipo de retorno

QuantumCircuit

Referencias

1. Vale et. al., Circuit Decomposition of Multicontrolled Special Unitary Single-Qubit Gates, IEEE TCAD 43(3) (2024), arXiv:2302.06377

qiskit.synthesis.synth_mcx_noaux_hp24(num_ctrl_qubits)

Sintetizar una puerta X multicontrolada con controles $k$ basados en el trabajo de Huang y Palsberg.

Produce un circuito cuántico con $k + 1$ qubits. El número de puertas CX es lineal en $k$.

Parámetros

num_ctrl_qubits (int) – El número de qubits de control.

Devuelve

El circuito cuántico sintetizado.

Eleva

QiskitError – si num_ctrl_qubits es ilegal.

Tipo de retorno

QuantumCircuit

Referencias

1. Huang y Palsberg, Compiling Conditional Quantum Gates without Using Helper Qubits, PLDI (2024), <https://dl.acm.org/doi/10.1145/3656436> `_

qiskit.synthesis.synth_mcx_gray_code(num_ctrl_qubits)

Sintetiza una puerta X multicontrolada con controles de tip $k\ge 3$ o utilizando el código Gray.

Genera un circuito cuántico con $k + 1$ qubits. Este método genera un número exponencial de puertas CX y solo debe utilizarse para valores pequeños de $k$. Para $k\le 2$, el circuito resultante consta de una sola puerta X, CX o CCX (que corresponden a $k = 0, 1, 2$, respectivamente) y no utiliza qubits auxiliares.

Parámetros

num_ctrl_qubits (int) – El número de qubits de control.

Eleva

QiskitError – si num_ctrl_qubits es ilegal.

Devuelve

El circuito cuántico sintetizado.

Tipo de retorno

QuantumCircuit

qiskit.synthesis.synth_c3x()

Síntesis eficaz de compuertas X de 3 controles.

Tipo de retorno

QuantumCircuit

qiskit.synthesis.synth_c4x()

Síntesis eficaz de compuertas X de 4 controles.

Tipo de retorno

QuantumCircuit

qiskit.synthesis.adder_qft_d00(num_state_qubits, kind='half', annotated=False)

Un circuito que utiliza la QFT para realizar sumas en el mismo lugar en dos registros de qubits.

Para registros con $n$ qubits, el sumador QFT puede realizar sumas módulo $2^n$ (con kind="fixed") o sumas ordinarias añadiendo un carry qubits (con kind="half"). El sumador fijo utiliza $(3n^2 - n)/2$ CPhaseGate operadores, con un $n$ adicional para el sumador medio.

Como ejemplo, un circuito sumador QFT de punto no fijo que realiza la suma en dos registros de tamaño 2-qubit es como sigue:

 a_0: ─────────■──────■────────■──────────────────────────────────
               │      │        │
 a_1: ─────────┼──────┼────────┼────────■──────■──────────────────
      ┌──────┐ │      │        │P(π/4)  │      │P(π/2) ┌─────────┐
 b_0: ┤0     ├─┼──────┼────────■────────┼──────■───────┤0        ├
      │      │ │      │P(π/2)           │P(π)          │         │
 b_1: ┤1 Qft ├─┼──────■─────────────────■──────────────┤1 qft_dg ├
      │      │ │P(π)                                   │         │
cout: ┤2     ├─■───────────────────────────────────────┤2        ├
      └──────┘                                         └─────────┘

Parámetros

• num_state_qubits (int) – El número de qubits en cualquiera de los registros de entrada para el estado $|a\rangle$ o $|b\rangle$. Los dos registros de entrada deben tener el mismo número de qubits.
• kind (str) – El tipo de sumador, puede ser "half" para un medio sumador o "fixed" para un sumador de tamaño fijo. Un sumador medio contiene un arrastre para representar el bit más significativo, pero el sumador de tamaño fijo no lo contiene y, por tanto, realiza la suma módulo 2 ** num_state_qubits.
• annotated (bool) – Si True, crea las operaciones de control e inversas apropiadas como objetos AnnotatedOperation .

Tipo de retorno

QuantumCircuit

Referencias:

[1] T. G. Draper, Addition on a Quantum Computer, 2000. arXiv:quant-ph/0008033

[2] Ruiz-Perez et al., Aritmética cuántica con la transformada cuántica de Fourier, 2017. arXiv:1411.5949

[3] Vedral et al., Redes cuánticas para operaciones aritméticas elementales, 1995. arXiv:quant-ph/9511018

qiskit.synthesis.adder_ripple_c04(num_state_qubits, kind='half')

Un circuito ripple-carry para realizar sumas in-place en dos registros qubit.

Este circuito utiliza $2n + O(1)$ compuertas CCX y $5n + O(1)$ compuertas CX, a una profundidad de $2n + O(1)$ [1]. La constante depende del tipo de sumador implementado.

Como ejemplo, un circuito sumador de acarreo de ondulación que realiza la suma en dos registros de 3 qubits de tamaño con un bit de acarreo (kind="full") es como sigue:

        ┌──────┐                                     ┌──────┐
 cin_0: ┤2     ├─────────────────────────────────────┤2     ├
        │      │┌──────┐                     ┌──────┐│      │
   a_0: ┤0     ├┤2     ├─────────────────────┤2     ├┤0     ├
        │      ││      │┌──────┐     ┌──────┐│      ││      │
   a_1: ┤  MAJ ├┤0     ├┤2     ├─────┤2     ├┤0     ├┤  UMA ├
        │      ││      ││      │     │      ││      ││      │
   a_2: ┤      ├┤  MAJ ├┤0     ├──■──┤0     ├┤  UMA ├┤      ├
        │      ││      ││      │  │  │      ││      ││      │
   b_0: ┤1     ├┤      ├┤  MAJ ├──┼──┤  UMA ├┤      ├┤1     ├
        └──────┘│      ││      │  │  │      ││      │└──────┘
   b_1: ────────┤1     ├┤      ├──┼──┤      ├┤1     ├────────
                └──────┘│      │  │  │      │└──────┘
   b_2: ────────────────┤1     ├──┼──┤1     ├────────────────
                        └──────┘┌─┴─┐└──────┘
cout_0: ────────────────────────┤ X ├────────────────────────
                                └───┘

Aquí las puertas MAJ y UMA corresponden a las puertas introducidas en [1]. Nótese que en esta implementación los qubits del registro de entrada se ordenan como todos los qubits del primer registro de entrada, seguidos de todos los qubits del segundo registro de entrada.

Se admiten dos tipos diferentes de sumadores. Estableciendo el argumento kind , también puede elegir una media escalera, que no tiene carry-in, y una escalera de tamaño fijo, que no tiene ni carry-in ni carry-out, y por lo tanto actúa sobre tamaños de registro fijos. A diferencia de la escalera completa, estos circuitos necesitan un qubit auxiliar adicional.

El diagrama de circuito para el sumador de punto fijo (kind="fixed") en entradas de tamaño 3qubit es

        ┌──────┐┌──────┐                ┌──────┐┌──────┐
   a_0: ┤0     ├┤2     ├────────────────┤2     ├┤0     ├
        │      ││      │┌──────┐┌──────┐│      ││      │
   a_1: ┤      ├┤0     ├┤2     ├┤2     ├┤0     ├┤      ├
        │      ││      ││      ││      ││      ││      │
   a_2: ┤      ├┤  MAJ ├┤0     ├┤0     ├┤  UMA ├┤      ├
        │      ││      ││      ││      ││      ││      │
   b_0: ┤1 MAJ ├┤      ├┤  MAJ ├┤  UMA ├┤      ├┤1 UMA ├
        │      ││      ││      ││      ││      ││      │
   b_1: ┤      ├┤1     ├┤      ├┤      ├┤1     ├┤      ├
        │      │└──────┘│      ││      │└──────┘│      │
   b_2: ┤      ├────────┤1     ├┤1     ├────────┤      ├
        │      │        └──────┘└──────┘        │      │
help_0: ┤2     ├────────────────────────────────┤2     ├
        └──────┘                                └──────┘

Tiene un qubit menos que la escalera completa, ya que no tiene el carry-out, pero utiliza un qubit de ayuda en lugar del carry-in, por lo que sólo tiene un qubit menos, no dos.

Parámetros

• num_state_qubits (int) – El número de qubits en cualquiera de los registros de entrada para el estado $|a\rangle$ o $|b\rangle$. Los dos registros de entrada deben tener el mismo número de qubits.
• kind (str) – El tipo de sumador, puede ser "full" para un sumador completo, "half" para un medio sumador, o "fixed" para un sumador de tamaño fijo. Un sumador completo incluye tanto carry-in como carry-out, un medio sólo carry-out, y un sumador de tamaño fijo ni carry-in ni carry-out.

Eleva

ValueError - Si num_state_qubits es inferior a 1.

Tipo de retorno

QuantumCircuit

Referencias:

[1] Cuccaro et al., Un nuevo circuito cuántico de adición por ondulación, 2004. arXiv:quant-ph/0410184

[2] Vedral et al., Redes cuánticas para operaciones aritméticas elementales, 1995. arXiv:quant-ph/9511018

qiskit.synthesis.adder_ripple_v95(num_state_qubits, kind='half')

El sumador de arrastre de ondulación VBE [1].

Este método utiliza $4n + O(1)$ compuertas CCX y $4n + 1$ compuertas CX a una profundidad de $6n - 2$ [2].

Este circuito realiza la suma in situ de dos registros cuánticos de igual tamaño. A modo de ejemplo, un circuito sumador clásico que realiza una suma completa (es decir, incluyendo un bit de acarreo) en dos registros de 2 qubits de tamaño es el siguiente:

          ┌────────┐                       ┌───────────┐┌──────┐
   cin_0: ┤0       ├───────────────────────┤0          ├┤0     ├
          │        │                       │           ││      │
     a_0: ┤1       ├───────────────────────┤1          ├┤1     ├
          │        │┌────────┐     ┌──────┐│           ││  Sum │
     a_1: ┤        ├┤1       ├──■──┤1     ├┤           ├┤      ├
          │        ││        │  │  │      ││           ││      │
     b_0: ┤2 Carry ├┤        ├──┼──┤      ├┤2 Carry_dg ├┤2     ├
          │        ││        │┌─┴─┐│      ││           │└──────┘
     b_1: ┤        ├┤2 Carry ├┤ X ├┤2 Sum ├┤           ├────────
          │        ││        │└───┘│      ││           │
  cout_0: ┤        ├┤3       ├─────┤      ├┤           ├────────
          │        ││        │     │      ││           │
helper_0: ┤3       ├┤0       ├─────┤0     ├┤3          ├────────
          └────────┘└────────┘     └──────┘└───────────┘

Aquí las puertas Carry y Sum corresponden a las puertas introducidas en [1]. Carry_dg corresponden a la inversa de la puerta Carry. Nótese que en esta implementación los qubits del registro de entrada se ordenan como todos los qubits del primer registro de entrada, seguidos de todos los qubits del segundo registro de entrada. Se trata de una ordenación diferente a la de la figura 2 en [1], lo que da lugar a un dibujo diferente del circuito.

Parámetros

• num_state_qubits (int) – El tamaño del registro.
• kind (str) – El tipo de sumador, puede ser "full" para un sumador completo, "half" para un medio sumador, o "fixed" para un sumador de tamaño fijo. Un sumador completo incluye tanto carry-in como carry-out, un medio sólo carry-out, y un sumador de tamaño fijo ni carry-in ni carry-out.

Eleva

ValueError - Si num_state_qubits es inferior a 1.

Tipo de retorno

QuantumCircuit

Referencias:

[1] Vedral et al., Redes cuánticas para operaciones aritméticas elementales, 1995. arXiv:quant-ph/9511018

[2] Cuccaro et al., Un nuevo circuito cuántico de adición por ondulación, 2004. arXiv:quant-ph/0410184

qiskit.synthesis.adder_ripple_r25(num_qubits)

El sumador de arrastre de rizado RV [1]. Construir un circuito sumador cuántico libre de ancilla con profundidad sublineal basado en el sumador RV ripple-carry mostrado en [1]. La implementación tiene una profundidad de $O(\log^2 n)$ y utiliza puertas math:O(n log n).

Como ejemplo, un circuito sumador ripple-carry que realiza la suma en dos registros de tamaño 4-qubit es el siguiente:

                               ┌───────────┐                    ┌────────┐
 a_0: ─────────────────────────┤0          ├────────────────────┤0       ├───────────────■─────────────────
                     ┌────────┐│           │                    │        │┌───────────┐  │
 a_1: ──■────────────┤0       ├┤2          ├──■─────────────────┤2       ├┤0          ├──┼────■────────────
        │            │        ││           │  │                 │        ││           │  │    │
 a_2: ──┼────■───────┤1       ├┤4          ├──┼────■────────────┤4       ├┤1 LAD_1_dg ├──┼────┼────■───────
        │    │       │        ││           │  │    │            │        ││           │  │    │    │
 a_3: ──┼────┼────■──┤2       ├┤6          ├──┼────┼────■───────┤6 LAD_2 ├┤2          ├──┼────┼────┼────■──
        │    │    │  │        ││           │  │    │    │       │        │└───────────┘┌─┴─┐  │    │    │
 b_0: ──┼────┼────┼──┤        ├┤1 LAD_2_dg ├──┼────┼────┼───────┤1       ├─────────────┤ X ├──┼────┼────┼──
      ┌─┴─┐  │    │  │  LAD_1 ││           │┌─┴─┐  │    │  ┌───┐│        │    ┌───┐    └───┘┌─┴─┐  │    │
 b_1: ┤ X ├──┼────┼──┤        ├┤3          ├┤ X ├──┼────┼──┤ X ├┤3       ├────┤ X ├─────────┤ X ├──┼────┼──
      └───┘┌─┴─┐  │  │        ││           │└───┘┌─┴─┐  │  ├───┤│        │    ├───┤         └───┘┌─┴─┐  │
 b_2: ─────┤ X ├──┼──┤        ├┤5          ├─────┤ X ├──┼──┤ X ├┤5       ├────┤ X ├──────────────┤ X ├──┼──
           └───┘┌─┴─┐│        ││           │     └───┘┌─┴─┐└───┘└────────┘    └───┘              └───┘┌─┴─┐
 b_3: ──────────┤ X ├┤        ├┤7          ├──────────┤ X ├───────────────────────────────────────────┤ X ├
                └───┘│        ││           │          └───┘                                           └───┘
cout: ───────────────┤3       ├┤8          ├───────────────────────────────────────────────────────────────
                     └────────┘└───────────┘

Aquí LAD_1 y LAD_2 son las escalas CX y CCX respectivamente introducidas en [1]. Nótese que en esta implementación los qubits del registro de entrada se ordenan como todos los qubits del primer registro de entrada, seguidos de todos los qubits del segundo registro de entrada.

Parámetros

num_qubits (int) – El tamaño del registro.

Devuelve

El circuito cuántico que implementa el sumador de acarreo de ondulación RV.

Eleva

ValueError - Si num_qubits es inferior a 1.

Tipo de retorno

QuantumCircuit

Referencias:

1. Remaud y Vandaele, Ancilla-free Quantum Adder with Sublinear Depth, 2025. arXiv:2501.16802

qiskit.synthesis.adder_modular_v17(num_qubits)

Construya un circuito sumador modular sin qubits auxiliares basado en el sumador estilo Van Rentergem de la Fig. 15 de [1]. La implementación utiliza como máximo $16k - 13$ puertas CX para un sumador con k qubits en cada registro, donde k = num_qubits.

Parámetros

num_qubits (int) – El tamaño del registro.

Devuelve

El circuito cuántico que implementa el sumador modular.

Eleva

ValueError - Si num_qubits es inferior a 1.

Tipo de retorno

QuantumCircuit

Referencias:

[1] Gidney, Factoring with n+2 clean qubits and n-1 dirty qubits, 2017. arxiv:1706.07884

qiskit.synthesis.multiplier_cumulative_h18(num_state_qubits, num_result_qubits=None)

Un circuito de multiplicación para almacenar el producto de dos registros de entrada fuera de lugar.

El circuito utiliza el enfoque de la Ref. [1]. Como ejemplo, un circuito multiplicador que realiza una multiplicación no modular en dos registros de tamaño 3qubit es:

from qiskit.synthesis.arithmetic import multiplier_cumulative_h18

num_state_qubits = 3
circuit = multiplier_cumulative_h18(num_state_qubits)
circuit.draw("mpl")

La multiplicación en este circuito se implementa en un enfoque clásico realizando una serie de sumas desplazadas utilizando uno de los registros de entrada mientras que los qubits del otro registro de entrada actúan como qubits de control para los sumadores.

Parámetros

• num_state_qubits (int) – El número de qubits en cualquiera de los registros de entrada para el estado $|a\rangle$ o $|b\rangle$. Los dos registros de entrada deben tener el mismo número de qubits.
• num_result_qubits (int | None) – El número de qubits de resultado al que limitar la salida. Si el número de qubits resultantes es $n$, se realiza la multiplicación módulo $2^n$ para limitar la salida al número especificado de qubits. El valor por defecto es 2 * num_state_qubits para representar cualquier resultado posible de la multiplicación de las dos entradas.

Eleva

ValueError - Si se da num_result_qubits y no es válido, significa que no está en [num_state_qubits, 2 * num_state_qubits].

Tipo de retorno

QuantumCircuit

Referencias:

[1] Häner et al., Optimización de circuitos cuánticos para aritmética, 2018. arXiv:1805.12445

qiskit.synthesis.multiplier_qft_r17(num_state_qubits, num_result_qubits=None)

Un circuito de multiplicación QFT para almacenar el producto de dos registros de entrada fuera de lugar.

La multiplicación en este circuito se implementa utilizando el procedimiento de la Fig. 3 en [1], donde las rotaciones de suma ponderada se implementan como se indica en la Fig. 5 en [1]. La QFT se utiliza en el registro de salida y va seguida de rotaciones controladas por los registros de entrada. Las rotaciones transforman el estado en el producto de dos registros de entrada en base QFT, que se revierte desde la base QFT utilizando QFT inversa. Por ejemplo, en 3 qubits de estado, un multiplicador completo viene dado por:

from qiskit.synthesis.arithmetic import multiplier_qft_r17

num_state_qubits = 3
circuit = multiplier_qft_r17(num_state_qubits)
circuit.draw("mpl")

Parámetros

• num_state_qubits (int) – El número de qubits en cualquiera de los registros de entrada para el estado $|a\rangle$ o $|b\rangle$. Los dos registros de entrada deben tener el mismo número de qubits.
• num_result_qubits (int | None) – El número de qubits de resultado al que limitar la salida. Si el número de qubits resultantes es $n$, se realiza la multiplicación módulo $2^n$ para limitar la salida al número especificado de qubits. El valor por defecto es 2 * num_state_qubits para representar cualquier resultado posible de la multiplicación de las dos entradas.

Eleva

ValueError - Si se da num_result_qubits y no es válido, significa que no está en [num_state_qubits, 2 * num_state_qubits].

Tipo de retorno

QuantumCircuit

Referencias:

[1] Ruiz-Perez et al., Aritmética cuántica con la transformada cuántica de Fourier, 2017. arXiv:1411.5949

qiskit.synthesis.synth_weighted_sum_carry(weighted_sum)

Sintetizar una puerta de suma ponderada, por el número de qubits de estado y los pesos de los qubits.

Este método se describe en el Apéndice A de [1].

Referencia:

[1] Stamatopoulos et al. Valoración de opciones mediante ordenadores cuánticos (2020)

Quantum 4, 291

Parámetros

weighted_sum (WeightedSumGate)

Tipo de retorno

QuantumCircuit

qiskit.synthesis.synth_integer_comparator_2s(num_state_qubits, value, geq=True)

Implementar una comparación de enteros basada en 2s complemento.

Esto se basa en el Apéndice B de [1].

Parámetros

• num_state_qubits (int) – El número de qubits que codifican el valor con el que comparar.
• value (int) – El valor con el que comparar.
• geq (bool) – Si True voltea el bit de destino si el estado del qubit es $\geq$ que el valor, de lo contrario implementa $<$.

Devuelve

Un circuito que implementa el comparador de enteros.

Tipo de retorno

QuantumCircuit

Referencias

[1] J. Gacon et al. "Optimización basada en la simulación cuántica"

arXiv:2005.10780.

qiskit.synthesis.synth_integer_comparator_greedy(num_state_qubits, value, geq=True)

Implementar una comparación de enteros basada en la comparación valor a valor.

Para value menor que 2 ** (num_state_qubits - 1) este circuito implementa value compuertas multi-controladas con estados de control 0, 1,..., value - 1, tales que el qubit objetivo se voltea si el estado del qubit representa cualquiera de los valores permitidos. Para value mayor que eso, se invierte geq . Esta implementación puede requerir un número exponencial de puertas. Si se dispone de qubits auxiliares, la implementación proporcionada por synth_integer_comparator_2s() es más eficaz.

Parámetros

• num_state_qubits (int) – El número de qubits que codifican el valor con el que comparar.
• value (int) – El valor con el que comparar.
• geq (bool) – Si True voltea el bit de destino si el estado del qubit es $\geq$ que el valor, de lo contrario implementa $<$.

Devuelve

Un circuito que implementa el comparador de enteros.

Tipo de retorno

QuantumCircuit