QuantumCircuit aula

Os dados do circuito (instruções e contexto).

Exemplo

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),))]

Retorna

Um objeto do tipo lista que contém as CircuitInstruction instâncias do circuito.

A fase global do escopo do circuito atual em radianos.

Exemplo

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

Um nome legível por humanos para o circuito.

Exemplo

from qiskit import QuantumCircuit

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

my_circuit

Dicionário arbitrário de metadados definido pelo usuário para o circuito.

O Qiskit não examinará o conteúdo desse mapeamento, mas o passará pelo transpilador e o anexará novamente à saída, para que você possa rastrear seus próprios metadados.

Exemplo

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2, metadata={'experiment_type': 'Bell state experiment'})

print(qc.metadata)

{'experiment_type': 'Bell state experiment'}

Uma lista de Qubits na ordem em que foram adicionados. Você não deve alterar isso.

Uma lista de Clbits na ordem em que foram adicionados. Você não deve alterar isso.

Uma lista de Qubits na ordem em que foram adicionados. Você não deve alterar isso.

Uma lista de AncillaQubits na ordem em que foram adicionados. Você não deve alterar isso.

Uma lista de Clbits na ordem em que foram adicionados. Você não deve alterar isso.

Exemplo

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)]

Os parâmetros definidos no circuito.

Esse atributo retorna os Parameter objetos no circuito classificados em ordem alfabética. Observe que os parâmetros instanciados com um ParameterVector ainda são classificados numericamente.

Exemplos

O trecho abaixo mostra que a ordem de inserção dos parâmetros não 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)])

Lembre-se de que a classificação alfabética pode não ser intuitiva quando se trata de números. O literal "10" vem antes do "2" em uma classificação alfabética rigorosa.

>>> 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 respeitar a classificação numérica, um ParameterVector pode ser usado.

>>> 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])
])

Retorna

Os objetos Parameter classificados no circuito.

Retorna qualquer informação de layout associada sobre o circuito.

Esse atributo contém um objeto TranspileLayout objeto. Normalmente, isso é definido na saída de transpile() ou PassManager.run() para reter informações sobre as permutações causadas no circuito de entrada pela transpilação.

Há dois tipos de permutações causadas pela função transpile() um layout inicial que permuta os qubits com base nos qubits físicos selecionados na função Targete um layout final, que é uma permutação de saída causada por SwapGates inseridos durante o roteamento.

Exemplo

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]

A duração total do circuito, definida por uma passagem do transpilador de agendamento. Sua unidade é especificada por unit.

A unidade em que duration é especificada em.

Retorna uma lista de horas de início da operação.

Esse atributo é ativado quando uma das passagens de análise de agendamento é executada no circuito quântico.

Exemplo

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

Retorna

Lista de números inteiros que representam os horários de início estimados das instruções. O índice corresponde ao índice da instrução em QuantumCircuit.data.

Aumentos

AttributeError - Quando o circuito não está programado.

Retorna o número de qubits ancilla.

Exemplo

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

Retorna o número de bits clássicos.

Exemplo

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

O número de variáveis clássicas em tempo real no circuito marcadas como capturadas de um escopo de fechamento.

Esse é o comprimento do iter_captured_vars() iterável. Se esse valor for diferente de zero, num_input_vars deve ser zero.

O número de trechos no circuito marcados como capturados em um escopo de cobertura.

Esse é o comprimento do iter_captured_stretches() iterável. Se esse valor for diferente de zero, num_input_vars deve ser zero.

O número de variáveis clássicas em tempo real no circuito que são declaradas por esse escopo de circuito, excluindo entradas ou capturas.

Esse é o comprimento do iter_declared_vars() iterável.

O número de trechos no circuito que são declarados por esse escopo de circuito, excluindo as capturas.

Esse é o comprimento do iter_declared_stretches() iterável.

O número de variáveis clássicas em tempo real no circuito marcadas como entradas do circuito.

Esse é o comprimento do iter_input_vars() iterável. Se esse valor for diferente de zero, num_captured_vars deve ser zero.

O número de variáveis e trechos clássicos em tempo real no circuito.

Isso é igual a num_vars() + num_stretches().

O número de objetos de parâmetro no circuito.

Retorna o número de qubits.

O número de trechos no circuito.

Esse é o comprimento do iter_stretches() iterável.

