QuantumCircuit clase

Los datos del circuito (instrucciones y contexto).

Ejemplo

from qiskit import QuantumCircuit
 
qc = QuantumCircuit(2, 2)
qc.measure([0], [1])
print(qc.data)

[CircuitInstruction(operation=Instruction(name='measure', num_qubits=1,
num_clbits=1, params=[]), qubits=(Qubit(QuantumRegister(2, 'q'), 0),),
clbits=(Clbit(ClassicalRegister(2, 'c'), 1),))]

Devuelve

Un objeto en forma de lista que contiene las CircuitInstruction instancias del circuito.

La fase global del alcance del circuito actual en radianes.

Ejemplo

from qiskit import QuantumCircuit
 
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
print(circuit.global_phase)

0.0

from numpy import pi
 
circuit.global_phase = pi/4
print(circuit.global_phase)

0.7853981633974483

Tipo: str

Un nombre legible para el circuito.

Ejemplo

from qiskit import QuantumCircuit
 
qc = QuantumCircuit(2, 2, name="my_circuit")
print(qc.name)

my_circuit

Diccionario arbitrario de metadatos definido por el usuario para el circuito.

Qiskit no examinará el contenido de este mapeo, pero lo pasará a través del transpilador y lo volverá a adjuntar a la salida, por lo que puede realizar un seguimiento de sus propios metadatos.

Ejemplo

from qiskit import QuantumCircuit
 
qc = QuantumCircuit(2, 2, metadata={'experiment_type': 'Bell state experiment'})
 
print(qc.metadata)

{'experiment_type': 'Bell state experiment'}

Una lista de Qubits en el orden en que fueron añadidos. No debes mutar esto.

Una lista de Clbits en el orden en que fueron añadidos. No debes mutar esto.

Una lista de Qubits en el orden en que fueron añadidos. No debes mutar esto.

Una lista de AncillaQubits en el orden en que fueron añadidos. No debes mutar esto.

Una lista de Clbits en el orden en que fueron añadidos. No debes mutar esto.

Ejemplo

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
 
qr1 = QuantumRegister(2)
qr2 = QuantumRegister(1)
cr1 = ClassicalRegister(2)
cr2 = ClassicalRegister(1)
qc = QuantumCircuit(qr1, qr2, cr1, cr2)
 
print("List the qubits in this circuit:", qc.qubits)
print("List the classical bits in this circuit:", qc.clbits)

List the qubits in this circuit: [Qubit(QuantumRegister(2, 'q0'), 0),
Qubit(QuantumRegister(2, 'q0'), 1), Qubit(QuantumRegister(1, 'q1'), 0)]
List the classical bits in this circuit: [Clbit(ClassicalRegister(2, 'c0'), 0),
Clbit(ClassicalRegister(2, 'c0'), 1), Clbit(ClassicalRegister(1, 'c1'), 0)]

Los parámetros definidos en el circuito.

Este atributo devuelve los Parameter objetos del circuito ordenados alfabéticamente. Tenga en cuenta que los parámetros instanciados con un ParameterVector siguen estando ordenados numéricamente.

Ejemplos

El siguiente fragmento muestra que el orden de inserción de los parámetros no importa.

>>> from qiskit.circuit import QuantumCircuit, Parameter
>>> a, b, elephant = Parameter("a"), Parameter("b"), Parameter("elephant")
>>> circuit = QuantumCircuit(1)
>>> circuit.rx(b, 0)
>>> circuit.rz(elephant, 0)
>>> circuit.ry(a, 0)
>>> circuit.parameters  # sorted alphabetically!
ParameterView([Parameter(a), Parameter(b), Parameter(elephant)])

Tenga en cuenta que la ordenación alfabética puede resultar poco intuitiva cuando se trata de números. El "10" literal va antes que el "2" en estricta ordenación alfabética.

>>> from qiskit.circuit import QuantumCircuit, Parameter
>>> angles = [Parameter("angle_1"), Parameter("angle_2"), Parameter("angle_10")]
>>> circuit = QuantumCircuit(1)
>>> circuit.u(*angles, 0)
>>> circuit.draw()
   ┌─────────────────────────────┐
q: ┤ U(angle_1,angle_2,angle_10) ├
   └─────────────────────────────┘
>>> circuit.parameters
ParameterView([Parameter(angle_1), Parameter(angle_10), Parameter(angle_2)])

Para respetar la ordenación numérica, se puede utilizar un ParameterVector puede utilizarse.

>>> from qiskit.circuit import QuantumCircuit, Parameter, ParameterVector
>>> x = ParameterVector("x", 12)
>>> circuit = QuantumCircuit(1)
>>> for x_i in x:
...     circuit.rx(x_i, 0)
>>> circuit.parameters
ParameterView([
    ParameterVectorElement(x[0]), ParameterVectorElement(x[1]),
    ParameterVectorElement(x[2]), ParameterVectorElement(x[3]),
    ..., ParameterVectorElement(x[11])
])

Devuelve

Los Parameter en el circuito.

Devuelve cualquier información de diseño asociada sobre el circuito.

Este atributo contiene un TranspileLayout opcional. Suele establecerse en la salida de transpile() o PassManager.run() para retener información sobre las permutaciones causadas en el circuito de entrada por la transpilación.

Hay dos tipos de permutaciones causadas por la función transpile() una disposición inicial que permuta los qubits basándose en los qubits físicos seleccionados en la función Targety una disposición final, que es una permutación de salida causada por SwapGates insertados durante el enrutamiento.

Ejemplo

from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.transpiler import generate_preset_pass_manager
 
# Create circuit to test transpiler on
qc = QuantumCircuit(3, 3)
qc.h(0)
qc.cx(0, 1)
qc.swap(1, 2)
qc.cx(0, 1)
 
# Add measurements to the circuit
qc.measure([0, 1, 2], [0, 1, 2])
 
# Specify the QPU to target
backend = GenericBackendV2(3)
 
# Transpile the circuit
pass_manager = generate_preset_pass_manager(
optimization_level=1, backend=backend
)
transpiled = pass_manager.run(qc)
 
# Print the layout after transpilation
print(transpiled.layout.routing_permutation())

[0, 1, 2]

