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 similar a una lista que contiene las CircuitInstruction instancias del circuito.

Tipo: CircuitData

Un manipulador opaco al objeto nativo de Rust subyacente QuantumCircuit.

Este objeto se corresponde directamente con el objeto de la API de C QkCircuit.

Hay muy pocos usos válidos de este objeto en Python. Puedes pasárselo a funciones que esperan el tipo de la API de C QkCircuit, como aquellas que llamarán a qk_circuit_borrow_from_python(); puedes utilizarlo como un passmanager.IR; puedes reconstruir el circuito completo con QuantumCircuit.from_circuit_data().

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. Ten en cuenta que los parámetros instanciados con un ParameterVector siguen ordenándose 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 .

>>> 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 objetos ordenados Parameter en el circuito.

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

Este atributo contiene un objeto opcional TranspileLayout . Normalmente se establece en la salida de transpile() o PassManager.run() para conservar la información sobre las permutaciones provocadas en el circuito de entrada por la transpilación.

Hay dos tipos de permutaciones provocadas por la transpile() función: una disposición inicial que permuta los qubits en función de los qubits físicos seleccionados en la Target, y una disposición final, que es una permutación de salida provocada por SwapGatelos s 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 especifica, se asignará una cadena generada automáticamente.

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

• metadata (dict | None) – Metadatos con valores de clave arbitrarios para asociar al circuito. Esto se almacena como datos de formato libre en un diccionario dentro del atributo metadata . No se utilizará directamente en el circuito.

• inputs (Iterable[Var]) – No hay variables que declarar como variables input de tiempo de ejecución para este circuito. Estos deberían ser nodos ya expr.Var existentes que hayas creado en otro lugar; si también necesitas crear las entradas, utiliza 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 heredar de un ámbito superior. 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 le dará al circuito copiado. Si es «None», el nombre se mantiene 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 «None», el nombre se mantiene 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 que hay que 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 con valores de clave arbitrarios para asociar al circuito.

Devuelve

El circuito cuántico.

Tipo de retorno

QuantumCircuit

static from_circuit_data(data, /, *, name=None, metadata=None)

Construye un circuito a partir de un objeto opaco CircuitData.

Normalmente, esta función se utiliza para envolver un objeto procedente de C en una clase QuantumCircuit completa de Python. El objeto CircuitData es el objeto nativo de Rust que se corresponde con el objeto de la API de C QkCircuit. Consulta su documentación para obtener más detalles sobre este objeto opaco.

La inversa de esta función es el atributo _data .

Parámetros

• data (CircuitData) – el objeto nativo que contiene el circuito IR.
• name (str | None) – : un nombre opcional, exclusivo de Python, que se aplicará al circuito.
• metadata (dict | None) – : metadatos opcionales, arbitrarios y exclusivos de Python que se pueden adjuntar al circuito.

Devuelve

Un objeto de circuito completo.

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 |PathLike) – Ruta al archivo de un programa de 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 de OpenQASM2.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) – : o bien una cadena con el nombre de la variable, o bien una instancia existente de Var que se vaya a 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

• name_or_var (str |Var) – : un nombre de cadena o un nodo Var existente que se 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.
• type_ (Type | None)

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.

Tipo de retorno

Var

add_stretch(name_or_stretch)

Declara un nuevo tramo para este circuito.

Parámetros