O número de variáveis clássicas em tempo real no circuito.

Esse é o comprimento do iter_vars() iterável.

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

Construtor padrão de QuantumCircuit.

Parâmetros

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

  Os registros a serem incluídos no circuito.

  • Se uma lista de objetos Register representa os objetos QuantumRegister e/ou ClassicalRegister objetos a serem incluídos no circuito.

    Por exemplo:

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

  • Se for uma lista de int, a quantidade de qubits e/ou bits clássicos a serem incluídos no circuito. Pode ser um único int para apenas o número de bits quânticos ou 2 ints para o número de bits quânticos e bits clássicos, respectivamente.

    Por exemplo:

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

  • Se uma lista de listas python contendo Bit objetos, uma coleção de Bit s a ser adicionada ao circuito.

• name (str | None) – o nome do circuito quântico. Se não for definido, será atribuída uma cadeia de caracteres gerada automaticamente.

• global_phase (ParameterExpression |float) – A fase global do circuito em radianos.

• metadata (dict | None) – Metadados arbitrários de valor-chave para associar ao circuito. Isso é armazenado como dados de forma livre em um dict no atributo metadata atributo. Ele não será usado diretamente no circuito.

• inputs (Iterable[Var]) – algumas variáveis a serem declaradas como variáveis input de tempo de execução para este circuito. Esses já devem ser nós expr.Var existentes que você criou em outro lugar; se precisar criar as entradas também, use QuantumCircuit.add_input(). As variáveis fornecidas neste argumento serão passadas diretamente para add_input(). Um circuito não pode ter tanto inputs quanto captures.

• captures (Iterable[Var |Stretch]) – quaisquer variáveis que este escopo de circuito deva herdar de um escopo contido. As variáveis aqui indicadas serão passadas diretamente para add_capture(). Um circuito não pode ter tanto inputs quanto captures.

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

  quaisquer variáveis que esse circuito deva declarar e inicializar imediatamente. Você pode ordenar essa entrada de modo que as declarações posteriores dependam das anteriores (incluindo entradas ou capturas). Se você precisar depender de valores que serão computados posteriormente em tempo de execução, use add_var() em um ponto apropriado na execução do circuito.

  Esse argumento destina-se à inicialização conveniente do circuito quando você já tem um conjunto de variáveis criadas. As variáveis usadas aqui serão passadas diretamente para add_var()que você pode usar diretamente se esta for a primeira vez que estiver criando a variável.

Aumentos

• CircuitError - se o nome do circuito, se fornecido, não for válido.
• CircuitError - se ambos inputs e captures forem fornecidos.

copy(name=None)

Copie o circuito.

Parâmetros

name (str) – nome a ser dado ao circuito copiado. Se for None, o nome permanecerá o mesmo.

Retorna

uma cópia profunda do circuito atual, com o nome especificado

Tipo de retorno

QuantumCircuit

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

Retorna uma cópia de self com a mesma estrutura, mas vazia.

Essa estrutura inclui:

• nome e outros metadados
• fase global
• todos os qubits e clbits, inclusive os registros
• as variáveis de tempo real definidas no circuito, tratadas de acordo com o argumento da palavra-chave vars .

Parâmetros

• name (str | None) – Nome do circuito copiado. Se for None, o nome permanecerá o mesmo.

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

  O modo de tratamento de variáveis em tempo real.

  semelhantes

  As variáveis no circuito de saída terão a mesma semântica de declaração que no circuito original. Por exemplo, as variáveis input na fonte serão variáveis input no circuito de saída. Observe que isso faz com que as variáveis locais não sejam inicializadas, pois os armazenamentos não são copiados. Isso pode deixar o circuito em um estado potencialmente perigoso para os usuários se eles não adicionarem novamente os armazenamentos do inicializador.

  capturas

  Todas as variáveis serão convertidas em variáveis capturadas. Isso é útil quando se está construindo uma nova camada para um circuito existente que se deseja colocar na base compose() na base, pois compose() pode incorporar capturas ao circuito de base (mas não a outras variáveis).

  **DROP **

  O circuito de saída não terá variáveis definidas.

Retorna

Uma cópia vazia de si mesmo.

Tipo de retorno

QuantumCircuit

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