La duración total del circuito, fijada por un pase del transpilador de programación. Su unidad se especifica mediante unit.

La unidad que duration se especifica en.

Devuelve una lista con las horas de inicio de las operaciones.

Este atributo se activa una vez que uno de los pases de análisis de programación se ejecuta en el circuito cuántico.

Ejemplo

from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.transpiler import generate_preset_pass_manager
 
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
 
# Print the original circuit
print("Original circuit:")
print(qc)
 
# Transpile the circuit with a specific basis gates list and print the resulting circuit
backend = GenericBackendV2(2, basis_gates=['u1', 'u2', 'u3', 'cx'])
pm = generate_preset_pass_manager(
    optimization_level=1, backend=backend, scheduling_method="alap"
)
transpiled_qc = pm.run(qc)
print("Transpiled circuit with basis gates ['u1', 'u2', 'u3', 'cx']:")
print(transpiled_qc)
 
# Print the start times of each instruction in the transpiled circuit
print("Start times of instructions in the transpiled circuit:")
for instruction, start_time in zip(transpiled_qc.data, transpiled_qc.op_start_times):
    print(f"{instruction.operation.name}: {start_time}")

Original circuit:
        ┌───┐      ░ ┌─┐
q_0: ┤ H ├──■───░─┤M├───
        └───┘┌─┴─┐ ░ └╥┘┌─┐
q_1: ─────┤ X ├─░──╫─┤M├
            └───┘ ░  ║ └╥┘
meas: 2/══════════════╩══╩═
                    0  1

Transpiled circuit with basis gates ['u1', 'u2', 'u3', 'cx']:
            ┌─────────┐          ░ ┌─────────────────┐┌─┐
q_0 -> 0 ───┤ U2(0,π) ├──────■───░─┤ Delay(1255[dt]) ├┤M├
        ┌──┴─────────┴───┐┌─┴─┐ ░ └───────┬─┬───────┘└╥┘
q_1 -> 1 ┤ Delay(196[dt]) ├┤ X ├─░─────────┤M├─────────╫─
        └────────────────┘└───┘ ░         └╥┘         ║
meas: 2/═══════════════════════════════════╩══════════╩═
                                            1          0

Start times of instructions in the transpiled circuit:
u2: 0
delay: 0
cx: 196
barrier: 2098
delay: 2098
measure: 3353
measure: 2098

Devuelve

Lista de enteros que representan las horas estimadas de inicio de las instrucciones. El índice corresponde al índice de instrucción en QuantumCircuit.data.

Eleva

AttributeError - Cuando el circuito no está programado.

Devuelve el número de qubits ancilla.

Ejemplo

from qiskit import QuantumCircuit, QuantumRegister, AncillaRegister
 
# Create a 2-qubit quantum circuit
reg = QuantumRegister(2)
qc = QuantumCircuit(reg)
 
# Create an ancilla register with 1 qubit
anc = AncillaRegister(1)
qc.add_register(anc)  # Add the ancilla register to the circuit
 
print("Number of ancilla qubits:", qc.num_ancillas)

Number of ancilla qubits: 1

Devuelve el número de bits clásicos.

Ejemplo

from qiskit import QuantumCircuit
 
# Create a new circuit with two qubits and one classical bit
qc = QuantumCircuit(2, 1)
print("Number of classical bits:", qc.num_clbits)

Number of classical bits: 1

El número de variables clásicas en tiempo real en el circuito marcadas como capturadas desde un ámbito envolvente.

Es la longitud del iter_captured_vars() iterable. Si es distinto de cero, num_input_vars debe ser cero.

El número de tramos en el circuito marcados como capturados desde un ámbito envolvente.

Es la longitud del iter_captured_stretches() iterable. Si es distinto de cero, num_input_vars debe ser cero.

El número de variables clásicas en tiempo real en el circuito que son declaradas por este ámbito de circuito, excluyendo entradas o capturas.

Es la longitud del iter_declared_vars() iterable.

El número de tramos en el circuito que son declarados por este ámbito de circuito, excluyendo las capturas.

Es la longitud del iter_declared_stretches() iterable.

Número de variables clásicas en tiempo real del circuito marcadas como entradas del circuito.

Es la longitud del iter_input_vars() iterable. Si es distinto de cero, num_captured_vars debe ser cero.

El número de variables clásicas en tiempo real y tramos en el circuito.

Esto es igual a num_vars() + num_stretches().

Número de objetos parámetro en el circuito.

Devuelve el número de qubits.

El número de tramos del circuito.

Es la longitud del iter_stretches() iterable.

El número de variables clásicas en tiempo real del circuito.

Es la longitud del iter_vars() iterable.

__init__(*regs, name=None, global_phase=0, metadata=None, inputs=(), captures=(), declarations=())

Constructor por defecto de QuantumCircuit.

Parámetros

• regs (Register |int |Sequence[Bit]) –

  Los registros que se incluirán en el circuito.

  • Si una lista de Register objetos, representa el QuantumRegister y/o ClassicalRegister objetos a incluir en el circuito.

    Por ejemplo:

    • QuantumCircuit(QuantumRegister(4))
    • QuantumCircuit(QuantumRegister(4), ClassicalRegister(3))
    • QuantumCircuit(QuantumRegister(4, 'qr0'), QuantumRegister(2, 'qr1'))

  • Si es una lista de int, la cantidad de qubits y/o bits clásicos a incluir en el circuito. Puede ser un único int para sólo el número de bits cuánticos, o 2 ints para el número de bits cuánticos y bits clásicos, respectivamente.

    Por ejemplo:

    • QuantumCircuit(4) # A QuantumCircuit with 4 qubits
    • QuantumCircuit(4, 3) # A QuantumCircuit with 4 qubits and 3 classical bits

  • Si una lista de listas python contiene Bit una colección de objetos Bit s que se añadirán al circuito.

• name (str | None) – el nombre del circuito cuántico. Si no se establece, se asignará una cadena generada automáticamente.

• global_phase (ParameterExpression |float) – La fase global del circuito en radianes.

• metadata (dict | None) – Metadatos de valor de clave arbitraria para asociar con el circuito. Esto se almacena como datos de forma libre en un dict en el atributo metadata atributo. No se utilizará directamente en el circuito.

