As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Compilar seu primeiro circuito
Depois que a instância do caderno for iniciada, abra a instância com uma interface Jupyter padrão escolhendo o caderno que você acabou de criar.
![\[Interface de notebooks mostrando uma instância de notebook existente nomeada amazon-braket-test com status InService e sua URL.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/console-page.png)
As instâncias do caderno Amazon Braket são pré-instaladas com o Amazon Braket SDK e todas as suas dependências. Comece criando um novo caderno com kernel `conda_braket`.
![\[Interface de inicialização para cadernos, console e outras ferramentas como Terminal, Arquivo de Texto, Arquivo Markdown, Arquivo Python, com o ambiente Python conda_braket destacado.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/jupyter-open.png)
Você pode começar com um simples “Olá, mundo\$1” exemplo. Primeiro, construa um circuito que prepare um estado de Bell e, em seguida, execute esse circuito em dispositivos diferentes para obter os resultados.
Comece importando o Comece importando os módulos do Amazon Braket SDK e definindo um BRAKETlong simples; módulos SDK e definindo um circuito Bell State básico.
```
import boto3
from braket.aws import AwsDevice
from braket.devices import LocalSimulator
from braket.circuits import Circuit
# Create the circuit
bell = Circuit().h(0).cnot(0, 1)
```
É possível visualizar o circuito com este comando:
```
print(bell)
```
```
T : │ 0 │ 1 │
┌───┐
q0 : ─┤ H ├───●───
└───┘ │
┌─┴─┐
q1 : ───────┤ X ├─
└───┘
T : │ 0 │ 1 │
```
**Execute seu circuito no simulador local**
Em seguida, escolha o dispositivo quântico no qual executar o circuito. O Amazon Braket SDK vem com um simulador local para prototipagem e testes rápidos. Recomendamos usar o simulador local para circuitos menores, que podem ser de até 25 qubits (dependendo do hardware local).
Para instanciar o simulador local:
```
# Instantiate the local simulator
local_sim = LocalSimulator()
```
e executar o circuito:
```
# Run the circuit
result = local_sim.run(bell, shots=1000).result()
counts = result.measurement_counts
print(counts)
```
Você deverá ver um resultado semelhante a este:
```
Counter({'11': 503, '00': 497})
```
O estado de Bell específico que você preparou é uma superposição igual de \$100⟩ e \$111⟩ e uma distribuição quase igual (até ruído shot) de 00 e 11 como resultados de medição, conforme esperado.
**Execute seu circuito em um simulador sob demanda**
O Amazon Braket também fornece acesso a um simulador SV1 de alto desempenho sob demanda para executar circuitos maiores. SV1é um simulador vetorial de estado sob demanda que permite a simulação de circuitos quânticos de até 34 qubits. Você pode encontrar mais informações SV1 na seção [Dispositivos compatíveis](braket-devices.md) e no AWS console. Ao executar tarefas quânticas em SV1 (e sobre TN1 ou em qualquer QPU), os resultados de sua tarefa quântica são armazenados em um bucket S3 em sua conta. Se você não especificar um bucket, o Braket SDK criará um bucket `amazon-braket-{region}-{accountID}` padrão para você. Para saber mais, consulte [Gerenciando o acesso ao Amazon Braket](braket-manage-access.md).
**nota**
Preencha o nome real do bucket existente, onde o exemplo a seguir aparece `amazon-braket-s3-demo-bucket` como o nome do bucket. Os nomes de bucket para Amazon Braket sempre começam com `amazon-braket-`, seguidos por outros caracteres de identificação que você adiciona. Se você precisar de informações sobre como configurar um bucket do S3, consulte [Conceitos básicos do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html).
```
# Get the account ID
aws_account_id = boto3.client("sts").get_caller_identity()["Account"]
# The name of the bucket
my_bucket = "amazon-braket-s3-demo-bucket"
# The name of the folder in the bucket
my_prefix = "simulation-output"
s3_folder = (my_bucket, my_prefix)
```
Para executar um circuito SV1, você deve fornecer a localização do bucket S3 que você selecionou anteriormente como argumento posicional na chamada `.run()`.
```
# Choose the cloud-based on-demand simulator to run your circuit
device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
# Run the circuit
task = device.run(bell, s3_folder, shots=100)
# Display the results
print(task.result().measurement_counts)
```
O console Amazon Braket fornece mais informações sobre sua tarefa quântica. Navegue até a guia **Tarefas quânticas** no console e sua tarefa quântica deve estar no topo da lista. Como alternativa, você pode pesquisar sua tarefa quântica usando o ID exclusivo da tarefa quântica ou outros critérios.
**nota**
Depois de 90 dias, o Amazon Braket remove automaticamente todas as IDs tarefas quânticas e outros metadados associados às suas tarefas quânticas. Para obter mais informações, consulte [Retenção de dados](https://docs.aws.amazon.com/braket/latest/developerguide/security.html#braket-data-retention).
**Executando em uma QPU**
Com o Amazon Braket, você pode executar o exemplo anterior de circuito quântico em um computador quântico físico alterando apenas uma única linha de código. O Amazon Braket fornece acesso a uma variedade de dispositivos de unidade de processamento quântico (QPU). Você pode encontrar informações sobre os diferentes dispositivos e janelas de disponibilidade na seção [Dispositivos compatíveis](braket-devices.md) e no AWS console, na guia **Dispositivos**. O exemplo a seguir mostra como instanciar um dispositivo IQM.
```
# Choose the IQM hardware to run your circuit
device = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")
```
Ou escolha um dispositivo IonQ com esse código:
```
# Choose the Ionq device to run your circuit
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1")
```
Depois de selecionar um dispositivo e antes de executar sua workload, você pode consultar a profundidade da fila do dispositivo com o código a seguir para determinar o número de tarefas quânticas ou trabalhos híbridos. Além disso, os clientes podem visualizar as profundidades de fila específicas do dispositivo na página Dispositivos do Amazon Braket Management Console.
```
# Print your queue depth
print(device.queue_depth().quantum_tasks)
# Returns the number of quantum tasks queued on the device
# {: '0', : '0'}
print(device.queue_depth().jobs)
# Returns the number of hybrid jobs queued on the device
# '2'
```
Quando você executa sua tarefa, o Amazon Braket SDK pesquisa um resultado (com um tempo limite padrão de 5 dias). Você pode alterar esse padrão modificando o parâmetro `poll_timeout_seconds` no comando `.run()`, conforme mostrado no exemplo a seguir. Lembre-se de que, se o tempo limite da pesquisa for muito curto, os resultados podem não ser retornados dentro do tempo da pesquisa, como quando uma QPU não está disponível e um erro de tempo limite local é retornado. Você pode reiniciar a pesquisa chamando a função `task.result()`.
```
# Define quantum task with 1 day polling timeout
task = device.run(bell, s3_folder, poll_timeout_seconds=24*60*60)
print(task.result().measurement_counts)
```
Além disso, depois de enviar sua tarefa quântica ou trabalho híbrido, você pode chamar a função `queue_position()` para verificar a posição da fila.
```
print(task.queue_position().queue_position)
# Return the number of quantum tasks queued ahead of you
# '2'
```
# Construindo seus primeiros algoritmos quânticos
A biblioteca de algoritmos Amazon Braket é um catálogo de algoritmos quânticos pré-criados escritos em Python. Execute esses algoritmos como estão ou use-os como pontos de partida para criar algoritmos mais complexos. Você pode acessar a biblioteca de algoritmos no console do Braket. Para obter mais informações, consulte a biblioteca de algoritmos do [Braket no Github.](https://github.com/aws-samples/amazon-braket-algorithm-library)
![\[A página da biblioteca de algoritmos do Amazon Braket mostra uma lista de algoritmos quânticos pré-criados, como Berstein Vazirani, Deutsch-Jozsa, algoritmo de Grover e algoritmo de otimização aproximada quântica com breves descrições.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/AlgorithmLibrary.png)
O console Braket fornece uma descrição de cada algoritmo disponível na biblioteca de algoritmos. Escolha um GitHub link para ver os detalhes de cada algoritmo ou escolha **Abrir caderno** para abrir ou criar um caderno que contenha todos os algoritmos disponíveis. Se você escolher a opção caderno, poderá encontrar a biblioteca de algoritmos Braket na pasta raiz do seu caderno.
# Construir circuitos no SDK
Esta seção fornece exemplos de definição de um circuito, visualização das portas disponíveis, extensão de um circuito e visualização das portas compatíveis por cada dispositivo. Ele também contém instruções sobre como alocar manualmente o qubits, instruir o compilador a executar seus circuitos exatamente conforme definido e criar circuitos ruidosos com um simulador de ruído.
Você também pode trabalhar no nível de pulso no Braket para várias portas, com certeza. QPUs Para obter mais informações, consulte [Controle de pulso no Amazon Braket](braket-pulse-control.md).
**Topics**
+ [
## Portas e circuitos
](#braket-gates)
+ [
## Conjuntos de programas
](#braket-program-set)
+ [
## Medição parcial
](#braket-partial-measurement)
+ [
## Alocação manual de qubit
](#manual-qubit-allocation)
+ [
## Compilação literal
](#verbatim-compilation)
+ [
## Simulação de ruído
](#noise-simulation)
## Portas e circuitos
As portas e circuitos quânticos são definidos na classe [https://github.com/aws/amazon-braket-sdk-python/blob/main/src/braket/circuits/circuit.py](https://github.com/aws/amazon-braket-sdk-python/blob/main/src/braket/circuits/circuit.py) do Amazon Braket Python SDK. No SDK, você pode instanciar um novo objeto de circuito chamando `Circuit()`.
**Exemplo: definir um circuito**
O exemplo começa definindo um circuito de amostra de quatro qubits (`q0`, `q1`, `q2` e `q3` rotulados) consistindo em portas Hadamard padrão de um qubit e portas CNOT de dois qubits. Você pode visualizar esse circuito chamando a função `print`, conforme mostra o exemplo a seguir.
```
# Import the circuit module
from braket.circuits import Circuit
# Define circuit with 4 qubits
my_circuit = Circuit().h(range(4)).cnot(control=0, target=2).cnot(control=1, target=3)
print(my_circuit)
```
```
T : │ 0 │ 1 │
┌───┐
q0 : ─┤ H ├───●─────────
└───┘ │
┌───┐ │
q1 : ─┤ H ├───┼─────●───
└───┘ │ │
┌───┐ ┌─┴─┐ │
q2 : ─┤ H ├─┤ X ├───┼───
└───┘ └───┘ │
┌───┐ ┌─┴─┐
q3 : ─┤ H ├───────┤ X ├─
└───┘ └───┘
T : │ 0 │ 1 │
```
**Exemplo: definir um circuito parametrizado**
Neste exemplo, definimos um circuito com portas que dependem de parâmetros livres. Podemos especificar os valores desses parâmetros para criar um novo circuito ou, ao enviar o circuito, para ser executado como uma tarefa quântica em determinados dispositivos.
```
from braket.circuits import Circuit, FreeParameter
# Define a FreeParameter to represent the angle of a gate
alpha = FreeParameter("alpha")
# Define a circuit with three qubits
my_circuit = Circuit().h(range(3)).cnot(control=0, target=2).rx(0, alpha).rx(1, alpha)
print(my_circuit)
```
Você pode criar um novo circuito não parametrizado a partir de um parametrizado fornecendo um único `float` (que é o valor que todos os parâmetros livres terão) ou argumentos de palavra-chave especificando o valor de cada parâmetro para o circuito da seguinte forma.
```
my_fixed_circuit = my_circuit(1.2)
my_fixed_circuit = my_circuit(alpha=1.2)
print(my_fixed_circuit)
```
Observe que `my_circuit` não foi modificado, então você pode usá-lo para instanciar muitos novos circuitos com valores de parâmetros fixos.
**Exemplo: Modificar portas em um circuito**
O exemplo a seguir define um circuito com portas que usam modificadores de controle e potência. Você pode usar essas modificações para criar novas portas, como a porta `Ry` controlada.
```
from braket.circuits import Circuit
# Create a bell circuit with a controlled x gate
my_circuit = Circuit().h(0).x(control=0, target=1)
# Add a multi-controlled Ry gate of angle .13
my_circuit.ry(angle=.13, target=2, control=(0, 1))
# Add a 1/5 root of X gate
my_circuit.x(0, power=1/5)
print(my_circuit)
```
Os modificadores de porta são suportados somente no simulador local.
**Exemplo: Veja todos as postas disponíveis**
O exemplo a seguir mostra como analisar todas as portas disponíveis no Amazon Braket.
```
from braket.circuits import Gate
# Print all available gates in Amazon Braket
gate_set = [attr for attr in dir(Gate) if attr[0].isupper()]
print(gate_set)
```
A saída desse código lista todas as portas.
```
['CCNot', 'CNot', 'CPhaseShift', 'CPhaseShift00', 'CPhaseShift01', 'CPhaseShift10', 'CSwap', 'CV', 'CY', 'CZ', 'ECR', 'GPhase', 'GPi', 'GPi2', 'H', 'I', 'ISwap', 'MS', 'PRx', 'PSwap', 'PhaseShift', 'PulseGate', 'Rx', 'Ry', 'Rz', 'S', 'Si', 'Swap', 'T', 'Ti', 'U', 'Unitary', 'V', 'Vi', 'X', 'XX', 'XY', 'Y', 'YY', 'Z', 'ZZ']
```
Qualquer uma dessas portas pode ser anexada a um circuito chamando o método para esse tipo de circuito. Por exemplo, chame `circ.h(0)` para adicionar uma porta Hadamard ao primeiro qubit.
**nota**
As portas são anexadas e o exemplo a seguir adiciona todas as portas listadas no exemplo anterior ao mesmo circuito.
```
circ = Circuit()
# toffoli gate with q0, q1 the control qubits and q2 the target.
circ.ccnot(0, 1, 2)
# cnot gate
circ.cnot(0, 1)
# controlled-phase gate that phases the |11> state, cphaseshift(phi) = diag((1,1,1,exp(1j*phi))), where phi=0.15 in the examples below
circ.cphaseshift(0, 1, 0.15)
# controlled-phase gate that phases the |00> state, cphaseshift00(phi) = diag([exp(1j*phi),1,1,1])
circ.cphaseshift00(0, 1, 0.15)
# controlled-phase gate that phases the |01> state, cphaseshift01(phi) = diag([1,exp(1j*phi),1,1])
circ.cphaseshift01(0, 1, 0.15)
# controlled-phase gate that phases the |10> state, cphaseshift10(phi) = diag([1,1,exp(1j*phi),1])
circ.cphaseshift10(0, 1, 0.15)
# controlled swap gate
circ.cswap(0, 1, 2)
# swap gate
circ.swap(0,1)
# phaseshift(phi)= diag([1,exp(1j*phi)])
circ.phaseshift(0,0.15)
# controlled Y gate
circ.cy(0, 1)
# controlled phase gate
circ.cz(0, 1)
# Echoed cross-resonance gate applied to q0, q1
circ = Circuit().ecr(0,1)
# X rotation with angle 0.15
circ.rx(0, 0.15)
# Y rotation with angle 0.15
circ.ry(0, 0.15)
# Z rotation with angle 0.15
circ.rz(0, 0.15)
# Hadamard gates applied to q0, q1, q2
circ.h(range(3))
# identity gates applied to q0, q1, q2
circ.i([0, 1, 2])
# iswap gate, iswap = [[1,0,0,0],[0,0,1j,0],[0,1j,0,0],[0,0,0,1]]
circ.iswap(0, 1)
# pswap gate, PSWAP(phi) = [[1,0,0,0],[0,0,exp(1j*phi),0],[0,exp(1j*phi),0,0],[0,0,0,1]]
circ.pswap(0, 1, 0.15)
# X gate applied to q1, q2
circ.x([1, 2])
# Y gate applied to q1, q2
circ.y([1, 2])
# Z gate applied to q1, q2
circ.z([1, 2])
# S gate applied to q0, q1, q2
circ.s([0, 1, 2])
# conjugate transpose of S gate applied to q0, q1
circ.si([0, 1])
# T gate applied to q0, q1
circ.t([0, 1])
# conjugate transpose of T gate applied to q0, q1
circ.ti([0, 1])
# square root of not gate applied to q0, q1, q2
circ.v([0, 1, 2])
# conjugate transpose of square root of not gate applied to q0, q1, q2
circ.vi([0, 1, 2])
# exp(-iXX theta/2)
circ.xx(0, 1, 0.15)
# exp(i(XX+YY) theta/4), where theta=0.15 in the examples below
circ.xy(0, 1, 0.15)
# exp(-iYY theta/2)
circ.yy(0, 1, 0.15)
# exp(-iZZ theta/2)
circ.zz(0, 1, 0.15)
# IonQ native gate GPi with angle 0.15 applied to q0
circ.gpi(0, 0.15)
# IonQ native gate GPi2 with angle 0.15 applied to q0
circ.gpi2(0, 0.15)
# IonQ native gate MS with angles 0.15, 0.15, 0.15 applied to q0, q1
circ.ms(0, 1, 0.15, 0.15, 0.15)
```
Além do conjunto de portas predefinido, você também pode aplicar portas unitárias autodefinidas ao circuito. Elas podem ser portas de um único qubit (conforme mostrado no código-fonte a seguir) ou portas de vários qubits aplicadas ao qubits definido pelo parâmetro `targets`.
```
import numpy as np
# Apply a general unitary
my_unitary = np.array([[0, 1],[1, 0]])
circ.unitary(matrix=my_unitary, targets=[0])
```
**Exemplo: Estenda os circuitos existentes**
Você pode estender os circuitos existentes adicionando instruções. Um `Instruction` é uma diretiva quântica que descreve a tarefa quântica a ser executada em um dispositivo quântico. Operadores `Instruction` incluem somente objetos do tipo `Gate`.
```
# Import the Gate and Instruction modules
from braket.circuits import Gate, Instruction
# Add instructions directly.
circ = Circuit([Instruction(Gate.H(), 4), Instruction(Gate.CNot(), [4, 5])])
# Or with add_instruction/add functions
instr = Instruction(Gate.CNot(), [0, 1])
circ.add_instruction(instr)
circ.add(instr)
# Specify where the circuit is appended
circ.add_instruction(instr, target=[3, 4])
circ.add_instruction(instr, target_mapping={0: 3, 1: 4})
# Print the instructions
print(circ.instructions)
# If there are multiple instructions, you can print them in a for loop
for instr in circ.instructions:
print(instr)
# Instructions can be copied
new_instr = instr.copy()
# Appoint the instruction to target
new_instr = instr.copy(target=[5, 6])
new_instr = instr.copy(target_mapping={0: 5, 1: 6})
```
**Exemplo: veja as portas que cada dispositivo suporta**
Os simuladores oferecem suporte a todas as portas no SDK do Braket, mas os dispositivos QPU oferecem suporte a um subconjunto menor. Você pode encontrar as portas compatíveis de um dispositivo nas propriedades do dispositivo. O exemplo a seguir mostra um exemplo de um dispositivo IonQ:
```
# Import the device module
from braket.aws import AwsDevice
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1")
# Get device name
device_name = device.name
# Show supportedQuantumOperations (supported gates for a device)
device_operations = device.properties.dict()['action']['braket.ir.openqasm.program']['supportedOperations']
print('Quantum Gates supported by {}:\n {}'.format(device_name, device_operations))
```
```
Quantum Gates supported by Aria 1:
['x', 'y', 'z', 'h', 's', 'si', 't', 'ti', 'v', 'vi', 'rx', 'ry', 'rz', 'cnot', 'swap', 'xx', 'yy', 'zz']
```
As portas compatíveis talvez precisem ser compiladas em portas nativas antes de poderem ser executadas em hardware quântico. Quando você envia um circuito, o Amazon Braket executa essa compilação automaticamente.
**Exemplo: recupere programaticamente a fidelidade das portas nativas compatíveis por um dispositivo**
Você pode ver as informações de fidelidade na página **Dispositivos** do console Braket. Às vezes, é útil acessar as mesmas informações programaticamente. O código a seguir mostra como extrair a fidelidade de duas portas qubit entre duas portas de uma QPU.
```
# Import the device module
from braket.aws import AwsDevice
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
# Specify the qubits
a=10
b=11
edge_properties_entry = device.properties.standardized.twoQubitProperties['10-11'].twoQubitGateFidelity
gate_name = edge_properties_entry[0].gateName
fidelity = edge_properties_entry[0].fidelity
print(f"Fidelity of the {gate_name} gate between qubits {a} and {b}: {fidelity}")
```
## Conjuntos de programas
Os conjuntos de programas executam com eficiência vários circuitos quânticos em uma única tarefa quântica. Nessa tarefa, você pode enviar até 100 circuitos quânticos ou um único circuito paramétrico com até 100 conjuntos de parâmetros diferentes. Essa operação minimiza o tempo entre as execuções subsequentes do circuito e reduz a sobrecarga de processamento de tarefas quânticas. Atualmente, os conjuntos de programas são compatíveis com o Amazon Local Simulator Braket e outros AQT dispositivosIQM. Rigetti
**Definindo um ProgramSet**
O primeiro exemplo de código a seguir demonstra como construir um `ProgramSet` usando circuitos parametrizados e circuitos sem parâmetros.
```
from braket.aws import AwsDevice
from braket.circuits import Circuit, FreeParameter
from braket.program_sets.circuit_binding import CircuitBinding
from braket.program_sets import ProgramSet
# Initialize the quantum device
device = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")
# Define circuits
circ1 = Circuit().h(0).cnot(0, 1)
circ2 = Circuit().rx(0, 0.785).ry(1, 0.393).cnot(1, 0)
circ3 = Circuit().t(0).t(1).cz(0, 1).s(0).cz(1, 2).s(1).s(2)
parameterize_circuit = Circuit().rx(0, FreeParameter("alpha")).cnot(0, 1).ry(1, FreeParameter("beta"))
# Create circuit bindings with different parameters
circuit_binding = CircuitBinding(
circuit=parameterize_circuit,
input_sets={
'alpha': (0.10, 0.11, 0.22, 0.34, 0.45),
'beta': (1.01, 1.01, 1.03, 1.04, 1.04),
})
# Creating the program set
program_set_1 = ProgramSet([
circ1,
circ2,
circ3,
circuit_binding,
])
```
Esse conjunto de programas contém quatro programas exclusivos: `circ1`, `circ2`, `circ3` e `circuit_binding`. O programa `circuit_binding` é executado com cinco associações de parâmetros diferentes, criando cinco executáveis. Os outros três programas sem parâmetros criam um executável cada. Isso resulta em um total de oito executáveis, conforme mostrado na imagem a seguir.
![\[ProgramSet estrutura com quatro circuitos, onde c4 usa CircuitBinding para processar cinco conjuntos de entrada.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/program_set1.png)
O segundo exemplo de código a seguir demonstra como usar o método `product()` para anexar o mesmo conjunto de observáveis a cada executável do conjunto de programas.
```
from braket.circuits.observables import I, X, Y, Z
observables = [Z(0) @ Z(1), X(0) @ X(1), Z(0) @ X(1), X(0) @ Z(1)]
program_set_2 = ProgramSet.product(
circuits=[circ1, circ2, circuit_binding],
observables=observables
)
```
Para programas sem parâmetros, cada observável é medido para cada circuito. Para programas paramétricos, cada observável é medido para cada conjunto de entrada, conforme mostrado na imagem a seguir.
![\[ProgramSet.product mostrando a execução paralela de três circuitos, com c3 sendo usado CircuitBinding para processar cinco conjuntos de entrada com cinco observáveis cada.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/program_set2.png)
O terceiro exemplo de código a seguir demonstra como usar o método `zip()` para emparelhar observáveis individuais com conjuntos de parâmetros específicos no `ProgramSet`.
```
program_set_3 = ProgramSet.zip(
circuits=circuit_binding,
observables=observables + [Y(0) @ Y(1)]
)
```
![\[ProgramSet.zip com CircuitBinding demonstração de cinco execuções paralelas usando um circuito compartilhado com observável individual por conjunto de entrada.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/program_set3.png)
Em vez do `CircuitBinding()`, você pode compactar diretamente uma lista de observáveis com uma lista de circuitos e conjuntos de entrada.
```
program_set_4 = ProgramSet.zip(
circuits=[circ1, circ2, circ3],
input_sets=[{}, {}, {}],
observables=observables[:3]
)
```
![\[ProgramSet.zip mostrando a execução paralela de sete circuitos com seu conjunto de entrada individual correspondente e observáveis individuais.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/program_set4.png)
Para obter mais informações e exemplos sobre conjuntos de programas, consulte a [pasta Conjunto de programas](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/braket_features/program_sets) no amazon-braket-examples Github.
**Inspecione e execute um conjunto de programas em um dispositivo**
A contagem de executáveis de um conjunto de programas é igual ao número de circuitos exclusivos vinculados a parâmetros. Calcule o número total de executáveis e disparos do circuito usando o exemplo de código a seguir.
```
# Number of shots per executable
shots = 10
num_executables = program_set_1.total_executables
# Calculate total number of shots across all executables
total_num_shots = shots*num_executables
```
**nota**
Com conjuntos de programas, você paga uma taxa única por tarefa e uma taxa por tiro com base no número total de disparos em todos os circuitos em um conjunto de programas.
Para executar o conjunto de programas, use o exemplo de código a seguir.
```
# Run the program set
task = device.run(
program_set_1, shots=total_num_shots,
)
```
Ao usar dispositivos Rigetti, seu conjunto de programas pode permanecer no estado `RUNNING` enquanto as tarefas estão parcialmente concluídas e parcialmente enfileiradas. Para obter resultados mais rápidos, considere enviar seu programa definido como um [Hybrid Job](braket-jobs-first.md).
**Analisando resultados**
Execute o código a seguir para analisar e medir os resultados dos executáveis em um `ProgramSet`.
```
# Get the results from a program set
result = task.result()
# Get the first executbable
first_program = result[0]
first_executable = first_program[0]
# Inspect the results of the first executable
measurements_from_first_executable = first_executable.measurements
print(measurements_from_first_executable)
```
## Medição parcial
Em vez de medir todos os qubits em um circuito quântico, use a medição parcial para medir qubits individuais ou um subconjunto de qubits.
**nota**
Recursos adicionais, como medição de circuito médio e operações de avanço, estão disponíveis como capacidades experimentais, consulte [Acesso a circuitos dinâmicos em dispositivos IQM](braket-experimental-capabilities.md#braket-access-dynamic-circuits).
**Exemplo: medir um subconjunto de qubits**
O exemplo de código a seguir demonstra a medição parcial medindo somente o qubit 0 em um circuito de estado Bell.
```
from braket.devices import LocalSimulator
from braket.circuits import Circuit
# Use the local state vector simulator
device = LocalSimulator()
# Define an example bell circuit and measure qubit 0
circuit = Circuit().h(0).cnot(0, 1).measure(0)
# Run the circuit
task = device.run(circuit, shots=10)
# Get the results
result = task.result()
# Print the circuit and measured qubits
print(circuit)
print()
print("Measured qubits: ", result.measured_qubits)
```
## Alocação manual de qubit
Ao executar um circuito quântico em computadores quânticos a partir do Rigetti, você pode, opcionalmente, usar a alocação manual de qubit para controlar quais qubits são usados em seu algoritmo. O [Amazon Braket Console](https://console.aws.amazon.com/braket/home) e o [Amazon Braket SDK](https://github.com/aws/amazon-braket-sdk-python) ajudam você a inspecionar os dados de calibração mais recentes do dispositivo de unidade de processamento quântico (QPU) selecionado, para que você possa selecionar o melhor para seu experimento de qubits.
A alocação manual de qubit permite que você execute circuitos com maior precisão e investigue propriedades de qubit individuais. Pesquisadores e usuários avançados otimizam o projeto do circuito com base nos dados mais recentes de calibração do dispositivo e podem obter resultados mais precisos.
O exemplo a seguir demonstra como alocar qubits de forma explícita.
```
# Import the device module
from braket.aws import AwsDevice
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
circ = Circuit().h(0).cnot(0, 7) # Indices of actual qubits in the QPU
# Set up S3 bucket (where results are stored)
my_bucket = "amazon-braket-s3-demo-bucket" # The name of the bucket
my_prefix = "your-folder-name" # The name of the folder in the bucket
s3_location = (my_bucket, my_prefix)
my_task = device.run(circ, s3_location, shots=100, disable_qubit_rewiring=True)
```
Para obter mais informações, consulte [os exemplos do Amazon Braket GitHub](https://github.com/aws/amazon-braket-examples) em, ou mais especificamente, neste notebook[: Alocação de qubits em dispositivos QPU](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Allocating_Qubits_on_QPU_Devices.ipynb).
## Compilação literal
Quando você executa um circuito quântico em computadores quânticos baseados em portas, você pode direcionar o compilador para executar seus circuitos exatamente como definido, sem nenhuma modificação. Usando a compilação literal, você pode especificar que um circuito inteiro seja preservado com precisão conforme especificado ou que somente partes específicas dele sejam preservadas (compatíveis somente pelo Rigetti). Ao desenvolver algoritmos para benchmarking de hardware ou protocolos de mitigação de erros, você precisa ter a opção de especificar exatamente as portas e os layouts de circuito que estão sendo executados no hardware. A compilação integral oferece controle direto sobre o processo de compilação, desativando determinadas etapas de otimização, garantindo assim que seus circuitos funcionem exatamente como projetado.
A compilação literal é suportada nos Rigetti dispositivosAQT, IonQIQM, e e requer o uso de portas nativas. Ao usar a compilação literal, é aconselhável verificar a topologia do dispositivo para garantir que as portas sejam chamadas a qubits conectados e que o circuito use as portas nativas compatíveis no hardware. O exemplo a seguir mostra como acessar programática a lista de portas nativas compatíveis com um dispositivo.
```
device.properties.paradigm.nativeGateSet
```
Para Rigetti, a reconexão qubit deve ser desativada configurando `disableQubitRewiring=True` para uso com compilação literal. Se `disableQubitRewiring=False` for definido ao usar caixas textuais em uma compilação, o circuito quântico falha na validação e não será executado.
Se a compilação literal estiver habilitada para um circuito e executada em uma QPU não compatível, um erro é gerado indicando que uma operação não comptatível causou a falha da tarefa. À medida que mais hardware quântico oferece suporte nativo às funções do compilador, esse recurso será expandido para incluir esses dispositivos. Os dispositivos que oferecem suporte à compilação literal a incluem como uma operação compatível quando consultados com o código a seguir.
```
from braket.aws import AwsDevice
from braket.device_schema.device_action_properties import DeviceActionType
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
device.properties.action[DeviceActionType.OPENQASM].supportedPragmas
```
Não há custo adicional associado ao uso da compilação literal. Você continua sendo cobrado por tarefas quânticas executadas em dispositivos Braket QPU, instâncias de caderno e simuladores sob demanda com base nas taxas atuais, conforme especificado na página de [preços do Amazon Braket](https://aws.amazon.com/braket/pricing/). Para obter mais informações, consulte o exemplo de [caderno de compilação literal](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Verbatim_Compilation.ipynb).
**nota**
Se você estiver usando o OpenQASM para escrever seus circuitos para os IonQ dispositivos AQT e quiser mapear seu circuito diretamente para os qubits físicos, precisará usar o, `#pragma braket verbatim` pois o `disableQubitRewiring` sinalizador é ignorado pelo OpenQASM.
## Simulação de ruído
Para instanciar o simulador de ruído local, você pode alterar o backend da seguinte maneira.
```
# Import the device module
from braket.aws import AwsDevice
device = LocalSimulator(backend="braket_dm")
```
É possível fazer circuitos ruidosos de duas maneiras:
1. Construa o circuito ruidoso de baixo para cima.
1. Pegue um circuito existente e livre de ruído e injete ruído por toda parte.
O exemplo a seguir mostra as abordagens usando um circuito básico com ruído despolarizador e um canal Kraus personalizado.
```
import scipy.stats
import numpy as np
# Bottom up approach
# Apply depolarizing noise to qubit 0 with probability of 0.1
circ = Circuit().x(0).x(1).depolarizing(0, probability=0.1)
# Create an arbitrary 2-qubit Kraus channel
E0 = scipy.stats.unitary_group.rvs(4) * np.sqrt(0.8)
E1 = scipy.stats.unitary_group.rvs(4) * np.sqrt(0.2)
K = [E0, E1]
# Apply a two-qubit Kraus channel to qubits 0 and 2
circ = circ.kraus([0, 2], K)
```
```
from braket.circuits import Noise
# Inject noise approach
# Define phase damping noise
noise = Noise.PhaseDamping(gamma=0.1)
# The noise channel is applied to all the X gates in the circuit
circ = Circuit().x(0).y(1).cnot(0, 2).x(1).z(2)
circ_noise = circ.copy()
circ_noise.apply_gate_noise(noise, target_gates=Gate.X)
```
Executar um circuito é a mesma experiência de usuário de antes, conforme mostrado nos dois exemplos a seguir.
**Exemplo 1**
```
task = device.run(circ, shots=100)
```
Ou
**Exemplo 2**
```
task = device.run(circ_noise, shots=100)
```
Para obter mais exemplos, consulte o [exemplo introdutório do simulador de ruído do Braket](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Simulating_Noise_On_Amazon_Braket.ipynb)
# Inspecionando o circuito
Os circuitos quânticos no Amazon Braket têm um conceito de pseudotempo chamado `Moments`. Cada qubit pode experimentar uma única porta por `Moment`. O objetivo do `Moments` é facilitar o endereçamento dos circuitos e suas portas e fornecer uma estrutura temporal.
**nota**
Os momentos geralmente não correspondem ao tempo real em que as portas são executadas em uma QPU.
A profundidade de um circuito é dada pelo número total de momentos nesse circuito. É possível visualizar a profundidade do circuito chamando o método `circuit.depth` conforme mostrado no exemplo a seguir.
```
from braket.circuits import Circuit
# Define a circuit with parametrized gates
circ = Circuit().rx(0, 0.15).ry(1, 0.2).cnot(0, 2).zz(1, 3, 0.15).x(0)
print(circ)
print('Total circuit depth:', circ.depth)
```
```
T : │ 0 │ 1 │ 2 │
┌──────────┐ ┌───┐
q0 : ─┤ Rx(0.15) ├───●────────────────┤ X ├─
└──────────┘ │ └───┘
┌──────────┐ │ ┌──────────┐
q1 : ─┤ Ry(0.20) ├───┼───┤ ZZ(0.15) ├───────
└──────────┘ │ └────┬─────┘
┌─┴─┐ │
q2 : ──────────────┤ X ├──────┼─────────────
└───┘ │
┌────┴─────┐
q3 : ────────────────────┤ ZZ(0.15) ├───────
└──────────┘
T : │ 0 │ 1 │ 2 │
Total circuit depth: 3
```
A profundidade total do circuito acima é 3 (mostrada como momentos `0`, `1` e`2`). Você pode verificar a operação da porta a cada momento.
`Moments` funciona como um dicionário de pares de *valores-chave*.
+ A chave é `MomentsKey()`, que contém pseudotempo e informações do qubit.
+ O valor é atribuído no tipo de `Instructions()`.
```
moments = circ.moments
for key, value in moments.items():
print(key)
print(value, "\n")
```
```
MomentsKey(time=0, qubits=QubitSet([Qubit(0)]), moment_type=, noise_index=0, subindex=0)
Instruction('operator': Rx('angle': 0.15, 'qubit_count': 1), 'target': QubitSet([Qubit(0)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)
MomentsKey(time=0, qubits=QubitSet([Qubit(1)]), moment_type=, noise_index=0, subindex=0)
Instruction('operator': Ry('angle': 0.2, 'qubit_count': 1), 'target': QubitSet([Qubit(1)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)
MomentsKey(time=1, qubits=QubitSet([Qubit(0), Qubit(2)]), moment_type=, noise_index=0, subindex=0)
Instruction('operator': CNot('qubit_count': 2), 'target': QubitSet([Qubit(0), Qubit(2)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)
MomentsKey(time=1, qubits=QubitSet([Qubit(1), Qubit(3)]), moment_type=, noise_index=0, subindex=0)
Instruction('operator': ZZ('angle': 0.15, 'qubit_count': 2), 'target': QubitSet([Qubit(1), Qubit(3)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)
MomentsKey(time=2, qubits=QubitSet([Qubit(0)]), moment_type=, noise_index=0, subindex=0)
Instruction('operator': X('qubit_count': 1), 'target': QubitSet([Qubit(0)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)
```
Você também pode adicionar portas a um circuito `Moments`.
```
from braket.circuits import Instruction, Gate
new_circ = Circuit()
instructions = [Instruction(Gate.S(), 0),
Instruction(Gate.CZ(), [1, 0]),
Instruction(Gate.H(), 1)
]
new_circ.moments.add(instructions)
print(new_circ)
```
```
T : │ 0 │ 1 │ 2 │
┌───┐ ┌───┐
q0 : ─┤ S ├─┤ Z ├───────
└───┘ └─┬─┘
│ ┌───┐
q1 : ─────────●───┤ H ├─
└───┘
T : │ 0 │ 1 │ 2 │
```
# Lista de tipos de resultados
O Amazon Braket pode retornar diferentes tipos de resultados quando um circuito é medido usando o `ResultType`. Um circuito pode retornar os seguintes tipos de resultados.
+ `AdjointGradient` retorna o gradiente (derivada vetorial) do valor esperado de um observável fornecido. Esse observável está agindo em um alvo fornecido em relação aos parâmetros especificados usando o método de diferenciação adjunta. Você só pode usar esse método quando tiros = 0.
+ `Amplitude` retorna a amplitude dos estados quânticos especificados na função de onda de saída. Ele está disponível somente nos simuladores locais SV1 e nos simuladores.
+ `Expectation` retorna o valor esperado de um determinado observável, que pode ser especificado com a classe `Observable` apresentada posteriormente neste capítulo. O alvo qubits usado para medir o observável deve ser especificado e o número de alvos especificados deve ser igual ao número qubits sobre o qual o observável atua. Se nenhum alvo for especificado, o observável deve operar somente em 1 qubit e é aplicado a todos os qubits em paralelo.
+ `Probability` retorna as probabilidades de medir os estados de base computacional. Se nenhuma meta for especificada, `Probability` retorna a probabilidade de medir todos os estados básicos. Se os alvos forem especificados, somente as probabilidades marginais dos vetores básicos nos qubits especificados serão retornadas. Os simuladores gerenciados QPUs estão limitados a 15 qubits no máximo, e os simuladores locais estão limitados ao tamanho da memória do sistema.
+ `Reduced density matrix` retorna uma matriz de densidade para um subsistema de qubits de destino especificado de um sistema de qubits. Para limitar o tamanho desse tipo de resultado, o Braket limita o número de alvos qubits a um máximo de 8.
+ `StateVector` retorna o vetor de estado completo. Ele está disponível no simulador local.
+ `Sample` retorna as contagens de medição de um alvo qubit especificado definido e observável. Se nenhum alvo for especificado, o observável deve operar somente em 1 qubit e é aplicado a todos os qubits em paralelo. Se os alvos forem especificados, o número de alvos especificados deverá ser igual ao número de qubits sobre os quais o observável atua.
+ `Variance` retorna a variância (`mean([x-mean(x)]2)`) do conjunto qubit de destino especificado e observável como o tipo de resultado solicitado. Se nenhum alvo for especificado, o observável deve operar somente em 1 qubit e é aplicado a todos os qubits em paralelo. Caso contrário, o número de alvos especificados deve ser igual ao número qubits ao qual o observável pode ser aplicado.
**Os tipos de resultados compatíveis para diferentes provedores:**
| | | | | | | | | |
| --- |--- |--- |--- |--- |--- |--- |--- |--- |
| | sim local | SV1 | DM1 | TN1 | AQT | IonQ | IQM | Rigetti |
| Gradiente adjunto | N | S | N | N | N | N | N | N |
| Amplitude | S | S | N | N | N | N | N | N |
| Expectativa | S | S | S | S | S | S | S | S |
| Probabilidade | S | S | S | N | S | S | S | S |
| Matriz de densidade reduzida | S | N | S | N | N | N | N | N |
| Vetor de estado | S | N | N | N | N | N | N | N |
| Amostra | S | S | S | S | S | S | S | S |
| Variação | S | S | S | S | S | S | S | S |
É possível verificar os tipos de resultados compatíveis ao examinar as propriedades do dispositivo, conforme mostrado no exemplo a seguir.
```
from braket.aws import AwsDevice
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
# Print the result types supported by this device
for iter in device.properties.action['braket.ir.openqasm.program'].supportedResultTypes:
print(iter)
```
```
name='Sample' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Expectation' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Variance' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Probability' observables=None minShots=10 maxShots=50000
```
Para chamar `ResultType`, anexe-o a um circuito, conforme mostrado no exemplo a seguir.
```
from braket.circuits import Circuit, Observable
circ = Circuit().h(0).cnot(0, 1).amplitude(state=["01", "10"])
circ.probability(target=[0, 1])
circ.probability(target=0)
circ.expectation(observable=Observable.Z(), target=0)
circ.sample(observable=Observable.X(), target=0)
circ.state_vector()
circ.variance(observable=Observable.Z(), target=0)
# Print one of the result types assigned to the circuit
print(circ.result_types[0])
```
**nota**
Diferentes dispositivos quânticos fornecem resultados em vários formatos. Por exemplo, os dispositivos Rigetti retornam medições, enquanto os dispositivos IonQ fornecem probabilidades. O Amazon Braket SDK oferece uma propriedade de medidas para todos os resultados. No entanto, para dispositivos que retornam probabilidades, essas medidas são pós-computadas e baseadas nas probabilidades, pois as medições por disparo não estão disponíveis. Para determinar se um resultado foi pós-computado, verifique `measurements_copied_from_device` no objeto resultante. Essa operação está detalhada no arquivo [gate\$1model\$1quantum\$1task\$1result.py](https://github.com/aws/amazon-braket-sdk-python/blob/ca5b08dada4839ca31c012ff50aa20b656fd1879/src/braket/tasks/gate_model_quantum_task_result.py#L70-L72) no repositório Amazon Braket SDK GitHub .
## Observáveis
A classe `Observable` do Amazon Braket permite medir um observável específico.
Você pode aplicar somente uma única não identidade observável a cada qubit. Ocorre um erro se você especificar dois ou mais observáveis sem identidade diferentes para o mesmo qubit. Para isso, cada fator de um produto tensorial conta como um indivíduo observável. Isso significa que você pode ter vários produtos tensoriais no mesmo qubit, desde que os fatores que atuam sobre o qubit permaneçam os mesmos.
Um observável pode ser escalado e adicionar outros observáveis (escalonados ou não). Isso cria um `Sum` que pode ser usado no tipo de resultado `AdjointGradient`.
A classe `Observable` inclui os seguintes observáveis.
```
import numpy as np
Observable.I()
Observable.H()
Observable.X()
Observable.Y()
Observable.Z()
# Get the eigenvalues of the observable
print("Eigenvalue:", Observable.H().eigenvalues)
# Or rotate the basis to be computational basis
print("Basis rotation gates:", Observable.H().basis_rotation_gates)
# Get the tensor product of the observable for the multi-qubit case
tensor_product = Observable.Y() @ Observable.Z()
# View the matrix form of an observable by using
print("The matrix form of the observable:\n", Observable.Z().to_matrix())
print("The matrix form of the tensor product:\n", tensor_product.to_matrix())
# Factorize an observable in the tensor form
print("Factorize an observable:", tensor_product.factors)
# Self-define observables, given it is a Hermitian
print("Self-defined Hermitian:", Observable.Hermitian(matrix=np.array([[0, 1], [1, 0]])))
print("Sum of other (scaled) observables:", 2.0 * Observable.X() @ Observable.X() + 4.0 * Observable.Z() @ Observable.Z())
```
```
Eigenvalue: [ 1. -1.]
Basis rotation gates: (Ry('angle': -0.7853981633974483, 'qubit_count': 1),)
The matrix form of the observable:
[[ 1.+0.j 0.+0.j]
[ 0.+0.j -1.+0.j]]
The matrix form of the tensor product:
[[ 0.+0.j 0.+0.j 0.-1.j 0.+0.j]
[ 0.+0.j -0.+0.j 0.+0.j 0.+1.j]
[ 0.+1.j 0.+0.j 0.+0.j 0.+0.j]
[ 0.+0.j 0.-1.j 0.+0.j -0.+0.j]]
Factorize an observable: (Y('qubit_count': 1), Z('qubit_count': 1))
Self-defined Hermitian: Hermitian('qubit_count': 1, 'matrix': [[0.+0.j 1.+0.j], [1.+0.j 0.+0.j]])
Sum of other (scaled) observables: Sum(TensorProduct(X('qubit_count': 1), X('qubit_count': 1)), TensorProduct(Z('qubit_count': 1), Z('qubit_count': 1)))
```
## Parâmetros
Os circuitos podem incorporar parâmetros livres. Esses parâmetros livres só precisam ser construídos uma vez para serem executados várias vezes e podem ser usados para calcular gradientes.
Cada parâmetro livre usa um nome codificado em string que é usado para:
+ Definir valores do parâmetro
+ Identificar quais parâmetros usar
```
from braket.circuits import Circuit, FreeParameter, observables
from braket.parametric import FreeParameter
theta = FreeParameter("theta")
phi = FreeParameter("phi")
circ = Circuit().h(0).rx(0, phi).ry(0, phi).cnot(0, 1).xx(0, 1, theta)
```
## Gradiente adjunto
O dispositivo SV1 calcula o gradiente adjunto de um valor esperado observável, incluindo hamiltoniano de vários termos. Para diferenciar os parâmetros, especifique seu nome (em formato de string) ou por referência direta.
```
from braket.aws import AwsDevice
from braket.devices import Devices
device = AwsDevice(Devices.Amazon.SV1)
circ.adjoint_gradient(observable=3 * Observable.Z(0) @ Observable.Z(1) - 0.5 * observables.X(0), parameters = ["phi", theta])
```
Passar valores de parâmetros fixos como argumentos para um circuito parametrizado removerá os parâmetros livres. Executar esse circuito com `AdjointGradient` produz um erro, porque os parâmetros livres não existem mais. O exemplo de código a seguir demonstra o uso correto e incorreto:
```
# Will error, as no free parameters will be present
#device.run(circ(0.2), shots=0)
# Will succeed
device.run(circ, shots=0, inputs={'phi': 0.2, 'theta': 0.2})
```