Construa um circuito a partir de um iterável 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]]]) – As instruções a serem adicionadas ao circuito.
• qubits (Iterable[Qubit]) – Quaisquer qubits a serem adicionados ao circuito. Esse argumento pode ser usado, por exemplo, para impor uma ordem específica de qubits.
• clbits (Iterable[Clbit]) – Quaisquer bits clássicos para adicionar ao circuito. Esse argumento pode ser usado, por exemplo, para impor uma ordem específica de bits clássicos.
• name (str | None) – O nome do circuito.
• global_phase (ParameterValueType) – A fase global do circuito em radianos.
• metadata (dict | None) – Metadados arbitrários de valor-chave para associar ao circuito.

Retorna

O circuito quântico.

Tipo de retorno

QuantumCircuit

static from_qasm_file(path)

Leia um programa OpenQASM 2.0 de um arquivo e converta-o em uma instância do QuantumCircuit.

Parâmetros

path (str |PathLike) – Caminho para o arquivo de um programa do OpenQASM 2

Retorna

O objeto QuantumCircuit para a entrada OpenQASM 2.

Tipo de retorno

QuantumCircuit

static from_qasm_str(qasm_str)

Converta uma string contendo um programa OpenQASM 2.0 em um arquivo QuantumCircuit.

Parâmetros

qasm_str (str) – Uma cadeia de caracteres que contém um programa OpenQASM 2.0.

Retorna

O objeto QuantumCircuit para a entrada OpenQASM 2

Tipo de retorno

QuantumCircuit

add_bits(bits)

Adicione bits ao circuito.

Parâmetros

bits (Iterable[Bit])

Tipo de retorno

Nenhum

add_register(*regs)

Adicione registros.

Parâmetros

regs (Register |int |Sequence[Bit])

Tipo de retorno

Nenhum

add_var(name_or_var, /, initial)

Adicione uma variável clássica com armazenamento automático e escopo a esse circuito.

Considera-se que a variável foi "declarada" no início do circuito, mas ela só é inicializada no ponto do circuito em que você chama esse método, portanto, ela pode depender de variáveis definidas antes dela.

Parâmetros

• name_or_var (str |Var) – uma string do nome da variável ou uma instância existente para Var reutilização. As variáveis não podem ocultar nomes que já estejam em uso no circuito.

• initial (Any) –

  o valor com o qual inicializar essa variável. Se o primeiro argumento foi fornecido como um nome de cadeia de caracteres, o tipo da variável resultante é inferido a partir da expressão inicial; para controlar isso mais manualmente, use Var.new() para construir manualmente uma nova variável com o tipo desejado ou use expr.cast() para converter o inicializador para o tipo desejado.

  Isso deve ser um nó Expr ou um valor que pode ser elevado a um nó usando expr.lift.

Retorna

A variável criada. Se uma instância Var tiver sido fornecida, será retornado exatamente o mesmo objeto.

Aumentos

CircuitError - se a variável não puder ser criada devido à sombra de um identificador existente.

Tipo de retorno

Var

Exemplos

Defina uma nova variável com apenas um nome e uma expressão inicializadora:

from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2)
my_var = qc.add_var("my_var", False)

Reutilizar uma variável que pode ter sido retirada de um circuito relacionado ou construída manualmente e inicializá-la com alguma expressão mais 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

Registre uma variável como uma entrada para o circuito.

Parâmetros

• name_or_var (str |Var) – um nome de string ou um nó Var existente a ser usado como variável de entrada.
• type (tipo ) - se o nome for fornecido como uma cadeia de caracteres, então esse deve ser um tipo Type a ser usada para a variável. Se a variável for fornecida como um objeto existente Varexistente, ela não deverá ser fornecida e, em vez disso, será lida do próprio objeto.
• type_ (Type | None)

Retorna

a variável criada ou a mesma variável que foi passada.

Aumentos

CircuitError - se a variável não puder ser criada devido à sombra de uma variável existente.

Tipo de retorno

Var

add_stretch(name_or_stretch)

Declara um novo trecho com escopo para esse circuito.

Parâmetros

name_or_stretch (str |Stretch) – uma string com o nome do stretch ou uma instância existente para Stretch reutilização. Os trechos não podem ter nomes que já estejam em uso no circuito.

Retorna

O trecho criado. Se uma instância Stretch tiver sido fornecida, será retornado exatamente o mesmo objeto.