• inputs (Iterable[Var]) – cualquier variable que se deba declarar como input variable de tiempo de ejecución para este circuito. Estos ya deberían ser nodos expr.Var existentes que usted construye desde otro lugar; si necesita crear también las entradas, utilice QuantumCircuit.add_input(). Las variables proporcionadas en este argumento se pasarán directamente a add_input(). Un circuito no puede tener tanto inputs como captures.

• captures (Iterable[Var |Stretch]) – cualquier variable que este ámbito de circuito deba capturar de un ámbito contenedor. Las variables que se indican aquí se pasarán directamente a add_capture(). Un circuito no puede tener tanto inputs como captures.

• declarations (Mapping[Var, Expr] | Iterable[Tuple[Var, Expr]]) –

  cualquier variable que este circuito deba declarar e inicializar inmediatamente. Puede ordenar esta entrada de modo que las declaraciones posteriores dependan de las anteriores (incluidas las entradas o capturas). Si necesita depender de valores que se calcularán posteriormente en tiempo de ejecución, utilice add_var() en un punto apropiado de la ejecución del circuito.

  Este argumento está pensado para la inicialización conveniente del circuito cuando ya se tiene un conjunto de variables creadas. Las variables utilizadas aquí se pasarán directamente a add_var()que puede utilizar directamente si es la primera vez que crea la variable.

Eleva

• CircuitError - si el nombre del circuito no es válido.
• CircuitError - si se indican inputs y captures .

copy(name=None)

Copia el circuito.

Parámetros

name (str) – nombre que se dará al circuito copiado. Si es Ninguno, el nombre permanece igual.

Devuelve

una copia profunda del circuito actual, con el nombre especificado

Tipo de retorno

QuantumCircuit

copy_empty_like(name=None, *, vars_mode='alike')

Devuelve una copia de self con la misma estructura pero vacía.

Esa estructura incluye:

• nombre y otros metadatos
• fase global
• todos los qubits y clbits, incluidos los registros
• las variables de tiempo real definidas en el circuito, tratadas según el argumento de la palabra clave vars .

Parámetros

• name (str | None) – Nombre del circuito copiado. Si es Ninguno, el nombre permanece igual.

• vars_mode (Literal['alike', 'captures', 'drop']) –

  El modo para manejar las variables en tiempo real.

  igual

  Las variables del circuito de salida tendrán la misma semántica de declaración que en el circuito original. Por ejemplo, las variables input en la fuente serán variables input en el circuito de salida. Tenga en cuenta que esto provoca que las variables locales no se inicialicen, porque los almacenes no se copian. Esto puede dejar el circuito en un estado potencialmente peligroso para los usuarios si no vuelven a añadir los almacenes inicializadores.

  capturas

  Todas las variables se convertirán en variables capturadas. Esto es útil cuando se está construyendo una nueva capa para un circuito existente que querrá compose() en la base, ya que compose() puede incluir capturas en el circuito base (pero no otras variables).

  descartar

  El circuito de salida no tendrá variables definidas.

Devuelve

Una copia vacía de sí mismo.

Tipo de retorno

QuantumCircuit

static from_instructions(instructions, *, qubits=(), clbits=(), name=None, global_phase=0, metadata=None)

Construye un circuito a partir de un iterable de CircuitInstructions.

Parámetros

• instructions (Iterable[CircuitInstruction |tuple[qiskit.circuit.Instruction] | tuple[qiskit.circuit.Instruction, Iterable[Qubit]] | tuple[qiskit.circuit.Instruction, Iterable[Qubit], Iterable[Clbit]]]) – Las instrucciones para añadir al circuito.
• qubits (Iterable[Qubit]) – Cualquier qubits para añadir al circuito. Este argumento puede utilizarse, por ejemplo, para imponer un orden determinado de los qubits.
• clbits (Iterable[Clbit]) – Cualquier bit clásico para añadir al circuito. Este argumento puede utilizarse, por ejemplo, para imponer un orden determinado de los bits clásicos.
• name (str | None) – El nombre del circuito.
• global_phase (ParameterValueType) – La fase global del circuito en radianes.
• metadata (dict | None) – Metadatos de valor de clave arbitraria para asociar con el circuito.

Devuelve

El circuito cuántico.

Tipo de retorno

QuantumCircuit

static from_qasm_file(path)

Leer un programa OpenQASM 2.0 de un archivo y convertirlo en una instancia de QuantumCircuit.

Parámetros

path (str) – Ruta de acceso al archivo de un programa OpenQASM 2

Devuelve

El objeto QuantumCircuit para la entrada OpenQASM 2.

Tipo de retorno

QuantumCircuit

static from_qasm_str(qasm_str)

Convierte una cadena que contiene un programa OpenQASM 2.0 en un programa QuantumCircuit.

Parámetros

qasm_str (str) – Una cadena que contiene un programa OpenQASM 2.0.

Devuelve

El objeto QuantumCircuit para la entrada OpenQASM 2

Tipo de retorno

QuantumCircuit

add_bits(bits)

Añade Bits al circuito.

Parámetros

bits (Iterable[Bit]) –

Tipo de retorno

Ninguna

add_register(*regs)

Añade registros.

Parámetros

regs (Register |int |Sequence[Bit]) –

Tipo de retorno

Ninguna

add_var(name_or_var, /, initial)

Añade a este circuito una variable clásica con almacenamiento automático y alcance.

La variable se considera "declarada" al principio del circuito, pero sólo se inicializa en el punto del circuito en que se llama a este método, por lo que puede depender de variables definidas antes que ella.

Parámetros

• name_or_var (str |Var) – una cadena con el nombre de la variable o una instancia existente de Var para reutilizar. Las variables no pueden ocultar nombres que ya están en uso dentro del circuito.

• initial (Any) –

  el valor con el que inicializar esta variable. Si el primer argumento se ha dado como nombre de cadena, el tipo de la variable resultante se deduce de la expresión inicial; para controlar esto de forma más manual, utilice Var.new() para construir manualmente una nueva variable con el tipo deseado, o utilice expr.cast() para convertir el inicializador al tipo deseado.

  Debe ser un nodo Expr o un valor que se puede elevar a uno mediante expr.lift.

Devuelve

