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á.
# 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.
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.
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)]
)
```
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]
)
```
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)