Aumentos

CircuitError - se o trecho não puder ser criado devido à sombra de um identificador existente.

Tipo de retorno

Alongamento

Exemplos

Definir e usar um novo trecho com apenas um nome:

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, /)

Adicionar uma variável sem inicializador.

Na maioria dos casos, você deve usar add_var() para inicializar a variável. Para usar essa função, você já deve ter uma instância Var pois o uso da função normalmente só faz sentido em contextos de cópia.

Parâmetros

var (Var) – a variável a ser adicionada.

add_capture(var: Var)

add_capture(stretch: Stretch)

Adicione um identificador ao circuito que ele deve capturar de um escopo no qual estará contido.

Esse método requer um Var ou Stretch para garantir que você tenha uma alça para um identificador, pois será necessário declarar o mesmo identificador usando o mesmo objeto no circuito externo.

Esse é um método de baixo nível, que só é realmente útil se você estiver construindo manualmente operações de fluxo de controle. Normalmente, não será necessário chamar esse método, desde que você esteja usando a interface do construtor para escopos de fluxo de controle (with context-manager statements for if_test() e outras construções de escopo). A interface do construtor criará automaticamente os fechamentos de escopos internos em seu nome, capturando todos os identificadores usados neles.

Parâmetros

var (Union[expr.Var, expr.Stretch]) – a variável ou trecho a ser capturado de um escopo adjacente.

Aumentos

CircuitError - se o identificador não puder ser criado devido à sombra de um identificador existente.

find_bit(bit)

Encontre locais no circuito que possam ser usados para referenciar um determinado Bit.

Em particular, essa função pode encontrar o índice inteiro de um qubit, que corresponde ao seu índice de hardware para um circuito transpilado.

Parâmetros

bit (Bit) – O bit a ser localizado.

Retorna

Um conjunto de 2. O primeiro elemento (index) contém o índice no qual o Bit pode ser encontrado (em qubits, clbits, dependendo de seu tipo). O segundo elemento (registers) é uma lista de pares (register, index) com uma entrada para cada Register no circuito que contém o Bit (e o índice no Register no qual ele pode ser encontrado).

Tipo de retorno

namedtuple (int, List[Tuple (Register, int )])

Aumentos

• CircuitError - Se o arquivo fornecido Bit fornecido for de um tipo desconhecido.
• CircuitError - Se o cabo fornecido Bit não puder ser encontrado no circuito.

Exemplos

Percorrer um circuito, obtendo os índices de qubit e clbit de cada operação:

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)

Teste se esse circuito tem o registro r.

Parâmetros

register (Register) – um registro quântico ou clássico.

Retorna

Verdadeiro se o registro estiver contido nesse 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

Atribuir parâmetros a novos parâmetros ou valores.

Se parameters for passado como um dicionário, as chaves deverão ser Parameter instâncias no circuito atual. Os valores do dicionário podem ser valores numéricos ou novos objetos de parâmetro.

Se parameters for passado como uma lista ou matriz, os elementos serão atribuídos aos parâmetros atuais na ordem de parameters que é classificada em ordem alfabética (respeitando a ordem nos objetos ParameterVector objetos).

Os valores podem ser atribuídos ao objeto do circuito atual ou a uma cópia dele.

Parâmetros

• parameters (Mapping[Parameter, ParameterExpression |float] | Iterable[ParameterExpression |float]) – Um dicionário ou um objeto iterável que especifique os novos valores dos parâmetros.
• inplace (bool) – Se for False, é retornada uma cópia do circuito com os parâmetros definidos. Se for True, a própria instância do circuito é modificada.
• flat_input (bool) – Se True e parameters é um tipo de mapeamento, presume-se que seja exatamente um mapeamento de {parameter: value}. Por padrão (False), o mapeamento também pode conter ParameterVector chaves que apontam para uma sequência correspondente de valores, e estas serão desdobradas durante o mapeamento, ou chaves de string, que serão convertidas em Parameter instâncias usando get_parameter().
• strict (bool) – Se houver False, quaisquer parâmetros especificados no mapeamento que não sejam utilizados no circuito serão ignorados. Se True (padrão), será gerado um erro indicando um erro lógico.

Aumentos