La variable creada. Si se ha dado una Var se devolverá exactamente el mismo objeto.

Eleva

CircuitError - si la variable no puede crearse debido a la sombra de un identificador existente.

Tipo de retorno

Var

Ejemplos

Define una nueva variable con un nombre y una expresión inicializadora:

from qiskit.circuit import QuantumCircuit
 
qc = QuantumCircuit(2)
my_var = qc.add_var("my_var", False)

Reutilizar una variable que puede haber sido tomada de un circuito relacionado, o construida manualmente de otro modo, e inicializarla con alguna expresión más complicada:

from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.classical import expr, types
 
my_var = expr.Var.new("my_var", types.Uint(8))
 
cr1 = ClassicalRegister(8, "cr1")
cr2 = ClassicalRegister(8, "cr2")
qc = QuantumCircuit(QuantumRegister(8), cr1, cr2)
 
# Get some measurement results into each register.
qc.h(0)
for i in range(1, 8):
    qc.cx(0, i)
qc.measure(range(8), cr1)
 
qc.reset(range(8))
qc.h(0)
for i in range(1, 8):
    qc.cx(0, i)
qc.measure(range(8), cr2)
 
# Now when we add the variable, it is initialized using the real-time state of the
# two classical registers we measured into above.
qc.add_var(my_var, expr.bit_and(cr1, cr2))

add_input(name_or_var: str, type_: Type, /) → Var

add_input(name_or_var: Var, type_: None = None, /) → Var

Registra una variable como entrada al circuito.

Parámetros

• nombre_o_var - ya sea un nombre de cadena, o una existente Var existente a utilizar como variable de entrada.
• tipo - si el nombre se da como una cadena, entonces este debe ser un Type para la variable. Si la variable se da como un Varno debe indicarse, sino que se leerá del propio objeto.

Devuelve

la variable creada, o la misma variable que se pasó.

Eleva

CircuitError - si la variable no puede crearse debido a la sombra de una variable existente.

add_stretch(name_or_stretch)

Declara un nuevo tramo para este circuito.

Parámetros

name_or_stretch (str |Stretch) – una cadena con el nombre del stretch o una instancia existente de Stretch para reutilizar. Los estiramientos no pueden imitar nombres que ya están en uso dentro del circuito.

Devuelve

El tramo creado. Si se ha dado una Stretch se devolverá exactamente el mismo objeto.

Eleva

CircuitError - si el tramo no puede crearse debido a la sombra de un identificador existente.

Tipo de retorno

Estiramiento

Ejemplos

Definir y utilizar un nuevo tramo dado sólo un nombre:

from qiskit.circuit import QuantumCircuit, Duration
from qiskit.circuit.classical import expr
 
qc = QuantumCircuit(2)
my_stretch = qc.add_stretch("my_stretch")
 
qc.delay(expr.add(Duration.dt(200), my_stretch), 1)

add_uninitialized_var(var, /)

Añade una variable sin inicializador.

En la mayoría de los casos, debe utilizar add_var() para inicializar la variable. Para utilizar esta función, debe tener ya una instancia Var ya que el uso de esta función sólo tiene sentido en contextos de copia.

Parámetros

var (Var) – la variable a añadir.

add_capture(var: Var)

add_capture(stretch: Stretch)

Añade un identificador al circuito que debe capturar de un ámbito en el que estará contenido.

Este método requiere un Var o Stretch para asegurar que tiene un "handle" a un identificador, porque necesitará declarar el mismo identificador usando el mismo objeto en el circuito externo.

Se trata de un método de bajo nivel, que sólo es realmente útil si está construyendo manualmente operaciones de flujo de control. Normalmente no necesitará llamar a este método, asumiendo que está utilizando la interfaz del constructor para ámbitos de flujo de control (with context-manager statements for if_test() y otras construcciones de ámbito). La interfaz del constructor hará automáticamente los cierres de los ámbitos internos en su nombre capturando cualquier identificador que se utilice dentro de ellos.

Parámetros

var (Union[expr.Var, expr.Stretch]) – la variable o tramo a capturar desde un ámbito envolvente.

Eleva

CircuitError - si el identificador no puede crearse debido a la sombra de un identificador existente.

find_bit(bit)

Encontrar lugares en el circuito que puedan utilizarse para referenciar un determinado Bit.

En particular, esta función puede encontrar el índice entero de un qubit, que corresponde a su índice hardware para un circuito transpilado.

Parámetros

bit (Bit) – El bit a localizar.

Devuelve

Una 2-tupla. El primer elemento (index) contiene el índice en el que se encuentra Bit (en qubits, clbitsen función de su tipo). El segundo elemento (registers) es una lista de pares (register, index) con una entrada para cada Register del circuito que contiene el Bit (y el índice en el Register en el que puede encontrarse).

Tipo de retorno

namedtuple (int, Lista[Tuple (Registro, int )])

Eleva

• CircuitError - Si el Bit es de tipo desconocido.
• CircuitError - Si el Bit en el circuito.

Ejemplos

Recorre en bucle un circuito, obteniendo los índices qubit y clbit de cada operación:

from qiskit.circuit import QuantumCircuit, Qubit
 
qc = QuantumCircuit(3, 3)
qc.h(0)
qc.cx(0, 1)
qc.cx(1, 2)
qc.measure([0, 1, 2], [0, 1, 2])
 
# The `.qubits` and `.clbits` fields are not integers.
assert isinstance(qc.data[0].qubits[0], Qubit)
# ... but we can use `find_bit` to retrieve them.
assert qc.find_bit(qc.data[0].qubits[0]).index == 0
 
simple = [
    (
        instruction.operation.name,
        [qc.find_bit(bit).index for bit in instruction.qubits],
        [qc.find_bit(bit).index for bit in instruction.clbits],
    )
    for instruction in qc.data
]

has_register(register)

Comprueba si este circuito tiene el registro r.

Parámetros

register (Register) – un registro cuántico o clásico.

Devuelve

Verdadero si el registro está contenido en este circuito.

Tipo de retorno

bool

assign_parameters(parameters: Mapping[Parameter, ParameterExpression | float] | Iterable[ParameterExpression | float], inplace: Literal[False] = False, *, flat_input: bool = False, strict: bool = True) → QuantumCircuit