name_or_stretch (str |Stretch) – : o bien una cadena con el nombre del tramo, o bien una instancia ya existente que se vaya a Stretch reutilizar. Los nombres «Stretches» no pueden solaparse con 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, List[Tuple( Register, 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 un diccionario, las claves deben ser Parameter instancias del circuito actual. Los valores del diccionario pueden ser valores numéricos o nuevos objetos de parámetro.

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

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

Parámetros

• parameters (Mapping[Parameter, ParameterExpression |float] | Iterable[ParameterExpression |float]) – Un diccionario o un iterable que especifique los nuevos valores de los parámetros.
• inplace (bool) – Si el valor es «False», se devuelve una copia del circuito con los parámetros vinculados. Si el valor es «True», se modifica la propia instancia del circuito.
• flat_input (bool) – Si y True es parameters un tipo de aplicación, se supone que es exactamente una aplicación de {parameter: value}. Por defecto (False), la asignación también puede contener ParameterVector claves que apunten a una secuencia correspondiente de valores, las cuales se desarrollarán durante la asignación, o claves de cadena, que se convertirán en instancias Parameter mediante get_parameter().
• strict (bool) – Si False, se ignorarán los parámetros especificados en la asignación que no se utilicen en el circuito. Si ( True valor predeterminado), se generará un error que indicará un error lógico.

Eleva

• CircuitError - Si parameters es un dict y contiene parámetros no presentes en el circuito.
• ValueError : si «parameters» es una lista o un array y su longitud no coincide con el número de parámetros libres del circuito.

Devuelve

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

Tipo de retorno

QuantumCircuit | Ninguno

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 el nombre del parámetro que se va a comprobar. Si se trata de un nodo Parameter , el parámetro debe ser exactamente el indicado 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: builtin_types.EllipsisType = Ellipsis) → Parameter

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

Parámetros

• name (str) – : el nombre del parámetro que se va a recuperar.
• default (Any) – : si se proporciona, se devolverá este valor en caso de que el parámetro no esté presente. Si no se especifica, KeyError se genera un en su lugar.

Devuelve

El parámetro correspondiente.

Eleva

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

Tipo de retorno

Parámetro

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 == 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) == my_param
assert qc.get_parameter("unknown_param", None) is None

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

get_var(name: str, default: builtin_types.EllipsisType = Ellipsis) → Var

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

Parámetros

• name (str) – : el nombre de la variable que se va a recuperar.
• default (Any) – : si se proporciona, se devolverá este valor si la variable no existe. Si no se especifica, KeyError se genera un en su lugar.

Devuelve

La variable correspondiente.

Eleva

KeyError : si no se ha especificado 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 == 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) == my_var
assert qc.get_var("unknown_variable", None) is None

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

get_stretch(name: str, default: builtin_types.EllipsisType = Ellipsis) → Stretch

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

Parámetros

• name (str) – : el nombre del tramo que se desea recuperar.
• default (Any) – : si se proporciona, se devolverá este valor si la variable no existe. Si no se especifica, KeyError se genera un en su lugar.

Devuelve

El tramo correspondiente.

Eleva

KeyError : si no se ha especificado 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 == 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) == 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: builtin_types.EllipsisType = 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 (str) – : el nombre del identificador que se desea recuperar.
• default (Any) – : si se proporciona, se devolverá este valor si la variable no existe. Si no se especifica, KeyError se genera un en su lugar.

Devuelve

La variable correspondiente.

Eleva

KeyError : si no se ha especificado 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 la 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 el nombre del tramo que se va a comprobar. Si se trata de un nodo expr.Stretch , el estiramiento debe ser exactamente el indicado 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 expr.Stretch nodo o expr.Var , la instancia coincidente debe ser exactamente la indicada 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.

InstructionLos elementos qargs y cargs se ampliarán y se transmitirán de acuerdo con las reglas del dado, y cualquier elemento que no seaBit un especificador (como los índices enteros) se resolverá en las instancias pertinentes.

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

Parámetros

• instruction (Operation |CircuitInstruction) –Instruction instancia a la que añadir, o un CircuitInstruction con todo su contexto. También se admiten los objetos que implementan to_instruction , pero por lo general es preferible pasar un Instruction directamente, ya que así se evita el coste de las conversiones repetidas.
• Especificadores qargs (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]] | None) – de los Qubit«s» a los que se va a adjuntar la instrucción.
• Especificadores cargs (Sequence[Clbit |ClassicalRegister |int |slice |Sequence[Clbit |int]] | None) – de los Clbit«s» a los que se va a adjuntar la instrucción.
• copy (bool) – si ( True por defecto), entonces el valor entrante instruction se copia antes de añadirlo al circuito si contiene parámetros simbólicos, de modo que pueda modificarse con seguridad sin afectar a otros circuitos en los que pueda encontrarse la misma instrucción. Si estás seguro de que esta instrucción no aparecerá en otros circuitos, puedes configurarla así para False obtener una pequeña mejora en la velocidad.

Devuelve

una referencia a los CircuitInstruction«s» que se añadieron realmente al circuito.