• CircuitError - Se parameters for um dict e contiver parâmetros não presentes no circuito.
• ValueError - Se os parâmetros forem uma lista/vetor e o comprimento não corresponder ao número de parâmetros livres no circuito.

Retorna

Uma cópia do circuito com parâmetros vinculados se inplace for False; caso contrário, None.

Tipo de retorno

QuantumCircuit | Nenhum

Exemplos

Crie um circuito parametrizado e atribua os parâmetros no local.

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')

Associe os valores fora do lugar por lista e obtenha uma cópia do 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, /)

Verificar se existe um objeto de parâmetro nesse circuito.

Parâmetros

name_or_param (str |Parameter) – o parâmetro ou o nome de um parâmetro a ser verificado. Se esse for um nó Parameter o parâmetro deve ser exatamente o parâmetro fornecido para que essa função retorne True.

Retorna

se um parâmetro de correspondência pode ser atribuído nesse circuito.

Tipo de retorno

bool

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

get_parameter(name: str, default: builtin_types.EllipsisType = Ellipsis) → Parameter

Recupera um parâmetro de tempo de compilação que é acessível nesse escopo de circuito por nome.

Parâmetros

• name (str) – o nome do parâmetro a ser recuperado.
• default (Any) – Se fornecido, esse valor será retornado caso o parâmetro não esteja presente. Se não for fornecido, é gerada KeyError uma exceção.

Retorna

O parâmetro correspondente.

Aumentos

KeyError - se nenhum padrão for fornecido, mas o parâmetro não existir no circuito.

Tipo de retorno

Parâmetro

Exemplos

Recuperar um parâmetro por nome em um circuito:

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

Obtém uma variável de um circuito pelo nome, retornando algum padrão se ela não estiver 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 uma variável que pode ser acessada nesse escopo de circuito por nome.

Parâmetros

• name (str) – o nome da variável a ser recuperada.
• default (Any) – Se fornecido, esse valor será retornado caso a variável não exista. Se não for fornecido, é gerada KeyError uma exceção.

Retorna

A variável correspondente.

Aumentos

KeyError - se nenhum padrão for fornecido, mas a variável não existir.

Exemplos

Recuperar uma variável por nome em um 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

Obtém uma variável de um circuito pelo nome, retornando algum padrão se ela não estiver 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 um trecho que é acessível nesse escopo de circuito por nome.

Parâmetros

• name (str) – o nome do trecho a ser recuperado.
• default (Any) – Se fornecido, esse valor será retornado caso a variável não exista. Se não for fornecido, é gerada KeyError uma exceção.

Retorna

O trecho correspondente.

Aumentos

KeyError - se nenhum padrão for fornecido, mas a variável não existir.

Exemplos

Recuperar um trecho por nome em um 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

Obtém uma variável de um circuito pelo nome, retornando algum padrão se ela não estiver 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 um identificador que é acessível nesse escopo de circuito por nome.

Atualmente, isso inclui variáveis e extensões clássicas em tempo real.

Parâmetros

• name (str) – o nome do identificador a ser recuperado.
• default (Any) – Se fornecido, esse valor será retornado caso a variável não exista. Se não for fornecido, é gerada KeyError uma exceção.

Retorna

A variável correspondente.

Aumentos

KeyError - se nenhum padrão for fornecido, mas o identificador não existir.

has_var(name_or_var, /)

Verificar se uma variável está acessível nesse escopo.

Parâmetros

name_or_var (str |Var) – a variável ou o nome de uma variável a ser verificada. Se este for um expr.Var nó, a variável deve ser exatamente a fornecida para que esta função retorne True.

Retorna

se uma variável correspondente está acessível.

Tipo de retorno

bool

has_stretch(name_or_stretch, /)

Verifique se um trecho está acessível nesse escopo.

Parâmetros

name_or_stretch (str |Stretch) – o trecho ou nome de um trecho a ser verificado. Se este for um expr.Stretch nó, o alongamento deve ser exatamente o indicado para que esta função retorne True.

Retorna

se um trecho correspondente está acessível.

Tipo de retorno

bool

has_identifier(name_or_ident, /)

Verificar se um identificador está acessível nesse escopo.

Parâmetros

name_or_ident (str |Var |Stretch) – a instância ou o nome do identificador a ser verificado. Se este for um nó expr.Var expr.Stretch ou, a instância correspondente deve ser exatamente a fornecida para que esta função retorne True.