assign_parameters(parameters: Mapping[Parameter, ParameterExpression | float] | Iterable[ParameterExpression | float], inplace: Literal[True] = False, *, flat_input: bool = False, strict: bool = True) → None

Asignar parámetros a nuevos parámetros o valores.

Si parameters se pasa como diccionario, las claves deben ser Parameter instancias en el circuito actual. Los valores del diccionario pueden ser valores numéricos o nuevos objetos de parámetro.

Si parameters se pasa como lista o matriz, los elementos se asignan a los parámetros actuales en el orden de parameters que se ordena alfabéticamente (respetando el orden en los objetos ParameterVector objetos).

Los valores pueden asignarse al objeto circuito actual o a una copia del mismo.

Parámetros

• parameters - Un diccionario o iterable que especifica los nuevos valores de los parámetros.
• inplace - Si es False, se devuelve una copia del circuito con los parámetros vinculados. Si es True, se modifica el propio circuito.
• flat_input - Si True y parameters es un tipo de mapeo, se asume que es exactamente un mapeo de {parameter: value}. Por defecto (False), el mapeo también puede contener ParameterVector que apunten a una secuencia de valores correspondiente, y éstas se desenrollarán durante el mapeo, o claves de cadena, que se convertirán en Parameter mediante get_parameter().
• strict - Si False, se ignorarán todos los parámetros indicados en la asignación que no se utilicen en el circuito. Si True (por defecto), se producirá un error indicando un error lógico.

Eleva

• CircuitError - Si parameters es un dict y contiene parámetros no presentes en el circuito.
• ValueError - Si los parámetros son una lista/array y la longitud no coincide con el número de parámetros libres en el circuito.

Devuelve

Una copia del circuito con parámetros vinculados si inplace es False, en caso contrario None.

Ejemplos

Cree un circuito parametrizado y asigne los parámetros in situ.

from qiskit.circuit import QuantumCircuit, Parameter
 
circuit = QuantumCircuit(2)
params = [Parameter('A'), Parameter('B'), Parameter('C')]
circuit.ry(params[0], 0)
circuit.crx(params[1], 0, 1)
circuit.draw('mpl')
circuit.assign_parameters({params[0]: params[2]}, inplace=True)
circuit.draw('mpl')

Une los valores fuera de lugar por lista y obtén una copia del circuito original.

from qiskit.circuit import QuantumCircuit, ParameterVector
 
circuit = QuantumCircuit(2)
params = ParameterVector('P', 2)
circuit.ry(params[0], 0)
circuit.crx(params[1], 0, 1)
 
bound_circuit = circuit.assign_parameters([1, 2])
bound_circuit.draw('mpl')
 
circuit.draw('mpl')

has_parameter(name_or_param, /)

Comprueba si existe un objeto parámetro en este circuito.

Parámetros

name_or_param (str |Parameter) – el parámetro, o nombre de un parámetro a comprobar. Si se trata de un Parameter nodo, el parámetro debe ser exactamente el dado para que esta función devuelva True.

Devuelve

si un parámetro de coincidencia es asignable en este circuito.

Tipo de retorno

bool

get_parameter(name: str, default: T) → Parameter | T

get_parameter(name: str, default: ellipsis = Ellipsis) → Parameter

Recupera un parámetro en tiempo de compilación accesible en este ámbito de circuito por su nombre.

Parámetros

• name - el nombre del parámetro a recuperar.
• default - si se da, este valor será devuelto si el parámetro no está presente. Si no se indica, se genera un KeyError en su lugar.

Devuelve

El parámetro correspondiente.

Eleva

KeyError - si no se indica ningún valor por defecto, pero el parámetro no existe en el circuito.

Ejemplos

Recuperar un parámetro de un circuito por su nombre:

from qiskit.circuit import QuantumCircuit, Parameter
 
my_param = Parameter("my_param")
 
# Create a parametrized circuit.
qc = QuantumCircuit(1)
qc.rx(my_param, 0)
 
# We can use 'my_param' as a parameter, but let's say we've lost the Python object
# and need to retrieve it.
my_param_again = qc.get_parameter("my_param")
 
assert my_param is my_param_again

Obtiene una variable de un circuito por su nombre, devolviendo algún valor por defecto si no está presente:

assert qc.get_parameter("my_param", None) is my_param
assert qc.get_parameter("unknown_param", None) is None

get_var(name: str, default: T) → Var | T

get_var(name: str, default: ellipsis = Ellipsis) → Var

Recupera una variable accesible en este ámbito de circuito por su nombre.

Parámetros

• name - el nombre de la variable a recuperar.
• default - si se da, se devolverá este valor si la variable no está presente. Si no se indica, se genera un KeyError en su lugar.

Devuelve

La variable correspondiente.

Eleva

KeyError - si no se indica ningún valor por defecto, pero la variable no existe.

Ejemplos

Recuperar una variable por su nombre de un circuito:

from qiskit.circuit import QuantumCircuit
 
# Create a circuit and create a variable in it.
qc = QuantumCircuit()
my_var = qc.add_var("my_var", False)
 
# We can use 'my_var' as a variable, but let's say we've lost the Python object and
# need to retrieve it.
my_var_again = qc.get_var("my_var")
 
assert my_var is my_var_again

Obtiene una variable de un circuito por su nombre, devolviendo algún valor por defecto si no está presente:

assert qc.get_var("my_var", None) is my_var
assert qc.get_var("unknown_variable", None) is None

get_stretch(name: str, default: T) → Stretch | T

get_stretch(name: str, default: ellipsis = Ellipsis) → Stretch

Recupera un tramo accesible en este ámbito de circuito por su nombre.

Parámetros

• name - el nombre del tramo a recuperar.
• default - si se da, se devolverá este valor si la variable no está presente. Si no se indica, se genera un KeyError en su lugar.

Devuelve

El tramo correspondiente.

Eleva

KeyError - si no se indica ningún valor por defecto, pero la variable no existe.

Ejemplos

Recuperar un tramo por su nombre de un circuito:

from qiskit.circuit import QuantumCircuit
 
# Create a circuit and create a variable in it.
qc = QuantumCircuit()
my_stretch = qc.add_stretch("my_stretch")
 
