Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Elenco dei tipi di risultati
Amazon Braket può restituire diversi tipi di risultati quando un circuito viene misurato utilizzando. `ResultType` Un circuito può restituire i seguenti tipi di risultati.
+ `AdjointGradient`restituisce il gradiente (derivata vettoriale) del valore atteso di un osservabile fornito. Questo osservabile agisce su un obiettivo fornito rispetto a parametri specificati utilizzando il metodo di differenziazione adjoint. Puoi usare questo metodo solo quando shots=0.
+ `Amplitude`restituisce l'ampiezza degli stati quantistici specificati nella funzione d'onda di uscita. È disponibile solo sui simulatori SV1 e sui simulatori locali.
+ `Expectation`restituisce il valore di aspettativa di un dato osservabile, che può essere specificato con la `Observable` classe introdotta più avanti in questo capitolo. L'obiettivo qubits utilizzato per misurare l'osservabile deve essere specificato e il numero di obiettivi specificati deve essere uguale al numero qubits su cui agisce l'osservabile. Se non viene specificato alcun obiettivo, l'osservabile deve operare solo su 1 qubit e viene applicato a tutti qubits in parallelo.
+ `Probability`restituisce le probabilità di misurare gli stati di base computazionali. Se non viene specificato alcun obiettivo, `Probability` restituisce la probabilità di misurare tutti gli stati di base. Se vengono specificati obiettivi, vengono restituite solo le probabilità marginali dei vettori di base sull'oggetto specificatoqubits. I simulatori gestiti QPUs sono limitati a un massimo di 15 qubit, mentre i simulatori locali sono limitati alla dimensione della memoria del sistema.
+ `Reduced density matrix`restituisce una matrice di densità per un sottosistema di un obiettivo qubits specificato da un sistema di. qubits Per limitare la dimensione di questo tipo di risultato, Braket limita il numero di obiettivi qubits a un massimo di 8.
+ `StateVector`restituisce il vettore di stato completo. È disponibile sul simulatore locale.
+ `Sample`restituisce i conteggi delle misurazioni di un qubit set di obiettivi specificato e osservabili. Se non viene specificato alcun obiettivo, l'osservabile deve operare solo su 1 qubit e viene applicato a tutti qubits in parallelo. Se vengono specificati obiettivi, il numero di obiettivi specificati deve essere uguale al numero qubits su cui agisce l'osservabile.
+ `Variance`restituisce la variance (`mean([x-mean(x)]2)`) del qubit set di obiettivi specificato e osservabile come tipo di risultato richiesto. Se non viene specificato alcun obiettivo, l'osservabile deve operare solo su 1 qubit e viene applicato a tutti qubits in parallelo. Altrimenti, il numero di obiettivi specificati deve essere uguale al numero qubits a cui può essere applicato l'osservabile.
**I tipi di risultati supportati per diversi provider:**
| | | | | | | | | |
| --- |--- |--- |--- |--- |--- |--- |--- |--- |
| | Sim locale | SV1 | DM1 | TN1 | AQT | IonQ | IQM | Rigetti |
| Gradiente aggiunto | N | Y | N | N | N | N | N | N |
| Amplitude | Y | Y | N | N | N | N | N | N |
| Aspettativa | Y | Y | Y | Y | Y | Y | Y | Y |
| Probability | Y | Y | Y | N | Y | Y | Y | Y |
| Matrice a densità ridotta | Y | N | Y | N | N | N | N | N |
| Vettore di stato | Y | N | N | N | N | N | N | N |
| Project N.E.M.O. | Y | Y | Y | Y | Y | Y | Y | Y |
| Varianza | Y | Y | Y | Y | Y | Y | Y | Y |
È possibile verificare i tipi di risultati supportati esaminando le proprietà del dispositivo, come illustrato nell'esempio seguente.
```
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
```
Per chiamare a`ResultType`, aggiungetelo a un circuito, come mostrato nell'esempio seguente.
```
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**
Diversi dispositivi quantistici forniscono risultati in vari formati. Ad esempio, Rigetti i dispositivi restituiscono le misurazioni, mentre IonQ i dispositivi forniscono le probabilità. L'SDK Amazon Braket offre una proprietà di misurazione per tutti i risultati. Tuttavia, per i dispositivi che restituiscono probabilità, queste misurazioni vengono post-calcolate e basate sulle probabilità, poiché le misurazioni per colpo non sono disponibili. Per determinare se un risultato è stato post-calcolato, controllate l'oggetto del risultato. `measurements_copied_from_device` Questa operazione è dettagliata nel file [gate\_model\_quantum\_task\_result.py](https://github.com/aws/amazon-braket-sdk-python/blob/ca5b08dada4839ca31c012ff50aa20b656fd1879/src/braket/tasks/gate_model_quantum_task_result.py#L70-L72) nel repository Amazon Braket SDK GitHub .
## Osservabili
La `Observable` classe di Amazon Braket ti consente di misurare un osservabile specifico.
Puoi applicare solo un osservabile univoco non identitario a ciascuno. qubit Si verifica un errore se si specificano due o più osservabili non di identità diversi sullo stesso. qubit A tal fine, ogni fattore di un prodotto tensoriale conta come osservabile individuale. Ciò significa che è possibile avere più prodotti tensoriali sullo stessoqubit, purché i fattori che agiscono su di essi rimangano gli stessi. qubit
Un osservabile può essere ridimensionato e aggiungere altri osservabili (ridimensionati o meno). Questo crea un `Sum` che può essere utilizzato nel tipo di risultato. `AdjointGradient`
La `Observable` classe include i seguenti osservabili.
```
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)))
```
## Parameters
I circuiti possono incorporare parametri liberi. Questi parametri liberi devono essere costruiti una sola volta per essere eseguiti più volte e possono essere utilizzati per calcolare i gradienti.
Ogni parametro gratuito utilizza un nome codificato in una stringa che viene utilizzato per:
+ Impostare i valori dei parametri
+ Identifica i parametri da utilizzare
```
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)
```
## Aggiungi gradiente
Il SV1 dispositivo calcola il gradiente aggiunto di un valore di aspettativa osservabile, incluso l'hamiltoniano multitermine. Per differenziare i parametri, specificate il loro nome (in formato stringa) o tramite riferimento diretto.
```
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])
```
Il passaggio di valori di parametri fissi come argomenti a un circuito parametrizzato rimuoverà i parametri liberi. L'esecuzione di questo circuito con `AdjointGradient` produce un errore, poiché i parametri liberi non esistono più. Il seguente esempio di codice dimostra l'utilizzo corretto e scorretto:
```
# 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})
```