Retorna

se um identificador correspondente está acessível.

Tipo de retorno

bool

iter_vars()

Obtém um iterável sobre todas as variáveis clássicas em tempo real no escopo desse circuito.

Esse método itera sobre todas as variáveis no escopo. Para obter iteradores mais refinados, consulte iter_declared_vars(), iter_input_vars() e iter_captured_vars().

Tipo de retorno

Iterável[* Var* ]

iter_stretches()

Obtém um iterável sobre todos os trechos no escopo desse circuito.

Esse método itera sobre todas as extensões no escopo. Para obter iteradores mais refinados, consulte iter_declared_stretches() e iter_captured_stretches().

Tipo de retorno

Iterável[* Stretch* ]

iter_input_vars()

Obtém um iterável sobre todas as variáveis clássicas em tempo real que são declaradas como entradas para esse escopo de circuito. Isso exclui variáveis declaradas localmente (consulte iter_declared_vars()) e variáveis capturadas (consulte iter_captured_vars()).

Tipo de retorno

Iterável[* Var* ]

iter_captured_vars()

Obtém um iterável sobre todas as variáveis clássicas em tempo real que são capturadas por esse escopo de circuito a partir de um escopo que o contém. Isso exclui variáveis de entrada (consulte iter_input_vars()) e variáveis declaradas localmente (consulte iter_declared_vars()).

Tipo de retorno

Iterável[* Var* ]

iter_captured_stretches()

Obtém um iterável sobre trechos que são capturados por esse escopo de circuito a partir de um escopo que o contém. Isso exclui os trechos declarados localmente (consulte iter_declared_stretches()).

Tipo de retorno

Iterável[* Stretch* ]

iter_declared_vars()

Obtém um iterável sobre todas as variáveis clássicas em tempo real que são declaradas com duração de armazenamento automático nesse escopo. Isso exclui as variáveis de entrada (consulte iter_input_vars()) e variáveis capturadas (consulte iter_captured_vars()).

Tipo de retorno

Iterável[* Var* ]

iter_declared_stretches()

Obtém um iterável sobre todas as extensões declaradas nesse escopo. Isso exclui os trechos capturados (consulte iter_captured_stretches()).

Tipo de retorno

Iterável[* Stretch* ]

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

Anexar uma ou mais instruções ao final do circuito, modificando o circuito no local.

O qargs e o cargs serão expandidos e transmitidos de acordo com as regras do Instructione quaisquer especificadores nãoBit (como índices inteiros) serão resolvidos nas instâncias relevantes.

Se um CircuitInstruction for fornecido, ele será desembrulhado, verificado no contexto desse circuito, e um novo objeto será anexado ao circuito. Nesse caso, você não pode passar qargs ou cargs separadamente.

Parâmetros

• instruction (Operation |CircuitInstruction) –Instruction para anexar, ou uma instância CircuitInstruction com todo o seu contexto.
• qargs (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]] | None) – especificadores aos quais a instrução Qubit deve ser anexada.
• cargs (Sequence[Clbit |ClassicalRegister |int |slice |Sequence[Clbit |int]] | None) – especificadores aos quais a instrução Clbit deve ser anexada.
• copy (bool) – se for True (o padrão), a entrada instruction será copiada antes de ser adicionada ao circuito se contiver parâmetros simbólicos, para que possa ser alterada com segurança sem afetar outros circuitos em que a mesma instrução possa estar. Se tiver certeza de que essa instrução não estará em outros circuitos, você pode definir esse False para um pequeno aumento de velocidade.

Retorna

uma alça para os CircuitInstructions que foram de fato adicionados ao circuito.

Tipo de retorno

qiskit.circuit.InstructionSet

Aumentos

CircuitError - se a operação passada não for uma instância de Instruction .

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

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

Anexar uma instrução ao final do circuito, modificando o circuito no local.

Parâmetros

• instrução -

  Uma descrição completa e bem formada CircuitInstruction da operação e seu contexto a ser adicionado.

  Na forma de compatibilidade herdada, isso pode ser um simples Operatione, nesse caso, qargs e cargs devem ser fornecidos explicitamente.

• qargs - Argumento de legado para os qubits aos quais anexar o bare Operation a. Ignorado se o primeiro argumento estiver na forma preferencial CircuitInstruction preferencial.