# We can use 'my_stretch' as a variable, but let's say we've lost the Python object and
# need to retrieve it.
my_stretch_again = qc.get_stretch("my_stretch")
 
assert my_stretch is my_stretch_again

Obtiene una variable de un circuito por su nombre, devolviendo algún valor por defecto si no está presente:

assert qc.get_stretch("my_stretch", None) is my_stretch
assert qc.get_stretch("unknown_stretch", None) is None

get_identifier(name: str, default: T) → Var | Stretch | T

get_identifier(name: str, default: ellipsis = Ellipsis) → Var | Stretch

Recupera un identificador accesible en este ámbito de circuito por su nombre.

Esto incluye actualmente tanto las variables clásicas en tiempo real como los tramos.

Parámetros

• name - el nombre del identificador a recuperar.
• default - si se da, se devolverá este valor si la variable no está presente. Si no se indica, se genera un KeyError en su lugar.

Devuelve

La variable correspondiente.

Eleva

KeyError - si no se indica ningún valor por defecto, pero el identificador no existe.

has_var(name_or_var, /)

Comprueba si una variable es accesible en este ámbito.

Parámetros

name_or_var (str |Var) – la variable o el nombre de una variable que se va a comprobar. Si se trata de un expr.Var nodo, la variable debe ser exactamente la indicada para que esta función devuelva True.

Devuelve

si una variable coincidente es accesible.

Tipo de retorno

bool

has_stretch(name_or_stretch, /)

Comprueba si un tramo es accesible en este ámbito.

Parámetros

name_or_stretch (str |Stretch) – el tramo, o nombre de un tramo que se debe comprobar. Si se trata de un expr.Stretch nodo, el estiramiento debe ser exactamente el dado para que esta función devuelva True.

Devuelve

si un tramo coincidente es accesible.

Tipo de retorno

bool

has_identifier(name_or_ident, /)

Comprueba si un identificador es accesible en este ámbito.

Parámetros

name_or_ident (str |Var |Stretch) – la instancia o el nombre del identificador que se va a comprobar. Si se trata de un nodo expr.Varexpr.Stretch o, la instancia coincidente debe ser exactamente la dada para que esta función devuelva True.

Devuelve

si un identificador coincidente es accesible.

Tipo de retorno

bool

iter_vars()

Obtiene un iterable sobre todas las variables clásicas en tiempo real en el ámbito de este circuito.

Este método iterará sobre todas las variables del ámbito. Para iteradores más precisos, véase iter_declared_vars(), iter_input_vars() y iter_captured_vars().

Tipo de retorno

Iterable[* Var* ]

iter_stretches()

Obtener un iterable sobre todos los tramos en el ámbito dentro de este circuito.

Este método iterará sobre todos los tramos del ámbito. Para iteradores más precisos, véase iter_declared_stretches() y iter_captured_stretches().

Tipo de retorno

Iterable[* Stretch* ]

iter_input_vars()

Obtiene un iterable sobre todas las variables clásicas en tiempo real que se declaran como entradas de este ámbito de circuito. Esto excluye las variables declaradas localmente (véase iter_declared_vars()) y las variables capturadas (véase iter_captured_vars()).

Tipo de retorno

Iterable[* Var* ]

iter_captured_vars()

Obtiene un iterable sobre todas las variables clásicas en tiempo real que son capturadas por este ámbito de circuito desde un ámbito contenedor. Esto excluye las variables de entrada (véase iter_input_vars()) y las variables declaradas localmente (véase iter_declared_vars()).

Tipo de retorno

Iterable[* Var* ]

iter_captured_stretches()

Obtiene un iterable sobre tramos que son capturados por este ámbito de circuito desde un ámbito contenedor. Esto excluye los tramos declarados localmente (véase iter_declared_stretches()).

Tipo de retorno

Iterable[* Stretch* ]

iter_declared_vars()

Obtiene un iterable sobre todas las variables clásicas en tiempo real que se declaran con duración de almacenamiento automático en este ámbito. Esto excluye las variables de entrada (véase iter_input_vars()) y las variables capturadas (véase iter_captured_vars()).

Tipo de retorno

Iterable[* Var* ]

iter_declared_stretches()

Obtiene un iterable sobre todos los tramos declarados en este ámbito. Esto excluye los tramos capturados (véase iter_captured_stretches()).

Tipo de retorno

Iterable[* Stretch* ]

append(instruction, qargs=None, cargs=None, *, copy=True)

Añadir una o más instrucciones al final del circuito, modificando el circuito en su lugar.

Las direcciones qargs y cargs se ampliarán y difundirán de acuerdo con las normas del dado Instructiony cualquier especificador noBit (como índices enteros) se resolverán en las instancias pertinentes.

Si se proporciona un objeto CircuitInstruction se desenvolverá, se verificará en el contexto de este circuito y se añadirá un nuevo objeto al circuito. En este caso, no puede pasar qargs o cargs por separado.

Parámetros

• instruction (Operation |CircuitInstruction) –Instruction a añadir, o un CircuitInstruction con todo su contexto.
• qargs (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]] | None) – especificadores de los Qubits a los que adjuntar la instrucción.
• cargs (Sequence[Clbit |ClassicalRegister |int |slice |Sequence[Clbit |int]] | None) – especificadores de los Clbits a los que adjuntar la instrucción.
• copy (bool) – si True (por defecto), entonces el instruction entrante es copiado antes de añadirlo al circuito si contiene parámetros simbólicos, por lo que puede ser mutado de forma segura sin afectar a otros circuitos en los que pueda estar la misma instrucción. Si está seguro de que esta instrucción no estará en otros circuitos, puede configurar este False para un pequeño aumento de velocidad.

Devuelve

a los CircuitInstructions que se han añadido realmente al circuito.

Tipo de retorno

qiskit.circuit.InstructionSet

Eleva

CircuitError - si la operación pasada no es una instancia de Instruction .

_append(instruction: CircuitInstruction, *, _standard_gate: bool) → CircuitInstruction

_append(instruction: Operation, qargs: Sequence[Qubit], cargs: Sequence[Clbit]) → Operation

Añade una instrucción al final del circuito, modificando el circuito en su lugar.

Parámetros

