Biblioteca de circuitos
qiskit.circuit.library
La biblioteca de circuitos es una colección de circuitos cuánticos que sirven como bloques de construcción algorítmicos, herramientas de evaluación comparativa y ejemplos que, según se supone, son difíciles de simular de forma clásica. El objetivo es ofrecer circuitos bien definidos, de amplia aplicabilidad y fáciles de reutilizar en diferentes flujos de trabajo.
Los criterios para que un circuito forme parte de la biblioteca son:
Bien definido
El circuito tiene una estructura clara o un funcionamiento matemático, respaldado por un artículo o una referencia.
De uso generalizado y relevante
El circuito es una opción canónica o la más conocida para una tarea bien definida, constituye una referencia estándar o un punto de partida común, o bien ha sido históricamente fundamental para un subcampo importante de la informática cuántica.
Autónomo
El circuito es autónomo, lo que significa que puede generarse de forma eficiente sin nuevas dependencias externas.
Los elementos de la biblioteca de circuitos son o bien QuantumCircuits o bien Instructions, lo que permite analizarlos fácilmente o integrarlos en otros circuitos. Esto permite la creación rápida de prototipos y el diseño de circuitos en niveles de abstracción más elevados.
Por ejemplo:
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.quantum_info import SparsePauliOp
hamiltonian = SparsePauliOp(["ZZI", "IZZ", "IXI"], coeffs=[1, 1, -1])
gate = PauliEvolutionGate(hamiltonian)
circuit = QuantumCircuit(hamiltonian.num_qubits)
circuit.append(gate, circuit.qubits)
circuit.draw("mpl")
Esta biblioteca está organizada en diferentes secciones:
Distinguimos distintas categorías de operaciones:
Puertas estándar
Se trata de puertas cuánticas fundamentales, un subconjunto de las cuales suele constituir el conjunto básico de puertas de un ordenador cuántico. Se trata de operaciones unitarias representadas como Gate. La biblioteca también proporciona directivas estándar del compilador (a Barrier) y operaciones no unitarias (como Measure).
Operaciones abstractas
Esta categoría incluye operaciones que se definen mediante una acción matemática, pero que pueden llevarse a cabo mediante diferentes descomposiciones. Por ejemplo, una operación de control múltiple XGate invierte el qubit objetivo si todos los qubits de control están en estado « », y existen diversos circuitos concretos que implementan esta operación utilizando puertas de nivel inferior. Estas operaciones abstractas se representan como Gate o Instruction. Esto permite construir el circuito sin tener que elegir una implementación concreta para cada bloque y, finalmente, deja que sea el compilador (o tú mismo, como usuario) quien elija la descomposición óptima. Por ejemplo:
from qiskit.circuit.library import MCXGate
mcx = MCXGate(4)
from qiskit import QuantumCircuit
circuit = QuantumCircuit(5)
circuit.append(mcx, [0, 1, 4, 2, 3])
circuit.draw("mpl")
Para los circuitos con operaciones abstractas, el contexto del circuito se tiene en cuenta durante la transpilación. Por ejemplo, si se dispone de qubits ociosos, pueden utilizarse para obtener un circuito menos profundo:
from qiskit import transpile
small_circuit = QuantumCircuit(5) # here we have no idle qubits
small_circuit.append(mcx, [0, 1, 4, 2, 3])
small_tqc = transpile(small_circuit, basis_gates=["u", "cx"])
print("No aux:", small_tqc.count_ops())
large_circuit = QuantumCircuit(10) # now we will have 5 idle qubits
large_circuit.append(mcx, [0, 1, 4, 2, 3])
large_tqc = transpile(large_circuit, basis_gates=["u", "cx"])
print("With aux:", large_tqc.count_ops())Que imprime:
No aux: OrderedDict([('u', 41), ('cx', 36)])
With aux: OrderedDict([('u', 24), ('cx', 18)])Operaciones estructurales
Estas operaciones tienen una descomposición única. Como el compilador no necesita razonar sobre ellos a un nivel superior, se implementan como funciones que devuelven un QuantumCircuit objeto. Por ejemplo:
from qiskit.circuit.library import real_amplitudes
ansatz = real_amplitudes(5, entanglement="pairwise")
ansatz.draw("mpl")
Puertas estándar
Estas operaciones son puertas unitarias reversibles y todas ellas forman parte de la subclase Gate. En consecuencia, todas ellas cuentan con los métodos to_matrix(), power(), y control(), que, por lo general, solo podemos aplicar a operaciones unitarias.
Por ejemplo:
from qiskit.circuit.library import XGate
gate = XGate()
print(gate.to_matrix()) # X gate
print(gate.power(1/2).to_matrix()) # √X gate -- see also the SXGate
print(gate.control(1).to_matrix()) # CX (controlled X) gate[[0.+0.j 1.+0.j]
[1.+0.j 0.+0.j]]
[[0.5+0.5j 0.5-0.5j]
[0.5-0.5j 0.5+0.5j]]
[[1.+0.j 0.+0.j 0.+0.j 0.+0.j]
[0.+0.j 0.+0.j 0.+0.j 1.+0.j]
[0.+0.j 0.+0.j 1.+0.j 0.+0.j]
[0.+0.j 1.+0.j 0.+0.j 0.+0.j]]La función get_standard_gate_name_mapping() permite ver las puertas y operaciones estándar disponibles.
get_standard_gate_name_mapping
qiskit.circuit.library.get_standard_gate_name_mapping()
Devuelve un diccionario que asigna el nombre de las puertas e instrucciones estándar a un objeto con ese nombre.
Ejemplos
from qiskit.circuit.library import get_standard_gate_name_mapping
gate_name_map = get_standard_gate_name_mapping()
cx_object = gate_name_map["cx"]
print(cx_object)
print(type(cx_object))Instruction(name='cx', num_qubits=2, num_clbits=0, params=[])
_SingletonCXGatePuertas estándar de 1 qubit
Columna « 1 » | Columna « 2 » |
|---|---|
HGate(*args[, _force_mutable] ) | Puerta Hadamard de un solo qubit. |
IGate(*args[, _force_mutable] ) | Puerta de la identidad. |
PhaseGate(theta[, etiqueta] ) | Rotación de un qubit alrededor del eje Z. |
RGate(theta, phi[, etiqueta] ) | Rotación alrededor del eje . |
RXGate(theta[, etiqueta] ) | Rotación de un qubit sobre el eje X. |
RYGate(theta[, etiqueta] ) | Rotación de un qubit sobre el eje Y. |
RZGate(phi[, etiqueta] ) | Rotación de un qubit alrededor del eje Z. |
SGate(*args[, _force_mutable] ) | Puerta S de un solo qubit ( ). |
SdgGate(*args[, _force_mutable] ) | Puerta S-adjungida de un solo qubit ( ). |
SXGate(*args[, _force_mutable] ) | La puerta Sqrt(X) de un solo qubit ( ). |
SXdgGate(*args[, _force_mutable] ) | La puerta inversa de un solo qubit Sqrt(X). |
TGate(*args[, _force_mutable] ) | Puerta T de un solo qubit ( ). |
TdgGate(*args[, _force_mutable] ) | Puerta T-adjungida de un solo qubit ( ). |
UGate(theta, phi, lam[, label] ) | Rotación genérica de un solo qubit en términos de ángulos de Euler ZYZ. |
U1Gate(theta[, etiqueta] ) | Rotación de un qubit alrededor del eje Z. |
U2Gate(phi, lam[, etiqueta] ) | Rotación de un qubit alrededor del eje X+Z. |
U3Gate(theta, phi, lam[, label] ) | Puerta de rotación genérica de un solo qubit con 3 ángulos de Euler. |
XGate(*args[, _force_mutable] ) | La puerta Pauli-X de un solo qubit ( ). |
YGate(*args[, _force_mutable] ) | La puerta Pauli-Y de un solo qubit ( ). |
ZGate(*args[, _force_mutable] ) | La puerta Pauli-Z de un solo qubit ( ). |
Puertas estándar de 2 qubits
Columna « 1 » | Columna « 2 » |
|---|---|
CHGate(*args[, _force_mutable] ) | Puerta de Hadamard controlada. |
CPhaseGate(theta[, etiqueta, ctrl_state,...] ) | Puerta de fase controlada. |
CRXGate(theta[, etiqueta, ctrl_state, _base_etiqueta] ) | Puerta de recepción controlada. |
CRYGate(theta[, etiqueta, ctrl_state, _base_etiqueta] ) | Puerta controlada-RY. |
CRZGate(theta[, etiqueta, ctrl_state, _base_etiqueta] ) | Puerta RZ controlada. |
CSGate(*args[, _force_mutable] ) | Puerta S controlada. |
CSdgGate(*args[, _force_mutable] ) | Controlada: compuerta de tipo « ». |
CSXGate(*args[, _force_mutable] ) | Puerta controlada-√X. |
CUGate(theta, phi, lam, gamma[, label,...] ) | Puerta U controlada (puerta de dos qubits de 4 parámetros). |
CU1Gate(theta[, etiqueta, ctrl_state, _base_etiqueta] ) | Controlled-U1 puerta. |
CU3Gate(theta, phi, lam[, label,...] ) | Controlled-U3 (puerta de dos qubits de 3 parámetros). |
CXGate(*args[, _force_mutable] ) | Puerta X controlada. |
CYGate(*args[, _force_mutable] ) | Puerta en Y controlada. |
CZGate(*args[, _force_mutable] ) | Puerta Z controlada. |
DCXGate(*args[, _force_mutable] ) | Compuerta doble CX. |
ECRGate(*args[, _force_mutable] ) | Una puerta de resonancia cruzada con eco. |
iSwapGate(*args[, _force_mutable] ) | iSWAP puerta. |
RXXGate(theta[, etiqueta] ) | Una interacción paramétrica de 2 qubits (rotación alrededor de XX). |
RYYGate(theta[, etiqueta] ) | Una interacción paramétrica de 2 qubits (rotación alrededor de YY). |
RZXGate(theta[, etiqueta] ) | Una interacción paramétrica de 2 qubits (rotación alrededor de ZX). |
RZZGate(theta[, etiqueta] ) | Una interacción paramétrica de 2 qubits (rotación alrededor de ZZ). |
SwapGate(*args[, _force_mutable] ) | La puerta SWAP. |
XXMinusYYGate(theta[, beta, etiqueta] ) | Puerta de interacción XX-YY. |
XXPlusYYGate(theta[, beta, etiqueta] ) | Puerta de interacción XX+YY. |
Puertas estándar de 3+ qubits
Columna « 1 » | Columna « 2 » |
|---|---|
C3SXGate(*args[, _force_mutable] ) | La puerta sqrt-X controlada por 3 qubits. |
C3XGate(*args[, _force_mutable] ) | La puerta X controlada en 3 qubits. |
C4XGate(*args[, _force_mutable] ) | La puerta X controlada por 4 qubits. |
CCXGate(*args[, _force_mutable] ) | Puerta CCX, también conocida como puerta Toffoli. |
CCZGate(*args[, _force_mutable] ) | Puerta CCZ. |
CSwapGate(*args[, _force_mutable] ) | Puerta SWAP controlada, también llamada puerta Fredkin. |
RCCXGate(*args[, _force_mutable] ) | La puerta simplificada de Toffoli, también llamada puerta de Margolus. |
RC3XGate(*args[, _force_mutable] ) | La puerta de Toffoli simplificada de 3 controles. |
Puertas estándar globales
La siguiente puerta es global y no toma ningún argumento qubit.
Columna « 1 » | Columna « 2 » |
|---|---|
GlobalPhaseGate(fase[, etiqueta] ) | La puerta de fase global ( ). |
Directivas estándar
Las directivas son operaciones de la pila cuántica destinadas a ser interpretadas por el backend o el transpilador. En general, el transpilador o el backend pueden ignorarlos opcionalmente si no existe una implementación para ellos.
Operaciones estándar
Las operaciones son cambios no reversibles en el estado cuántico del circuito.
Además Measure, existe una medición conjunta de Pauli generalizada, que se utiliza como operación básica en el cálculo basado en Pauli.
Columna « 1 » | Columna « 2 » |
|---|---|
PauliProductMeasurement(Pauli[, sello discográfico] ) | Instrucciones para la medición de productos Pauli. |
Puertas generalizadas
Este módulo amplía las compuertas estándar con una colección más amplia de compuertas básicas. Esto incluye puertas que son variádicas, lo que significa que el número de qubits depende de la entrada. Por ejemplo:
from qiskit.circuit.library import DiagonalGate
diagonal = DiagonalGate([1, 1j])
print(diagonal.num_qubits)
diagonal = DiagonalGate([1, 1, 1, -1])
print(diagonal.num_qubits)que imprime:
1
2Columna « 1 » | Columna « 2 » |
|---|---|
DiagonalGate(diag) | Una puerta cuántica diagonal genérica. |
PermutationGate(patrón) | Una puerta que permuta qubits. |
MCMTGate(puerta, num_ctrl_qubits,...[,...] ) | La puerta multiobjetivo multicontrolada, para una puerta objetivo arbitraria controlada individualmente. |
MCPhaseGate(lam, num_ctrl_qubits[, label,...] ) | Puerta multifase controlada. |
MCXGate( [num_ctrl_qubits, etiqueta,...] ) | La puerta X general multicontrolada. |
MSGate(num_qubits, theta[, label] ) | La puerta Mølmer-Sørensen. |
RVGate(v_x, v_y, v_z[, base] ) | Rotación alrededor de un eje de rotación arbitrario , donde es el ángulo de rotación en radianes. |
PauliGate(etiqueta) | Una puerta Pauli multi-qubit. |
PauliProductRotationGate(pauli, ángulo[, etiqueta] ) | Una rotación de Pauli genérica. |
LinearFunction(lineal[, validate_input] ) | Un circuito lineal reversible en n qubits. |
Isometry(isometría, num_ancillas_zero,...[,...] ) | Descomposición de isometrías arbitrarias de a qubits. |
UnitaryGate(datos[, etiqueta, check_input,...] ) | Clase para puertas cuánticas especificadas por una matriz unitaria. |
UCGate(lista_de_puertas[, hasta_la_diagonal, multiplexor_simp] ) | Puerta de control uniforme (también llamada puerta multiplexada). |
UCPauliRotGate(ángulo_lista, eje_rotación) | Rotaciones Pauli uniformemente controladas. |
UCRXGate(lista_de_ángulos) | Rotaciones Pauli-X uniformemente controladas. |
UCRYGate(lista_de_ángulos) | Rotaciones Pauli-Y uniformemente controladas. |
UCRZGate(lista_de_ángulos) | Rotaciones Pauli-Z uniformemente controladas. |
Los objetos anteriores derivan Gate o Instruction, lo que permite al compilador analizarlos a un nivel abstracto. Por lo tanto, sugerimos utilizar estos en lugar de los siguientes, que se derivan QuantumCircuit y se construyen de forma anticipada.
Columna « 1 » | Columna « 2 » |
|---|---|
Diagonal(diag) | Circuito que implementa una transformación diagonal. |
MCMT(puerta, num_ctrl_qubits, num_target_qubits) | La puerta multiobjetivo multicontrolada, para una puerta objetivo arbitraria controlada individualmente. |
MCMTVChain(puerta, num_ctrl_qubits,...) | La implementación de MCMT utilizando la cadena en V CCX. |
MCXGrayCode( [num_ctrl_qubits, etiqueta,...] ) | Implementa la puerta X multicontrolada utilizando el código Gray. |
MCXRecursive( [num_ctrl_qubits, etiqueta,...] ) | Implementa la puerta X multicontrolada utilizando recursividad. |
MCXVChain( [num_ctrl_qubits, dirty_ancillas,...] ) | Implementa la puerta X multicontrolada utilizando una cadena en V de puertas CX. |
Permutation(núm_qubits[, patrón, semilla] ) | Un circuito n_qubit que permuta qubits. |
GMS(num_qubits, theta) | Puerta Global Mølmer-Sørensen. |
GR(num_qubits, theta, phi) | Puerta R global. |
GRX(num_qubits, theta) | Puerta RX global. |
GRY(num_qubits, theta) | Puerta global RY. |
GRZ(num_qubits, phi) | Puerta RZ global. |
Lógica booleana
GateEstos implementan operaciones lógicas booleanas, como la lógica or de un conjunto de estados de qubits.
Columna « 1 » | Columna « 2 » |
|---|---|
AndGate(núm. de qubits variables[, indicadores] ) | Una puerta que representa la operación lógica AND en un número de qubits. |
OrGate(núm. de qubits variables[, indicadores] ) | Una puerta que representa la operación lógica OR en un número de qubits. |
BitwiseXorGate(núm_qubits, cantidad) | Una puerta de n-qubits para xorizar bit a bit la entrada con algún entero amount. |
InnerProductGate(núm. de qubits) | Una función booleana 2n-qubit que calcula el producto interior de dos vectores n-qubit sobre . |
Los objetos anteriores derivan Gate de este tipo (o lo devuelven), lo que permite al compilador analizarlos a un nivel abstracto. Por lo tanto, sugerimos utilizar estos en lugar de los siguientes, que se derivan QuantumCircuit y se construyen de forma anticipada.
Columna « 1 » | Columna « 2 » |
|---|---|
AND(num_variable_qubits[, flags, mcx_mode] ) | Circuito que ejecuta la operación lógica AND en varios qubits. |
OR(num_variable_qubits[, flags, mcx_mode] ) | Circuito que realiza la operación OR lógica en varios qubits. |
XOR(núm_qubits[, cantidad, semilla] ) | Un circuito n_qubit para xor-ing bitwise la entrada con algún entero amount. |
InnerProduct(núm. de qubits) | Una función booleana 2n-qubit que calcula el producto interior de dos vectores n-qubit sobre . |
Un circuito aleatorio bitwise xor puede generarse directamente utilizando:
Columna « 1 » | Columna « 2 » |
|---|---|
random_bitwise_xor(num_qubits, seed) | Cree un BitwiseXorGate aleatorio. |
Cambio de base
Estas puertas realizan transformaciones de base de los estados de los qubits. Por ejemplo, en el caso de la Transformada Cuántica de Fourier (QFT), se transforma entre la base de cálculo y la base de Fourier.
Columna « 1 » | Columna « 2 » |
|---|---|
QFTGate(núm. de qubits) | Puerta de transformada cuántica de Fourier. |
El objeto anterior deriva Gate, lo que permite al compilador analizarlo a un nivel abstracto. Por lo tanto, sugerimos utilizar esto en lugar de lo siguiente, que se deriva QuantumCircuit y se construye de forma anticipada.
Columna « 1 » | Columna « 2 » |
|---|---|
QFT( [núm_qubits, grado_de_aproximación,...] ) | Circuito de transformada cuántica de Fourier. |
Aritmético
Estas puertas y circuitos realizan operaciones aritméticas clásicas, como la suma o la multiplicación.
Víboras
Los sumadores calculan la suma de dos registros -qubit, es decir
donde el tamaño del registro de salida depende del tipo de sumador utilizado.
Columna « 1 » | Columna « 2 » |
|---|---|
ModularAdderGate(núm. de qubits de estado[, etiqueta] ) | Calcular la suma módulo de dos registros de qubits de tamaño . |
HalfAdderGate(núm. de qubits de estado[, etiqueta] ) | Calcula la suma de dos registros de qubits de igual tamaño, incluyendo un bit de salida. |
FullAdderGate(núm. de qubits de estado[, etiqueta] ) | Calcular la suma de dos registros de qubits de tamaño , incluyendo los bits de entrada y salida. |
Los objetos anteriores derivan Gate, lo que permite al compilador analizarlos a un nivel abstracto. Por lo tanto, sugerimos utilizar estos en lugar de los siguientes, que se derivan QuantumCircuit y se construyen de forma anticipada.
Columna « 1 » | Columna « 2 » |
|---|---|
DraperQFTAdder(núm. de qubits de estado[, tipo, nombre] ) | Un circuito que utiliza la QFT para realizar sumas en el mismo lugar en dos registros de qubits. |
CDKMRippleCarryAdder(núm. de qubits de estado[,...] ) | Un circuito ripple-carry para realizar sumas in-place en dos registros qubit. |
VBERippleCarryAdder(núm. de qubits de estado[,...] ) | El sumador de arrastre de ondulación VBE [1]. |
multiplicadores
Los multiplicadores calculan el producto de dos registros -qubit, es decir
donde es el número de bits utilizados para representar el resultado.
Columna « 1 » | Columna « 2 » |
|---|---|
MultiplierGate(núm. de qubits de estado[,...] ) | Calcula el producto de dos registros de qubits de igual tamaño en un nuevo registro. |
El objeto anterior deriva Gate, lo que permite al compilador analizarlo a un nivel abstracto. Por lo tanto, sugerimos utilizar esto en lugar de lo siguiente, que se deriva QuantumCircuit y se construye de forma anticipada.
Columna « 1 » | Columna « 2 » |
|---|---|
HRSCumulativeMultiplier(núm. de qubits de estado[,...] ) | Un circuito de multiplicación para almacenar el producto de dos registros de entrada fuera de lugar. |
RGQFTMultiplier(núm. de qubits de estado[,...] ) | Un circuito de multiplicación QFT para almacenar el producto de dos registros de entrada fuera de lugar. |
Funciones de amplitud
Una función de amplitud aproxima una función aplicada sobre las amplitudes de qubits. Consulte la documentación de la clase para obtener información más detallada.
Columna « 1 » | Columna « 2 » |
|---|---|
LinearAmplitudeFunctionGate(...[, ...]) | Un circuito que implementa una función lineal (a trozos) sobre las amplitudes de los qubits. |
El objeto anterior deriva Gate, lo que permite al compilador analizarlo a un nivel abstracto. Por lo tanto, sugerimos utilizar esto en lugar de lo siguiente, que se deriva QuantumCircuit y se construye de forma anticipada.
Columna « 1 » | Columna « 2 » |
|---|---|
LinearAmplitudeFunction(núm. de qubits de estado,...) | Un circuito que implementa una función lineal (a trozos) sobre las amplitudes de los qubits. |
Rotaciones funcionales de Pauli
Las rotaciones funcionales de Pauli implementan operaciones de la forma
utilizando rotaciones Pauli- para diferentes tipos de funciones , como lineales, polinómicas o una versión a trozos de éstas. Son similares a las funciones de amplitud anteriores, pero sin preprocesamiento ni postprocesamiento para el dominio y la imagen de la función objetivo.
Columna « 1 » | Columna « 2 » |
|---|---|
LinearPauliRotationsGate(núm. de qubits de estado[,...] ) | Rotación X, Y o Z controlada linealmente. |
PolynomialPauliRotationsGate(núm. de qubits de estado) | Una puerta que implementa rotaciones Pauli polinómicas. |
PiecewiseLinearPauliRotationsGate([...]) | Rotaciones Pauli controladas linealmente a trozos. |
PiecewisePolynomialPauliRotationsGate(...[, ...]) | Rotaciones Pauli controladas a trozos. |
PiecewiseChebyshevGate(f_x, num_state_qubits) | Aproximación Chebyshev a trozos a una función de entrada. |
Los objetos anteriores derivan Gate, lo que permite al compilador analizarlos a un nivel abstracto. Por lo tanto, sugerimos utilizar estos en lugar de los siguientes, que se derivan QuantumCircuit y se construyen de forma anticipada.
Columna « 1 » | Columna « 2 » |
|---|---|
FunctionalPauliRotations( [núm. de qubits de estado,...] ) | Clase base para rotaciones Pauli funcionales. |
LinearPauliRotations( [núm. de qubits de estado,...] ) | Rotación X, Y o Z controlada linealmente. |
PolynomialPauliRotations( [núm. de qubits de estado,...] ) | Un circuito que implementa rotaciones Pauli polinómicas. |
PiecewiseLinearPauliRotations([...]) | Rotaciones Pauli controladas linealmente a trozos. |
PiecewisePolynomialPauliRotations([...]) | Rotaciones Pauli controladas a trozos. |
PiecewiseChebyshev(f_x[, grado,...] ) | Aproximación Chebyshev a trozos a una función de entrada. |
Otras funciones aritméticas
A continuación se enumeran otros circuitos aritméticos. Consulte la documentación de cada clase para obtener más información.
Columna « 1 » | Columna « 2 » |
|---|---|
ExactReciprocalGate(número de qubits de estado, escalado) | Implementa una función recíproca exacta. |
IntegerComparatorGate(núm. de qubits de estado, valor) | Realice un (o ) en un registro qubit contra un entero clásico. |
QuadraticFormGate( [núm_result_qubits,...] ) | Implementa una forma cuadrática en variables binarias codificadas en registros qubit. |
WeightedSumGate(número de qubits de estado[, pesos,...] ) | Una puerta para calcular la suma ponderada de registros de qubits. |
Los objetos anteriores derivan Gate, lo que permite al compilador analizarlos a un nivel abstracto. Por lo tanto, sugerimos utilizar estos en lugar de los siguientes, que se derivan QuantumCircuit y se construyen de forma anticipada.
Columna « 1 » | Columna « 2 » |
|---|---|
ExactReciprocal(número de qubits de estado, escalado[,...] ) | Recíproco exacto |
IntegerComparator( [núm_qubits_de_estado, valor,...] ) | Comparador de enteros. |
QuadraticForm( [núm_result_qubits,...] ) | Implementa una forma cuadrática en variables binarias codificadas en registros qubit. |
WeightedAdder( [núm. de qubits de estado, pesos, nombre] ) | Un circuito para calcular la suma ponderada de registros de qubits. |
Circuitos cuánticos particulares
Las siguientes puertas y circuitos cuánticos definen operaciones específicas de interés:
Columna « 1 » | Columna « 2 » |
|---|---|
fourier_checking(f, g) | Circuito de comprobación de Fourier. |
hidden_linear_function(matriz de adyacencia) | Circuito para resolver el problema de la función lineal oculta. |
iqp(interacciones) | Circuito de tiempo polinómico cuántico instantáneo (IQP). |
random_iqp(num_qubits[, seed] ) | Un circuito instantáneo aleatorio de tiempo polinómico cuántico (IQP). |
quantum_volume(núm_qubits[, profundidad, semilla] ) | Un circuito modelo de volumen cuántico. |
phase_estimation(núm. de qubits de evaluación, unitaria) | Circuito de estimación de fase. |
grover_operator(oráculo[, preparación del estado,...] ) | Construye el operador Grover. |
unitary_overlap(unitary1, unitary2[, ...]) | Circuito que devuelve el solapamiento entre dos unitarios . |
GraphStateGate(matriz de adyacencia) | Una puerta que representa el estado de un gráfico. |
PauliEvolutionGate(operador[, tiempo, etiqueta,...] ) | Evolución temporal de un operador formado por Paulis. |
HamiltonianGate(datos, hora[, etiqueta] ) | Clase para representar la evolución por un operador Hamiltoniano como una puerta. |
A continuación proporcionamos las mismas operaciones que las clases que derivan de QuantumCircuit. Sin embargo, para mejorar el tiempo de ejecución y el rendimiento del compilador, sugerimos utilizar las funciones y compuertas anteriores.
Columna « 1 » | Columna « 2 » |
|---|---|
FourierChecking(f, g) | Circuito de comprobación de Fourier. |
GraphState(matriz de adyacencia) | Circuito para preparar un estado gráfico. |
HiddenLinearFunction(matriz de adyacencia) | Circuito para resolver el problema de la función lineal oculta. |
IQP(interacciones) | Circuito de polinomio cuántico instantáneo (IQP). |
QuantumVolume(núm_qubits[, profundidad, semilla,...] ) | Un circuito modelo de volumen cuántico. |
PhaseEstimation(núm. de qubits de evaluación, unitaria) | Circuito de estimación de fase. |
GroverOperator(oráculo[, preparación del estado,...] ) | El operador Grover. |
UnitaryOverlap(unitary1, unitary2[, ...]) | Circuito que devuelve el solapamiento entre dos unitarios . |
Circuitos N-locales
Las siguientes funciones devuelven un QuantumCircuit para utilizarlo como ansatz en un amplio conjunto de algoritmos cuánticos variacionales.
Por ejemplo, podemos construir un circuito variacional
from qiskit.circuit.library import efficient_su2
num_qubits = 4
ansatz = efficient_su2(num_qubits, entanglement="pairwise")
ansatz.draw("mpl")
y combinarlo con
from qiskit.circuit.library import zz_feature_map
circuit = zz_feature_map(num_qubits)
circuit.barrier()
circuit.compose(ansatz, inplace=True)
circuit.draw("mpl")
para obtener un circuito de clasificación cuántica variacional.
Todas las funciones siguientes construyen circuitos variacionales y están optimizadas para una construcción rápida:
Columna « 1 » | Columna « 2 » |
|---|---|
n_local(núm_qubits, bloques_de_rotación,...[,...] ) | Construir un circuito variacional n-local. |
efficient_su2(num_qubits[, su2_gates,...] ) | El circuito hardware-eficiente 2-local. |
real_amplitudes(número de qubits[, entrelazamiento,...] ) | Construye un circuito 2-local de amplitudes reales. |
pauli_two_design(núm_qubits[, reps, seed,...] ) | Construir un ansatz de Pauli 2-design. |
excitation_preserving(núm_qubits[, modo,...] ) | El ansatz heurístico de la función de onda que preserva la excitación. |
qaoa_ansatz(coste_operador[, repeticiones,...] ) | Un circuito cuántico QAOA generalizado con soporte de estados iniciales y mezcladores personalizados. |
hamiltonian_variational_ansatz(hamiltoniano) | Construir un ansatz variacional hamiltoniano. |
evolved_operator_ansatz(operadores[, representantes, etc.] ) | Construir un ansatz a partir de evoluciones de operadores. |
Aunque sugerimos utilizar las funciones anteriores, también seguimos apoyando las siguientes BlueprintCircuit, que envuelven los circuitos en un bloque y permiten mutaciones in situ de los circuitos:
Columna « 1 » | Columna « 2 » |
|---|---|
NLocal( [núm_qubits, bloques_de_rotación,...] ) | La clase de circuito n-local. |
TwoLocal( [núm_qubits, bloques_de_rotación,...] ) | El circuito de dos locales. |
PauliTwoDesign( [núm_qubits, reps, seed,...] ) | El ansatz de Pauli de dos diseños. |
RealAmplitudes( [número de qubits, entrelazamiento,...] ) | El circuito 2-local de amplitudes reales. |
EfficientSU2( [num_qubits, su2_gates,...] ) | El circuito hardware eficiente SU(2) 2-local. |
EvolvedOperatorAnsatz( [operadores, representantes, etc.] ) | El operador evolucionado ansatz. |
ExcitationPreserving( [núm_qubits, modo,...] ) | El ansatz heurístico de la función de onda que preserva la excitación. |
QAOAAnsatz( [coste_operador, repeticiones,...] ) | Un circuito cuántico QAOA generalizado con soporte de estados iniciales y mezcladores personalizados. |
Circuitos de codificación de datos
Las siguientes funciones devuelven un QuantumCircuit para utilizarlo como circuitos de codificación de datos en una serie de algoritmos cuánticos variacionales:
Columna « 1 » | Columna « 2 » |
|---|---|
pauli_feature_map(característica_dimensión[, repeticiones,...] ) | El circuito de expansión de Pauli. |
z_feature_map(característica_dimensión[, repeticiones,...] ) | El circuito de evolución Z de Pauli de primer orden. |
zz_feature_map(característica_dimensión[, repeticiones,...] ) | Circuito de evolución Pauli-Z de segundo orden. |
Aunque sugerimos utilizar las funciones anteriores, también seguimos apoyando las siguientes BlueprintCircuit, que envuelven los circuitos en un bloque y permiten mutaciones in situ de los circuitos:
Columna « 1 » | Columna « 2 » |
|---|---|
PauliFeatureMap( [característica_dimensión, repeticiones,...] ) | El circuito de expansión de Pauli. |
ZFeatureMap(característica_dimensión[, repeticiones,...] ) | El circuito de evolución Z de Pauli de primer orden. |
ZZFeatureMap(característica_dimensión[, repeticiones,...] ) | Circuito de evolución Pauli-Z de segundo orden. |
Circuitos de preparación de datos
Las siguientes operaciones se utilizan para la preparación del estado:
Columna « 1 » | Columna « 2 » |
|---|---|
StatePreparation(parámetros[, num_qubits,...] ) | Preparación del estado de amplitud compleja. |
Initialize(parámetros[, número de qubits, normalizar] ) | Inicialización de amplitud compleja. |
Oráculos
Un "oráculo" puede referirse a una variedad de operaciones de caja negra sobre estados cuánticos. Aquí consideramos oráculos que implementan funciones booleanas mediante cambios de fase
o bit-flips
Se aplican en
Columna « 1 » | Columna « 2 » |
|---|---|
PhaseOracleGate(expresión[, var_order, etiqueta] ) | Implementa un oráculo de fase. |
BitFlipOracleGate(expresión[, var_order, etiqueta] ) | Implementa un oráculo de bit-flip |
y un elemento fundamental del algoritmo de Grover (véase grover_operator()).
GateAdemás de la implementación basada en, también admitimos la QuantumCircuitversión del oráculo de inversión de fase
Columna « 1 » | Columna « 2 » |
|---|---|
PhaseOracle(expresión[, var_order] ) | Fase Oracle. |
Circuitos de plantilla
Las plantillas son funciones que devuelven circuitos que calculan la identidad. Se utilizan en la optimización de circuitos, donde la coincidencia de una parte de la plantilla permite al compilador sustituir la coincidencia por la inversa del resto de la plantilla.
En este ejemplo, se comprueba la constante de identidad de una plantilla:
from qiskit.circuit.library.templates import template_nct_4b_1
from qiskit.quantum_info import Operator
import numpy as np
template = template_nct_4b_1()
identity = np.identity(2 ** len(template.qubits), dtype=complex)
data = Operator(template).data
np.allclose(data, identity) # True, template_nct_4b_1 is the identityCircuitos modelo NCT (Not-CNOT-Toffoli)
XGateCircuitos modelo para las puertas, CXGate, y CCXGate (Toffoli).
Referencias:
Maslov, D. y Dueck, G. W. y Miller, D. M., Técnicas de síntesis de redes Toffoli reversibles, 2007 https://dx.doi.org/10.1145/1278349.1278355
template_nct_2a_1
qiskit.circuit.library.templates.nct.template_nct_2a_1()
Plantilla 2a_1:
┌───┐┌───┐
q_0: ┤ X ├┤ X ├
└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_2a_2
qiskit.circuit.library.templates.nct.template_nct_2a_2()
Plantilla 2a_2:
q_0: ──■────■──
┌─┴─┐┌─┴─┐
q_1: ┤ X ├┤ X ├
└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_2a_3
qiskit.circuit.library.templates.nct.template_nct_2a_3()
Plantilla 2a_3:
q_0: ──■────■──
│ │
q_1: ──■────■──
┌─┴─┐┌─┴─┐
q_2: ┤ X ├┤ X ├
└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_4a_1
qiskit.circuit.library.templates.nct.template_nct_4a_1()
Plantilla 4a_1:
q_0: ───────■─────────■──
│ │
q_1: ──■────┼────■────┼──
│ │ │ │
q_2: ──■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_3: ──┼──┤ X ├──┼──┤ X ├
┌─┴─┐└───┘┌─┴─┐└───┘
q_4: ┤ X ├─────┤ X ├─────
└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_4a_2
qiskit.circuit.library.templates.nct.template_nct_4a_2()
Plantilla 4a_2:
q_0: ──■─────────■───────
│ │
q_1: ──■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_2: ──┼──┤ X ├──┼──┤ X ├
┌─┴─┐└───┘┌─┴─┐└───┘
q_3: ┤ X ├─────┤ X ├─────
└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_4a_3
qiskit.circuit.library.templates.nct.template_nct_4a_3()
Plantilla 4a_3:
q_0: ──■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_1: ──┼──┤ X ├──┼──┤ X ├
┌─┴─┐└───┘┌─┴─┐└───┘
q_2: ┤ X ├─────┤ X ├─────
└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_4b_1
qiskit.circuit.library.templates.nct.template_nct_4b_1()
Plantilla 4b_1:
q_0: ───────■─────────■──
│ │
q_1: ──■────┼────■────┼──
│ │ │ │
q_2: ──■────■────■────■──
┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_3: ┤ X ├┤ X ├┤ X ├┤ X ├
└───┘└───┘└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_4b_2
qiskit.circuit.library.templates.nct.template_nct_4b_2()
Plantilla 4b_2:
q_0: ──■─────────■───────
│ │
q_1: ──■────■────■────■──
┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_2: ┤ X ├┤ X ├┤ X ├┤ X ├
└───┘└───┘└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_5a_1
qiskit.circuit.library.templates.nct.template_nct_5a_1()
Plantilla 5a_1:
q_0: ──■────■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐ │
q_1: ──■──┤ X ├──■──┤ X ├──┼──
┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
q_2: ┤ X ├─────┤ X ├─────┤ X ├
└───┘ └───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_5a_2
qiskit.circuit.library.templates.nct.template_nct_5a_2()
Plantilla 5a_2:
q_0: ──■─────────■─────────■──
│ ┌───┐ │ ┌───┐ │
q_1: ──■──┤ X ├──■──┤ X ├──┼──
┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
q_2: ┤ X ├─────┤ X ├─────┤ X ├
└───┘ └───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_5a_3
qiskit.circuit.library.templates.nct.template_nct_5a_3()
Plantilla 5a_3:
q_0: ───────■─────────■────■──
┌─┴─┐ ┌─┴─┐ │
q_1: ──■──┤ X ├──■──┤ X ├──┼──
┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
q_2: ┤ X ├─────┤ X ├─────┤ X ├
└───┘ └───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_5a_4
qiskit.circuit.library.templates.nct.template_nct_5a_4()
Plantilla 5a_4:
┌───┐ ┌───┐
q_0: ──■──┤ X ├──■──┤ X ├
┌─┴─┐└───┘┌─┴─┐├───┤
q_1: ┤ X ├─────┤ X ├┤ X ├
└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_6a_1
qiskit.circuit.library.templates.nct.template_nct_6a_1()
Plantilla 6a_1:
┌───┐ ┌───┐ ┌───┐
q_0: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_1: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_6a_2
qiskit.circuit.library.templates.nct.template_nct_6a_2()
Plantilla 6a_2:
q_0: ──■────■────■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_6a_3
qiskit.circuit.library.templates.nct.template_nct_6a_3()
Plantilla 6a_3:
q_0: ───────■─────────■────■────■──
┌─┴─┐ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_6a_4
qiskit.circuit.library.templates.nct.template_nct_6a_4()
Plantilla 6a_4:
q_0: ───────■──────────────■───────
┌─┴─┐ ┌───┐ │ ┌───┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_6b_1
qiskit.circuit.library.templates.nct.template_nct_6b_1()
Plantilla 6b_1:
q_0: ──■─────────■────■─────────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────■──┤ X ├──■────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_6b_2
qiskit.circuit.library.templates.nct.template_nct_6b_2()
Plantilla 6b_2:
q_0: ───────■────■─────────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────■──┤ X ├──■────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_6c_1
qiskit.circuit.library.templates.nct.template_nct_6c_1()
Plantilla 6c_1:
q_0: ──■─────────■─────────■────■──
│ ┌───┐ │ ┌───┐ │ ┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_7a_1
qiskit.circuit.library.templates.nct.template_nct_7a_1()
Plantilla 7a_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└─┬─┘┌─┴─┐ │ ┌─┴─┐└─┬─┘ │
q_1: ──■──┤ X ├──■────■──┤ X ├──■────■──
└───┘┌─┴─┐┌─┴─┐└───┘ ┌─┴─┐
q_2: ──────────┤ X ├┤ X ├──────────┤ X ├
└───┘└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_7b_1
qiskit.circuit.library.templates.nct.template_nct_7b_1()
Plantilla 7b_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└───┘┌─┴─┐ │ ┌─┴─┐└───┘ │
q_1: ─────┤ X ├──■────■──┤ X ├───────■──
└───┘┌─┴─┐┌─┴─┐└───┘ ┌─┴─┐
q_2: ──────────┤ X ├┤ X ├──────────┤ X ├
└───┘└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_7c_1
qiskit.circuit.library.templates.nct.template_nct_7c_1()
Plantilla 7c_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└───┘┌─┴─┐ │ ┌─┴─┐└───┘ │
q_1: ─────┤ X ├──■────■──┤ X ├───────■──
└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘ ┌─┴─┐
q_2: ───────■──┤ X ├┤ X ├──■───────┤ X ├
└───┘└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_7d_1
qiskit.circuit.library.templates.nct.template_nct_7d_1()
Plantilla 7d_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└─┬─┘┌─┴─┐ │ ┌─┴─┐└─┬─┘ │
q_1: ──■──┤ X ├──■────■──┤ X ├──■────■──
└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘ ┌─┴─┐
q_2: ───────■──┤ X ├┤ X ├──■───────┤ X ├
└───┘└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_7e_1
qiskit.circuit.library.templates.nct.template_nct_7e_1()
Plantilla 7e_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└───┘┌─┴─┐ │ ┌─┴─┐└───┘ │
q_1: ─────┤ X ├───────┼──┤ X ├───────┼──
└─┬─┘┌───┐┌─┴─┐└─┬─┘ ┌─┴─┐
q_2: ───────■──┤ X ├┤ X ├──■───────┤ X ├
└───┘└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9a_1
qiskit.circuit.library.templates.nct.template_nct_9a_1()
Plantilla 9a_1:
┌───┐ ┌───┐ ┌───┐
q_0: ┤ X ├──■──┤ X ├──■────■──┤ X ├──■──
└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├
└─┬─┘ │ ├───┤└─┬─┘┌───┐└─┬─┘
q_2: ───────■────■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_1
qiskit.circuit.library.templates.nct.template_nct_9c_1()
Plantilla 9c_1:
┌───┐ ┌───┐┌───┐ ┌───┐ ┌───┐
q_0: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_1: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_2
qiskit.circuit.library.templates.nct.template_nct_9c_2()
Plantilla 9c_2:
q_0: ───────■────■──────────────■────■─────────■──
┌───┐ │ ┌─┴─┐┌───┐ ┌─┴─┐ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_3
qiskit.circuit.library.templates.nct.template_nct_9c_3()
Plantilla 9c_3:
q_0: ───────■────────────────────────■────────────
┌───┐ │ ┌───┐┌───┐ ┌───┐ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_4
qiskit.circuit.library.templates.nct.template_nct_9c_4()
Plantilla 9c_4:
q_0: ──■────■─────────■──────────────■────────────
┌─┴─┐ │ ┌───┐┌─┴─┐ ┌───┐ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_5
qiskit.circuit.library.templates.nct.template_nct_9c_5()
Plantilla 9c_5:
q_0: ────────────■─────────■──────────────■───────
┌───┐ ┌─┴─┐┌───┐ │ ┌───┐ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_6
qiskit.circuit.library.templates.nct.template_nct_9c_6()
Plantilla 9c_6:
q_0: ───────■────■─────────■─────────■────■───────
┌───┐ │ ┌─┴─┐┌───┐ │ ┌───┐ │ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_7
qiskit.circuit.library.templates.nct.template_nct_9c_7()
Plantilla 9c_7:
q_0: ──■────■────■────■────■─────────■────■───────
┌─┴─┐ │ ┌─┴─┐┌─┴─┐ │ ┌───┐ │ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_8
qiskit.circuit.library.templates.nct.template_nct_9c_8()
Plantilla 9c_8:
q_0: ──■─────────■────■─────────■──────────────■──
┌─┴─┐ ┌─┴─┐┌─┴─┐ ┌─┴─┐ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_9
qiskit.circuit.library.templates.nct.template_nct_9c_9()
Plantilla 9c_9:
q_0: ──■────■────■────■─────────■────■─────────■──
┌─┴─┐ │ ┌─┴─┐┌─┴─┐ ┌─┴─┐ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_10
qiskit.circuit.library.templates.nct.template_nct_9c_10()
Plantilla 9c_10:
q_0: ──■─────────■────■────■────■─────────■────■──
┌─┴─┐ ┌─┴─┐┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_11
qiskit.circuit.library.templates.nct.template_nct_9c_11()
Plantilla 9c_11:
q_0: ───────■────■─────────■────■────■────■────■──
┌───┐ │ ┌─┴─┐┌───┐ │ ┌─┴─┐ │ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9c_12
qiskit.circuit.library.templates.nct.template_nct_9c_12()
Plantilla 9c_12:
q_0: ──■────■────■────■────■────■────■────■────■──
┌─┴─┐ │ ┌─┴─┐┌─┴─┐ │ ┌─┴─┐ │ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9d_1
qiskit.circuit.library.templates.nct.template_nct_9d_1()
Plantilla 9d_1:
┌───┐ ┌───┐ ┌───┐
q_0: ──■───────┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌───┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_1: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9d_2
qiskit.circuit.library.templates.nct.template_nct_9d_2()
Plantilla 9d_2:
q_0: ──■────■────■──────────────■──────────────■──
│ │ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9d_3
qiskit.circuit.library.templates.nct.template_nct_9d_3()
Plantilla 9d_3:
q_0: ──■────■───────────────────■─────────────────
│ │ ┌───┐ ┌─┴─┐ ┌───┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9d_4
qiskit.circuit.library.templates.nct.template_nct_9d_4()
Plantilla 9d_4:
q_0: ───────■─────────■──────────────■────────────
│ ┌───┐ │ ┌───┐ │ ┌───┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9d_5
qiskit.circuit.library.templates.nct.template_nct_9d_5()
Plantilla 9d_5:
q_0: ──■────■─────────■─────────■────■────────────
│ │ ┌───┐ │ ┌─┴─┐ │ ┌───┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9d_6
qiskit.circuit.library.templates.nct.template_nct_9d_6()
Plantilla 9d_6:
q_0: ──■────■──────────────■────■─────────■───────
│ │ ┌───┐ │ ┌─┴─┐ │ ┌───┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9d_7
qiskit.circuit.library.templates.nct.template_nct_9d_7()
Plantilla 9d_7:
q_0: ──■────■─────────■────■────■────■────■───────
│ │ ┌───┐ │ │ ┌─┴─┐ │ │ ┌───┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9d_8
qiskit.circuit.library.templates.nct.template_nct_9d_8()
Plantilla 9d_8:
q_0: ──■────■────■────■─────────■────■─────────■──
│ │ ┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9d_9
qiskit.circuit.library.templates.nct.template_nct_9d_9()
Plantilla 9d_9:
q_0: ──■────■────■─────────■────■─────────■────■──
│ │ ┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
template_nct_9d_10
qiskit.circuit.library.templates.nct.template_nct_9d_10()
Plantilla 9d_10:
q_0: ──■────■────■────■────■────■────■────■────■──
│ │ ┌─┴─┐ │ │ ┌─┴─┐ │ │ ┌─┴─┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
Circuitos de plantillas Clifford
Circuitos plantilla sobre puertas Clifford.
clifford_2_1
qiskit.circuit.library.clifford_2_1()
Clifford plantilla 2_1:
q_0: ─■──■─
│ │
q_1: ─■──■─Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_2_2
qiskit.circuit.library.clifford_2_2()
Plantilla Clifford 2_2:
q_0: ──■────■──
┌─┴─┐┌─┴─┐
q_1: ┤ X ├┤ X ├
└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_2_3
qiskit.circuit.library.clifford_2_3()
Plantilla Clifford 2_3:
┌───┐┌───┐
q_0: ┤ H ├┤ H ├
└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_2_4
qiskit.circuit.library.clifford_2_4()
Plantilla Clifford 2_4:
q_0: ─X──X─
│ │
q_1: ─X──X─Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_3_1
qiskit.circuit.library.clifford_3_1()
Clifford plantilla 3_1:
┌───┐┌───┐┌───┐
q_0: ┤ S ├┤ S ├┤ Z ├
└───┘└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_4_1
qiskit.circuit.library.clifford_4_1()
Clifford plantilla 4_1:
┌───┐
q_0: ──■──┤ X ├──■───X─
┌─┴─┐└─┬─┘┌─┴─┐ │
q_1: ┤ X ├──■──┤ X ├─X─
└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_4_2
qiskit.circuit.library.clifford_4_2()
Plantilla Clifford 4_2:
q_0: ───────■────────■─
┌───┐┌─┴─┐┌───┐ │
q_1: ┤ H ├┤ X ├┤ H ├─■─
└───┘└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_4_3
qiskit.circuit.library.clifford_4_3()
Plantilla Clifford 4_3:
┌───┐ ┌─────┐
q_0: ┤ S ├──■──┤ SDG ├──■──
└───┘┌─┴─┐└─────┘┌─┴─┐
q_1: ─────┤ X ├───────┤ X ├
└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_4_4
qiskit.circuit.library.clifford_4_4()
Plantilla Clifford 4_4:
┌───┐ ┌─────┐
q_0: ┤ S ├─■─┤ SDG ├─■─
└───┘ │ └─────┘ │
q_1: ──────■─────────■─Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_5_1
qiskit.circuit.library.clifford_5_1()
Clifford plantilla 5_1:
q_0: ──■─────────■─────────■── ┌─┴─┐ ┌─┴─┐ │ q_1: ┤ X ├──■──┤ X ├──■────┼── └───┘┌─┴─┐└───┘┌─┴─┐┌─┴─┐ q_2: ─────┤ X ├─────┤ X ├┤ X ├ └───┘ └───┘└───┘
Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_6_1
qiskit.circuit.library.clifford_6_1()
Clifford plantilla 6_1:
┌───┐ ┌───┐┌───┐ q_0: ┤ H ├──■──┤ H ├┤ X ├ ├───┤┌─┴─┐├───┤└─┬─┘ q_1: ┤ H ├┤ X ├┤ H ├──■── └───┘└───┘└───┘
Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_6_2
qiskit.circuit.library.clifford_6_2()
Plantilla Clifford 6_2:
┌───┐ q_0: ┤ S ├──■───────────■───■─ ├───┤┌─┴─┐┌─────┐┌─┴─┐ │ q_1: ┤ S ├┤ X ├┤ SDG ├┤ X ├─■─ └───┘└───┘└─────┘└───┘
Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_6_3
qiskit.circuit.library.clifford_6_3()
Plantilla Clifford 6_3:
┌───┐ ┌───┐
q_0: ─X──■─┤ H ├──■──┤ X ├─────
│ │ └───┘┌─┴─┐└─┬─┘┌───┐
q_1: ─X──■──────┤ X ├──■──┤ H ├
└───┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_6_4
qiskit.circuit.library.clifford_6_4()
Plantilla Clifford 6_4:
global phase: 7π/4
┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐
q: ┤ S ├┤ H ├┤ S ├┤ H ├┤ S ├┤ H ├
└───┘└───┘└───┘└───┘└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_6_5
qiskit.circuit.library.clifford_6_5()
Plantilla Clifford 6_5:
┌───┐
q_0: ─■───■───┤ S ├───■───────
│ ┌─┴─┐┌┴───┴┐┌─┴─┐┌───┐
q_1: ─■─┤ X ├┤ SDG ├┤ X ├┤ S ├
└───┘└─────┘└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_8_1
qiskit.circuit.library.clifford_8_1()
Clifford plantilla 8_1:
┌───┐ ┌───┐ ┌───┐┌─────┐
q_0: ──■───────┤ X ├─┤ S ├─┤ X ├┤ SDG ├
┌─┴─┐┌───┐└─┬─┘┌┴───┴┐└─┬─┘└┬───┬┘
q_1: ┤ X ├┤ H ├──■──┤ SDG ├──■───┤ H ├─
└───┘└───┘ └─────┘ └───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_8_2
qiskit.circuit.library.clifford_8_2()
Plantilla Clifford 8_2:
┌───┐
q_0: ──■─────────■───┤ S ├───■────────────
┌─┴─┐┌───┐┌─┴─┐┌┴───┴┐┌─┴─┐┌───┐┌───┐
q_1: ┤ X ├┤ H ├┤ X ├┤ SDG ├┤ X ├┤ S ├┤ H ├
└───┘└───┘└───┘└─────┘└───┘└───┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
clifford_8_3
qiskit.circuit.library.clifford_8_3()
Plantilla Clifford 8_3:
q_0: ─────────────────■───────────────────────■──
┌───┐┌───┐┌───┐┌─┴─┐┌─────┐┌───┐┌─────┐┌─┴─┐
q_1: ┤ S ├┤ H ├┤ S ├┤ X ├┤ SDG ├┤ H ├┤ SDG ├┤ X ├
└───┘└───┘└───┘└───┘└─────┘└───┘└─────┘└───┘Devuelve
plantilla como un circuito cuántico.
Tipo de retorno
Circuitos de plantilla RZXGate
Circuitos modelo con RZXGate.
rzx_yz
qiskit.circuit.library.rzx_yz(theta=None)
Plantilla basada en RZX para CX - RYGate - CX.
┌────────┐ ┌─────────┐┌─────────┐┌──────────┐
q_0: ──■──┤ RY(-ϴ) ├──■──┤ RX(π/2) ├┤0 ├┤ RX(-π/2) ├
┌─┴─┐└────────┘┌─┴─┐└─────────┘│ RZX(ϴ) │└──────────┘
q_1: ┤ X ├──────────┤ X ├───────────┤1 ├────────────
└───┘ └───┘ └─────────┘Parámetros
theta (ParameterExpression |float | None)
rzx_xz
qiskit.circuit.library.rzx_xz(theta=None)
Plantilla basada en RZX para CX - RXGate - CX.
global phase: π
┌───┐ ┌───┐┌─────────┐┌─────────┐┌─────────┐┌──────────┐»
q_0: ┤ X ├─────────┤ X ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├┤0 ├»
└─┬─┘┌───────┐└─┬─┘└─────────┘└─────────┘└─────────┘│ Rzx(-ϴ) │»
q_1: ──■──┤ Rx(ϴ) ├──■───────────────────────────────────┤1 ├»
└───────┘ └──────────┘»
« ┌─────────┐┌─────────┐┌─────────┐
«q_0: ┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├
« └─────────┘└─────────┘└─────────┘
«q_1: ─────────────────────────────────
«Parámetros
theta (ParameterExpression |float | None)
rzx_cy
qiskit.circuit.library.rzx_cy(theta=None)
Plantilla basada en RZX para CX - RYGate - CX.
┌──────────┐
q_0: ──■─────────────■─────────────────────────────────┤0 ├───────────
┌─┴─┐┌───────┐┌─┴─┐┌────────┐┌──────────┐┌───────┐│ RZX(-ϴ) │┌─────────┐
q_1: ┤ X ├┤ RY(ϴ) ├┤ X ├┤ RY(-ϴ) ├┤ RZ(-π/2) ├┤ RX(ϴ) ├┤1 ├┤ RZ(π/2) ├
└───┘└───────┘└───┘└────────┘└──────────┘└───────┘└──────────┘└─────────┘Parámetros
theta (ParameterExpression |float | None)
rzx_zz1
qiskit.circuit.library.rzx_zz1(theta=None)
Plantilla basada en RZX para CX - RZGate - CX.
global phase: π/2
»
q_0: ──■────────────────────────────────────────────■───────────────────────»
┌─┴─┐┌───────┐┌────┐┌───────┐┌────┐┌────────┐┌─┴─┐┌────────┐┌─────────┐»
q_1: ┤ X ├┤ Rz(ϴ) ├┤ √X ├┤ Rz(π) ├┤ √X ├┤ Rz(3π) ├┤ X ├┤ Rz(-ϴ) ├┤ Rz(π/2) ├»
└───┘└───────┘└────┘└───────┘└────┘└────────┘└───┘└────────┘└─────────┘»
« ┌──────────┐ »
«q_0: ───────────────────────────────┤0 ├──────────────────────»
« ┌─────────┐┌─────────┐┌───────┐│ Rzx(-ϴ) │┌─────────┐┌─────────┐»
«q_1: ┤ Rx(π/2) ├┤ Rz(π/2) ├┤ Rx(ϴ) ├┤1 ├┤ Rz(π/2) ├┤ Rx(π/2) ├»
« └─────────┘└─────────┘└───────┘└──────────┘└─────────┘└─────────┘»
«
«q_0: ───────────
« ┌─────────┐
«q_1: ┤ Rz(π/2) ├
« └─────────┘Parámetros
theta (ParameterExpression |float | None)
rzx_zz2
qiskit.circuit.library.rzx_zz2(theta=None)
Plantilla basada en RZX para CX - PhaseGate - CX.
global phase: π
»
q_0: ──■────────────■─────────────────────────────────────────────────────»
┌─┴─┐┌──────┐┌─┴─┐┌───────┐┌─────────┐┌─────────┐┌─────────┐┌───────┐»
q_1: ┤ X ├┤ P(ϴ) ├┤ X ├┤ P(-ϴ) ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├┤ Rx(ϴ) ├»
└───┘└──────┘└───┘└───────┘└─────────┘└─────────┘└─────────┘└───────┘»
« ┌──────────┐
«q_0: ┤0 ├─────────────────────────────────
« │ Rzx(-ϴ) │┌─────────┐┌─────────┐┌─────────┐
«q_1: ┤1 ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├
« └──────────┘└─────────┘└─────────┘└─────────┘Parámetros
theta (ParameterExpression |float | None)
rzx_zz3
qiskit.circuit.library.rzx_zz3(theta=None)
Plantilla basada en RZX para CX - RZGate - CX.
global phase: π
»
q_0: ──■─────────────■──────────────────────────────────────────────────────»
┌─┴─┐┌───────┐┌─┴─┐┌────────┐┌─────────┐┌─────────┐┌─────────┐┌───────┐»
q_1: ┤ X ├┤ Rz(ϴ) ├┤ X ├┤ Rz(-ϴ) ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├┤ Rx(ϴ) ├»
└───┘└───────┘└───┘└────────┘└─────────┘└─────────┘└─────────┘└───────┘»
« ┌──────────┐
«q_0: ┤0 ├─────────────────────────────────
« │ Rzx(-ϴ) │┌─────────┐┌─────────┐┌─────────┐
«q_1: ┤1 ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├
« └──────────┘└─────────┘└─────────┘└─────────┘Parámetros
theta (ParameterExpression |float | None)