• cargs - Argumento de legado para clbits para anexar o bare Operation a. Ignorado se o primeiro argumento estiver na forma preferencial CircuitInstruction preferencial.

• _standard_gate (bool)

Retorna

um identificador da instrução que acabou de ser adicionada.

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 as instruções de um circuito em qubits e/ou clbits especificados em outro.

Ao lidar com variáveis em tempo real (expr.Var e expr.Stretch existem duas estratégias principais para usar compose():

1. O circuito other é tratado como totalmente aditivo, inclusive suas variáveis. As variáveis em other devem ser totalmente distintas das variáveis em self (use var_remap para ajudar nisso), e todas as variáveis em other serão declaradas novamente na saída com o escopo de entrada/captura/local correspondente ao modo como estão em other. Geralmente, é isso que você deseja se estiver unindo dois circuitos não relacionados.
2. O circuito other foi criado como uma extensão exata do self para ser incorporado a ele, inclusive atuando sobre as variáveis existentes em seus estados no final do self. Nesse caso, o site other deve ser criado com todas essas variáveis a serem incluídas declaradas como "capturas" e, em seguida, você pode usar o site inline_captures=True nesse método para vinculá-las. Geralmente, isso é o que você deseja se estiver construindo um circuito definindo camadas em tempo real ou reconstruindo um circuito usando camadas retiradas dele mesmo. Você pode achar o argumento vars_mode="captures" para copy_empty_like() útil para criar a base de cada camada, nesse caso.

Parâmetros

• other (qiskit.circuit.Instruction orQuantumCircuit) – (sub)circuito ou instrução para compor em si mesmo. Se não for um QuantumCircuitpode ser qualquer coisa que o append aceite.

• qubits (list[Qubit|int]) – qubits do eu para compor.

• clbits (list[Clbit|int]) – fragmentos de si mesmo para compor.

• front (bool) – Se True, a composição frontal será executada. Isso não é possível nos gerenciadores de contexto do construtor de fluxo de controle.

• inplace (bool) – Se True, modifique o objeto. Caso contrário, retorne o circuito composto.

• copy (bool) – Se for True (o padrão), a entrada será tratada como compartilhada e todas as instruções contidas serão copiadas, caso precisem ser alteradas no futuro. Você pode definir esse valor como False se a entrada for considerada propriedade do circuito base, a fim de evitar cópias desnecessárias; nesse caso, não é válido usar other posteriormente, e algumas instruções podem ter sofrido mutação no local.

• var_remap (Mapping) –

  mapeamento a ser usado para reescrever expr.Var e expr.Stretch em other à medida que são incorporados em self. Isso pode ser usado para evitar conflitos de nomes.

  Tanto as chaves quanto os valores podem ser fornecidos como cadeias de caracteres ou instâncias de identificadores diretos. Se uma chave for uma string, ela corresponderá a qualquer Var ou Stretch com o mesmo nome. Se um valor for uma string, sempre que uma nova chave corresponder a ele, um novo Var ou Stretch é criado com o tipo correto. Se um valor for um Varseu endereço type deve corresponder exatamente ao da variável que está substituindo.

• inline_captures (bool) –

  se True, então todos os nós de identificadores "capturados" no other QuantumCircuit são considerados como referentes a identificadores já declarados em self (como qualquer tipo de entrada/captura/local), e os usos em other serão aplicados aos identificadores existentes. Se você quiser criar uma camada para um circuito existente a ser usado com compose()poderá achar útil o argumento vars_mode="captures" para copy_empty_like() útil. Qualquer remapeamento em vars_remap ocorre antes da avaliação dessa variável inlining.

  Se for False (o padrão), todos os identificadores em other deverão ser distintos daqueles em self, e novas declarações serão feitas para eles.

• wrap (bool) – Se verdadeiro, envolve o outro circuito em uma porta (ou instrução, dependendo se ele contém apenas instruções unitárias) antes de compô-lo em si mesmo. Em vez de usar essa opção, quase sempre é melhor controlar isso manualmente usando to_instruction() ou to_gate()e, em seguida, chamar append().

Retorna

o circuito composto (retorna None se inplace==True).

Tipo de retorno

QuantumCircuit

Aumentos

• CircuitError - se não for possível fazer o mapeamento correto dos fios entre os dois circuitos, por exemplo, se other for mais largo que self.
• CircuitError - se tentar emitir um novo circuito enquanto self tiver um contexto de fluxo de controle parcialmente construído ativo, como as formas de gerenciador de contexto de if_test(), for_loop() e while_loop().
• CircuitError - se estiver tentando compor a parte frontal de um circuito quando um bloco construtor de fluxo de controle estiver ativo; não há um significado claro para essa ação.

Exemplos

>>> 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 com other.

Lembre-se de que, na convenção little-endian, a operação mais à esquerda estará na parte inferior do circuito. Consulte também os documentos para obter mais informações.

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

Parâmetros

• other (QuantumCircuit) – O outro circuito com o qual esse circuito deve ser tensionado.
• inplace (bool) – Se True, modifique o objeto. Caso contrário, retorne o circuito composto.

Tipo de retorno

QuantumCircuit | Nenhum

Exemplos

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')

Retorna

O circuito tensionado (retorna None se inplace=True).

Tipo de retorno

QuantumCircuit

Parâmetros

• other (QuantumCircuit)
• inplace (bool)

barrier(*qargs, label=None)

Inscreva-se em Barrier. Se qargs estiver vazio, aplica-se a todos os qubits do circuito.

Parâmetros

• qargs (QubitSpecifier) – Especificação para um ou mais argumentos de qubit.
• label (str) – O rótulo de cadeia de caracteres da barreira.

Retorna

para as instruções adicionais.

Tipo de retorno

qiskit.circuit.InstructionSet

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

Aplicar CCXGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como primeiro controle.
• control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como segundo controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CCZGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como primeiro controle.
• control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como segundo controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '10'). O padrão é o controle no estado "11".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CHGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CPhaseGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• theta (ParameterExpression |float) – O ângulo da rotação.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CRXGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• theta (ParameterExpression |float) – O ângulo da rotação.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CRYGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• theta (ParameterExpression |float) – O ângulo da rotação.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CRZGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• theta (ParameterExpression |float) – O ângulo da rotação.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CSGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CSdgGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CSwapGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controle.
• target_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• target_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado '1' .

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CSXGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CUGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• theta (ParameterExpression |float) – O $\theta$ ângulo de rotação da porta.
• phi (ParameterExpression |float) – O $\phi$ ângulo de rotação da porta.
• lam (ParameterExpression |float) – O $\lambda$ ângulo de rotação da porta.
• gamma (ParameterExpression |float) – A fase global aplicada do portão U, se aplicada.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CXGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controle.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CYGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controles.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar CZGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) utilizado(s) como controles.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) a porta se destina.
• label (str | None) – O rótulo da cadeia de caracteres da porta no circuito.
• ctrl_state (str |int | None) – O estado de controle em decimal ou como uma cadeia de bits (por exemplo, '1'). O padrão é o controle no estado "1".

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