• instrucción -

  Una descripción completa y bien formada CircuitInstruction de la operación y su contexto a añadir.

  En la forma de compatibilidad heredada, puede ser un simple Operationen cuyo caso qargs y cargs deben indicarse explícitamente.

• qargs - Argumento legado para qubits a los que adjuntar el bare Operation a. Se ignora si el primer argumento está en la forma preferente CircuitInstruction preferente.

• cargs - Argumento de legado para clbits para adjuntar el bare Operation a. Se ignora si el primer argumento está en la forma preferente CircuitInstruction preferente.

Devuelve

un manejador de la instrucción que se acaba de añadir.

Tipo de retorno

CircuitInstruction

compose(other: QuantumCircuit | Instruction, qubits: Qubit | QuantumRegister | int | slice | Sequence[Qubit | int] | Sequence[Qubit | QuantumRegister | int | slice | Sequence[Qubit | int]] | None = None, clbits: Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int] | Sequence[Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int]] | None = None, front: bool = False, inplace: Literal[True] = True, wrap: bool = False, *, copy: bool = True, var_remap: Mapping[str | Var | Stretch, str | Var | Stretch] | None = None, inline_captures: bool = False) → None

compose(other: QuantumCircuit | Instruction, qubits: Qubit | QuantumRegister | int | slice | Sequence[Qubit | int] | Sequence[Qubit | QuantumRegister | int | slice | Sequence[Qubit | int]] | None = None, clbits: Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int] | Sequence[Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int]] | None = None, front: bool = False, inplace: Literal[False] = False, wrap: bool = False, *, copy: bool = True, var_remap: Mapping[str | Var | Stretch, str | Var | Stretch] | None = None, inline_captures: bool = False) → QuantumCircuit

Aplicar las instrucciones de un circuito a los qubits y/o clbits especificados en otro.

Cuando se trata de variables en tiempo real (expr.Var y expr.Stretch instancias), existen dos estrategias principales para utilizar compose():

1. El circuito other se trata como totalmente aditivo, incluidas sus variables. Las variables de other deben ser totalmente distintas de las de self (utilice var_remap como ayuda), y todas las variables de other se declararán de nuevo en la salida con un ámbito de entrada/captura/local que coincida con el de other. Por lo general, esto es lo que quieres si vas a unir dos circuitos no relacionados.
2. El circuito other fue creado como una extensión exacta de self para ser inlineado sobre él, incluyendo la actuación sobre las variables existentes en sus estados al final de self. En este caso, se debe crear other con todas estas variables a ser inlineadas declaradas como "captures", y luego se puede usar inline_captures=True en este método para enlazarlas. Por lo general, esto es lo que quieres si estás construyendo un circuito definiendo capas sobre la marcha, o reconstruyendo un circuito utilizando capas tomadas de sí mismo. Puede que el argumento vars_mode="captures" de copy_empty_like() para crear la base de cada capa, en este caso.

Parámetros

• other (qiskit.circuit.Instruction orQuantumCircuit) – (sub)circuito o instrucción para componer sobre sí mismo. Si no es un QuantumCircuitpuede ser cualquier cosa que append acepte.

• qubits (list[Qubit|int]) – qubits de uno mismo para componer.

• clbits (list[Clbit|int]) – trozos de sí mismo para componer.

• front (bool) – Si True, se realizará la composición frontal. Esto no es posible en los gestores de contexto de los constructores de flujo de control.

• inplace (bool) – Si True, modifique el objeto. De lo contrario, devuelva el circuito compuesto.

• copy (bool) – Si True (el valor por defecto), entonces la entrada se trata como compartida, y cualquier instrucción contenida se copiará, si puede ser que necesite ser mutada en el futuro. Puede establecerlo a False si la entrada debe considerarse propiedad del circuito base, para evitar copias innecesarias; en este caso, no es válido utilizar other después, y algunas instrucciones pueden haber mutado en su lugar.

• var_remap (Mapping) –

  para reescribir expr.Var y expr.Stretch en other a medida que se incorporan a self. Puede utilizarse para evitar conflictos de nombres.

  Tanto las claves como los valores pueden ser cadenas o identificadores directos. Si una clave es una cadena, coincide con cualquier Var o Stretch con el mismo nombre. Si un valor es una cadena, cada vez que una nueva clave coincida con él, aparecerá un nuevo valor Var o Stretch con el tipo correcto. Si un valor es a Varsu type debe coincidir exactamente con el de la variable a la que sustituye.

• inline_captures (bool) –

  si True, entonces todos los nodos identificadores "capturados" en other QuantumCircuit se supone que se refieren a identificadores ya declarados en self (como cualquier tipo de entrada/captura/local), y los usos en other se aplicarán a los identificadores existentes. Si quieres construir una capa para un circuito existente para usar con compose()puede que le resulte útil el argumento vars_mode="captures" de copy_empty_like() útil. Cualquier remapeo en vars_remap ocurre antes de evaluar esta variable inlining.

  Si es False (el valor predeterminado), se exigirá que todos los identificadores de other sean distintos de los de self, y se harán nuevas declaraciones para ellos.

• wrap (bool) – Si es True, envuelve el otro circuito en una puerta (o instrucción, dependiendo de si contiene sólo instrucciones unitarias) antes de componerlo sobre sí mismo. En lugar de utilizar esta opción, casi siempre es mejor controlarlo manualmente utilizando to_instruction() o to_gate()y luego llamar a append().

Devuelve

el circuito compuesto (devuelve None si inplace==True).

Tipo de retorno

QuantumCircuit

Eleva

• CircuitError - si no se puede realizar una asignación correcta de cables entre los dos circuitos, como por ejemplo si other es más ancho que self.
• CircuitError - si se intenta emitir un nuevo circuito mientras self tiene activo un contexto de flujo de control parcialmente construido, como las formas de gestor de contexto de if_test(), for_loop() y while_loop().
• CircuitError - si se intenta componer al frente de un circuito cuando un bloque constructor de flujo de control está activo; no hay un significado claro para esta acción.

Ejemplos

>>> lhs.compose(rhs, qubits=[3, 2], inplace=True)

            ┌───┐                   ┌─────┐                ┌───┐