Tipo de retorno

qiskit.circuit.InstructionSet

Eleva

CircuitError – si la operación pasada no es una instancia de Instruction, o no puede convertirse en una llamando a to_instruction sobre ella.

_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 -

  Se debe añadir una descripción completa y bien estructurada CircuitInstruction de la operación y su contexto.

  En el formulario de compatibilidad con versiones anteriores, puede tratarse de un Operation, en cuyo caso qargs y cargs deben indicarse explícitamente.

• qargs – Argumento heredado para que los qubits se acoplen al «bare Operation ». Se ignora si el primer argumento está en forma preferencial CircuitInstruction .

• cargs : argumento heredado de clbits al que se adjunta el «bare Operation ». Se ignora si el primer argumento está en forma preferencial CircuitInstruction .

• _standard_gate (bool)

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 componerse a sí mismo. Si no es un QuantumCircuit, puede ser cualquier cosa que append acepte.

• qubits (list[Qubit|int]) – qubits propios sobre los que componer.

• clbits (list[Clbit|int]) – clbits de «self» sobre los que realizar la composición.

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

• inplace (bool) – Si es así True, modifica el objeto. De lo contrario, devuelve el circuito compuesto.

• copy (bool) – Si ( True valor por defecto), la entrada se considera compartida y se copiarán todas las instrucciones que contenga, en caso de que sea necesario modificarlas en el futuro. Puedes configurar esta opción para indicar que False la entrada debe considerarse propiedad del circuito base, con el fin de evitar copias innecesarias; en este caso, no es válido utilizar other posteriormente, y es posible que algunas instrucciones se hayan modificado in situ.

• 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 verdadero, envuelve el otro circuito en una puerta (o instrucción, dependiendo de si contiene únicamente instrucciones unitarias) antes de componerlo sobre sí mismo. En lugar de utilizar esta opción, casi siempre es mejor controlarlo manualmente tú mismo utilizando o to_instruction() to_gate(), y después 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 es así True, modifica el objeto. De lo 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, label=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(los) qubit(s) utilizado(s) como primer control.
• control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El(los) qubit(s) utilizado(s) como segundo control.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o los qubits a los que se dirige la puerta.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa en el estado «1».
• label (str | None) – La etiqueta de cadena de la puerta del circuito.

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(los) qubit(s) utilizado(s) como primer control.
• control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El(los) qubit(s) utilizado(s) como segundo control.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «10»). Por defecto, el control se realiza 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(los) qubit(s) utilizado(s) como control.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa 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 rotación.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El(los) qubit(s) utilizado(s) como control.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa 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 rotación.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El(los) qubit(s) utilizado(s) como control.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa 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 rotación.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El(los) qubit(s) utilizado(s) como control.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa 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 rotación.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El(los) qubit(s) utilizado(s) como control.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa 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(los) qubit(s) utilizado(s) como control.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa 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(los) qubit(s) utilizado(s) como control.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa 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(los) qubit(s) utilizado(s) 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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., '1'). Por defecto, se controla en función del 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(los) qubit(s) utilizado(s) como control.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa 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 a la puerta U, en caso de que se aplique.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El(los) qubit(s) utilizado(s) como control.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa 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(los) qubit(s) utilizado(s) como control.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa 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]) – El(los) qubit(s) utilizado(s) como controles.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa 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]) – El(los) qubit(s) utilizado(s) como controles.
• target_qubit (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 del circuito.
• ctrl_state (str |int | None) – El estado de control en formato decimal o como cadena de bits (p. ej., «1»). Por defecto, el control se activa en el estado «1».

Devuelve

Un handle a las instrucciones creadas.

Tipo de retorno

InstructionSet

dcx(qubit1, qubit2, label=None)

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 los qubits a los que se aplicará la puerta.
• qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – El qubit o los qubits a los que se aplicará la puerta.
• label (str | None) – La etiqueta de cadena de la puerta del circuito.

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 duración, a menos que duration sea un, en Expr cuyo caso no debe especificarse. Unidades compatibles: 's', 'ms', 'us', 'ns', 'ps', y 'dt'. El valor por defecto es 'dt', es decir, una unidad de tiempo entera que depende del backend de destino.