dcx(qubit1, qubit2)

Aplicar DCXGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) aplicar a porta.
• qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – O(s) qubit(s) ao(s) qual(is) aplicar a porta.

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet

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

Aplicar Delay. Se qarg for None, aplica-se a todos os qubits. Ao aplicar a vários qubits, serão criados atrasos com a mesma duração.

Parâmetros

• duration (Object) – duração do atraso. Se for um Exprele deve ser uma expressão constante do tipo Duration.
• qarg (Object) – para aplicar esse atraso.
• unit (str | None) – unidade da duração, a menos que duration seja um Expr caso em que ela não deve ser especificada. Unidades apoiadas: 's', 'ms', 'us', 'ns', 'ps', e 'dt'. O padrão é 'dt', ou seja, uma unidade de tempo inteira, dependendo do backend de destino.

Retorna

para as instruções adicionais.

Tipo de retorno

qiskit.circuit.InstructionSet

Aumentos

CircuitError - se os argumentos tiverem um formato ruim.

ecr(qubit1, qubit2)

Aplicar ECRGate.

Para obter a forma completa da matriz dessa porta, consulte a documentação da porta subjacente.

Parâmetros

• qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Os qubits aos quais a porta será aplicada.
• qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Os qubits aos quais a porta será aplicada.

Retorna

Um identificador para as instruções criadas.

Tipo de retorno

InstructionSet