lqr_1_0: ───┤ H ├───    rqr_0: ──■──┤ Tdg ├    lqr_1_0: ───┤ H ├───────────────
            ├───┤              ┌─┴─┐└─────┘                ├───┤
lqr_1_1: ───┤ X ├───    rqr_1: ┤ X ├───────    lqr_1_1: ───┤ X ├───────────────
         ┌──┴───┴──┐           └───┘                    ┌──┴───┴──┐┌───┐
lqr_1_2: ┤ U1(0.1) ├  +                     =  lqr_1_2: ┤ U1(0.1) ├┤ X ├───────
         └─────────┘                                    └─────────┘└─┬─┘┌─────┐
lqr_2_0: ─────■─────                           lqr_2_0: ─────■───────■──┤ Tdg ├
            ┌─┴─┐                                          ┌─┴─┐        └─────┘
lqr_2_1: ───┤ X ├───                           lqr_2_1: ───┤ X ├───────────────
            └───┘                                          └───┘
lcr_0: 0 ═══════════                           lcr_0: 0 ═══════════════════════

lcr_1: 0 ═══════════                           lcr_1: 0 ═══════════════════════

tensor(other, inplace=False)

Tensor self con other.

Recuerde que en la convención little-endian la operación más a la izquierda estará en la parte inferior del circuito. Consulte también la documentación para obtener más información.

     ┌────────┐        ┌─────┐          ┌─────┐
q_0: ┤ bottom ├ ⊗ q_0: ┤ top ├  = q_0: ─┤ top ├──
     └────────┘        └─────┘         ┌┴─────┴─┐
                                  q_1: ┤ bottom ├
                                       └────────┘

Parámetros

• other (QuantumCircuit) – El otro circuito con el que tensor este circuito.
• inplace (bool) – Si True, modifique el objeto. En caso contrario, devuelve el circuito compuesto.

Tipo de retorno

QuantumCircuit | Ninguno

Ejemplos

from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
tensored = bottom.tensor(top)
tensored.draw('mpl')

Devuelve

El circuito tensado (devuelve None si inplace=True).

Tipo de retorno

QuantumCircuit

Parámetros

• other (QuantumCircuit) –
• inplace (bool) –

barrier(*qargs, label=None)

Aplicar Barrier. Si qargs está vacío, se aplica a todos los qubits del circuito.

Parámetros

• qargs (QubitSpecifier) – Especificación para uno o más argumentos qubit.
• label (str) – La etiqueta de cadena de la barrera.

Devuelve

asa a las instrucciones añadidas.

Tipo de retorno

qiskit.circuit.InstructionSet

ccx(control_qubit1, control_qubit2, target_qubit, ctrl_state=None)

Solicitar CCXGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits utilizados como primer control.
• control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits utilizados como segundo control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

ccz(control_qubit1, control_qubit2, target_qubit, label=None, ctrl_state=None)

Solicitar CCZGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits utilizados como primer control.
• control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits utilizados como segundo control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "10"). Por defecto se controla en el estado '11'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

ch(control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CHGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El o los qubits utilizados como control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

cp(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CPhaseGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• theta (ParameterExpression |float) – El ángulo de la rotación.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El o los qubits utilizados como control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

crx(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CRXGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• theta (ParameterExpression |float) – El ángulo de la rotación.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El o los qubits utilizados como control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

cry(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CRYGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• theta (ParameterExpression |float) – El ángulo de la rotación.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El o los qubits utilizados como control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

crz(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CRZGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• theta (ParameterExpression |float) – El ángulo de la rotación.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El o los qubits utilizados como control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

cs(control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CSGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El o los qubits utilizados como control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

csdg(control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CSdgGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El o los qubits utilizados como control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

cswap(control_qubit, target_qubit1, target_qubit2, label=None, ctrl_state=None)

Solicitar CSwapGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El o los qubits utilizados como control.
• target_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o los qubits a los que se dirige la puerta.
• target_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o los qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, '1'). Control por defecto en el estado '1' .

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

csx(control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CSXGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El o los qubits utilizados como control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

cu(theta, phi, lam, gamma, control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CUGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• theta (ParameterExpression |float) – El ángulo de rotación $\theta$ de la puerta.
• phi (ParameterExpression |float) – El ángulo de rotación $\phi$ de la puerta.
• lam (ParameterExpression |float) – El ángulo de rotación $\lambda$ de la puerta.
• gamma (ParameterExpression |float) – La fase global aplicada de la puerta U, si se aplica.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El o los qubits utilizados como control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

cx(control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CXGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El o los qubits utilizados como control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

cy(control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CYGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Los qubits utilizados como controles.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

cz(control_qubit, target_qubit, label=None, ctrl_state=None)

Solicitar CZGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Los qubits utilizados como controles.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que se dirige la puerta.
• label (str | None) – La etiqueta de cadena de la puerta en el circuito.
• ctrl_state (str |int | None) – El estado de control en decimal, o como una cadena de bits (por ejemplo, "1"). Por defecto se controla en el estado '1'.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

dcx(qubit1, qubit2)

Solicitar DCXGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que aplicar la puerta.
• qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o qubits a los que aplicar la puerta.

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

delay(duration, qarg=None, unit=None)

Solicitar Delay. Si qarg es None, se aplica a todos los qubits. Si se aplica a varios qubits, se crearán retardos con la misma duración.

Parámetros

• duration (Object) – duración del retraso. Si se trata de un Exprdebe ser una expresión constante de tipo Duration.
• qarg (Object) – qubit para aplicar este retardo.
• unit (str | None) – unidad de la duración, a menos que duration sea una Expr en cuyo caso no debe especificarse. Unidades soportadas: 's', 'ms', 'us', 'ns', 'ps', y 'dt'. Por defecto es 'dt', es decir, unidad de tiempo entera dependiendo del backend de destino.

Devuelve

asa a las instrucciones añadidas.

Tipo de retorno

qiskit.circuit.InstructionSet

Eleva

CircuitError - si los argumentos tienen mal formato.

ecr(qubit1, qubit2)

Solicitar ECRGate.

Para ver la forma matricial completa de esta puerta, consulte la documentación de la puerta subyacente.

Parámetros

• qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Los qubits a los que aplicar la puerta.
• qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Los qubits a los que aplicar la puerta.