qsharp Modulo
API pubblica dell'interprete Q#.
Questo modulo è la superficie pubblica per la funzionalità dell'interprete Q# all'interno del qdk pacchetto.
Esportazioni chiave:
- init — inizializzare o reimpostare l'interprete Q#.
- eval — valutare un'espressione Q# e restituirne il valore.
- run — eseguire un'espressione di immissione Q# per uno o più scatti.
- compile : compilare l'origine Q# in QIR per l'invio di hardware.
- circuit : sintetizzare un diagramma del circuito dal codice Q#.
- estimate — stimare le risorse quantistice (deprecate; usare qre invece).
- logical_counts — estrarre i conteggi dei gate logici dal codice Q#.
- dump_machine: restituisce lo stato del simulatore corrente come .StateDump
-
dump_circuit — restituire il circuito tracciato (richiede
trace_circuit=Truein init). - dump_operation — calcolare la matrice unitaria di un'operazione Q#.
- set_quantum_seed, set_classical_seed — controllare i semi RNG.
- estimate_custom : eseguire lo strumento di stima delle risorse generico con parametri di codice, qubit e algoritmo forniti dall'utente.
- QSharpError : generato in caso di errori di compilazione o runtime Q#.
- TargetProfile — enumerazione del profilo di destinazione della compilazione.
- Result, Pauli — Tipi primitivi Q#.
- CircuitGenerationMethod — controlla la modalità di sintesi dei circuiti.
- StateDump, ShotResult — tipi di output dell'interprete.
- PauliNoise BitFlipNoise, DepolarizingNoise, PhaseFlipNoise - modelli di rumore per la simulazione.
Classi
| BitFlipNoise |
Rumore di scorrimento del bit da usare nella simulazione. Crea una nuova istanza di BitFlipNoise. Il canale di scorrimento bit applica un errore Pauli-X con probabilità |
| CircuitGenerationMethod |
API pubblica dell'interprete Q#. Questo modulo è la superficie pubblica per la funzionalità dell'interprete Q# all'interno del Esportazioni chiave:
|
| DepolarizingNoise |
Rumore depolarizzato da usare nella simulazione. Crea una nuova istanza di DepolarizingNoise. Il canale depolarizzatore applica Pauli-X, Pauli-Y o Pauli-Z errori ognuno con probabilità |
| Pauli |
Operatore Q# Pauli. |
| PauliNoise |
Il rumore Pauli da usare nella simulazione rappresentate come probabilità degli errori Pauli-X, Pauli-Y e Pauli-Z Crea una nuova PauliNoise istanza con le probabilità di errore indicate. |
| PhaseFlipNoise |
La fase capovolgi il rumore da usare nella simulazione. Crea una nuova istanza di PhaseFlipNoise. Il canale di scorrimento della fase applica un errore di Pauli-Z con probabilità |
| QSharpError |
Errore restituito dall'interprete Q#. |
| Result |
Risultato della misurazione Q#. |
| ShotResult |
Un singolo risultato di un colpo. |
| StateDump |
Dump dello stato restituito dall'interprete Q#. |
| TargetProfile |
Profilo di destinazione Q#. Un profilo di destinazione descrive le funzionalità dell'hardware o del simulatore che verrà usato per eseguire il programma Q#. |
Funzioni
circuit
Esegue la sintesi di un circuito per un programma Q#. È necessario specificare un'espressione di voce o un'operazione.
circuit(entry_expr: str | Callable | GlobalCallable | Closure | None = None, *args, operation: str | None = None, generation_method: CircuitGenerationMethod | None = None, max_operations: int | None = None, source_locations: bool = False, group_by_scope: bool = True, prune_classical_qubits: bool = False) -> Circuit
Parametri
| Nome | Descrizione |
|---|---|
|
entry_expr
|
Espressione di immissione. In alternativa, è possibile specificare un oggetto chiamabile, che deve essere chiamabile Q#. Valore predefinito: None
|
|
*args
Necessario
|
Argomenti da passare all'oggetto chiamabile, se disponibile. |
Parametri di sole parole chiave
| Nome | Descrizione |
|---|---|
|
operation
|
Operazione da sintetizzare. Può trattarsi di un nome di un'operazione o di un'espressione lambda. L'operazione deve accettare solo qubit o matrici di qubit come parametri. Valore predefinito: None
|
|
generation_method
|
Metodo da utilizzare per la generazione di circuiti.
ClassicalEval valuta il flusso di controllo classico in fase di generazione del circuito.
Simulate esegue una simulazione completa per tracciare il circuito.
Static usa la valutazione parziale e richiede un profilo non Valore predefinito: None
|
|
max_operations
|
Numero massimo di operazioni da includere nel circuito.
L'impostazione Valore predefinito: None
|
|
source_locations
|
Se Valore predefinito: False
|
|
group_by_scope
|
Se Valore predefinito: True
|
|
prune_classical_qubits
|
Se Valore predefinito: False
|
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
<xref:Circuit>
|
Circuito sintetizzato. |
Eccezioni
| Tipo | Descrizione |
|---|---|
|
Se si verifica un errore durante la diffusione del circuito. |
compile
Compila il codice sorgente Q# in un programma che può essere inviato a una destinazione. È necessario specificare un'espressione di voce o un oggetto chiamabile con argomenti.
Esempio:
compile(entry_expr: str | Callable | GlobalCallable | Closure, *args) -> QirInputData
Parametri
| Nome | Descrizione |
|---|---|
|
entry_expr
Necessario
|
Espressione Q# che verrà usata come punto di ingresso per il programma. In alternativa, è possibile specificare un oggetto chiamabile, che deve essere chiamabile Q#. |
|
*args
Necessario
|
Argomenti da passare all'oggetto chiamabile, se disponibile. |
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
<xref:QirInputData>
|
Programma compilato. Usare |
dump_circuit
Esegue il dump di un circuito che mostra lo stato corrente del simulatore.
Questo circuito conterrà i cancelli applicati nel simulatore fino al punto corrente.
Richiede l'inizializzazione dell'interprete con trace_circuit=True.
dump_circuit() -> Circuit
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
<xref:Circuit>
|
Traccia del circuito corrente. |
Eccezioni
| Tipo | Descrizione |
|---|---|
|
Se l'interprete non è stato inizializzato con |
dump_machine
Restituisce il vettore di stato sparse del simulatore come oggetto StateDump.
dump_machine() -> StateDump
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
Stato del simulatore. |
dump_operation
Restituisce una matrice quadrata di numeri complessi che rappresentano l'operazione eseguita.
dump_operation(operation: str, num_qubits: int) -> List[List[complex]]
Parametri
| Nome | Descrizione |
|---|---|
|
operation
Necessario
|
Operazione da eseguire, che deve operare su un elenco di qubit. |
|
num_qubits
Necessario
|
Numero di qubit da usare. |
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
Matrice che rappresenta l'operazione. |
estimate
Stima le risorse per il codice sorgente Q#. È necessario specificare un'espressione di voce o un oggetto chiamabile con argomenti.
Deprecato dalla versione This: function usa l'API di stima delle risorse legacy. Utilizzare invece qdk.qre.
estimate(entry_expr: str | Callable | GlobalCallable | Closure, params: Dict[str, Any] | List | EstimatorParams | None = None, *args) -> EstimatorResult
Parametri
| Nome | Descrizione |
|---|---|
|
entry_expr
Necessario
|
Espressione di immissione. In alternativa, è possibile specificare un oggetto chiamabile, che deve essere chiamabile Q#. |
|
params
|
Parametri per configurare la stima fisica. Valore predefinito: None
|
|
*args
Necessario
|
Argomenti da passare all'oggetto chiamabile, se disponibile. |
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
Risorse stimate. |
estimate_custom
estimate_custom(algorithm, qubit, qec, factories=Ellipsis, *, error_budget=0.01, max_factories=None, logical_depth_factor=None, max_physical_qubits=None, max_duration=None, error_budget_pruning=False)
Parametri
| Nome | Descrizione |
|---|---|
|
algorithm
Necessario
|
|
|
qubit
Necessario
|
|
|
qec
Necessario
|
|
|
factories
|
Valore predefinito: Ellipsis
|
Parametri di sole parole chiave
| Nome | Descrizione |
|---|---|
|
error_budget
|
Valore predefinito: 0.01
|
|
max_factories
|
Valore predefinito: None
|
|
logical_depth_factor
|
Valore predefinito: None
|
|
max_physical_qubits
|
Valore predefinito: None
|
|
max_duration
|
Valore predefinito: None
|
|
error_budget_pruning
|
Valore predefinito: False
|
eval
Valuta il codice sorgente Q#.
L'output viene stampato nella console.
eval(source: str, *, save_events: bool = False) -> Any
Parametri
| Nome | Descrizione |
|---|---|
|
source
Necessario
|
Codice sorgente Q# da valutare. |
Parametri di sole parole chiave
| Nome | Descrizione |
|---|---|
|
save_events
|
Se true, tutti gli output verranno salvati e restituiti. Se false, verranno stampate. Valore predefinito: False
|
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
Valore restituito dall'ultima istruzione nel codice sorgente o dall'output salvato se |
Eccezioni
| Tipo | Descrizione |
|---|---|
|
Se si verifica un errore durante la valutazione del codice sorgente. |
init
Inizializza l'interprete Q#.
init(*, target_profile: TargetProfile = TargetProfile.Unrestricted, target_name: str | None = None, project_root: str | None = None, language_features: List[str] | None = None, trace_circuit: bool | None = None) -> Config
Parametri di sole parole chiave
| Nome | Descrizione |
|---|---|
|
target_profile
|
L'impostazione del profilo di destinazione consente all'interprete Q# di generare programmi compatibili con una destinazione specifica. Vedete TargetProfile. Valore predefinito: Unrestricted
|
|
target_name
|
Nome facoltativo del computer di destinazione da usare per dedurre l'impostazione di target_profile compatibile. Valore predefinito: None
|
|
project_root
|
Percorso facoltativo di una directory radice con un progetto Q# da includere. Deve contenere un manifesto del progetto qsharp.json. Valore predefinito: None
|
|
language_features
|
Elenco facoltativo di flag di funzionalità della lingua da abilitare. Questi corrispondono alle funzionalità sperimentali o in anteprima del linguaggio Q#. I valori validi sono:
Valore predefinito: None
|
|
trace_circuit
|
Abilita la traccia del circuito durante l'esecuzione. Il passaggio di True è necessario affinché la funzione dump_circuit restituisca un circuito. La funzione del circuitonon è interessata da questo parametro e genererà sempre un circuito. Valore predefinito: None
|
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
<xref:Config>
|
Configurazione dell'interprete Q#. |
logical_counts
Estrae i conteggi delle risorse logiche dal codice sorgente Q#. È necessario specificare un'espressione di voce o un oggetto chiamabile con argomenti.
logical_counts(entry_expr: str | Callable | GlobalCallable | Closure, *args) -> LogicalCounts
Parametri
| Nome | Descrizione |
|---|---|
|
entry_expr
Necessario
|
Espressione di immissione. In alternativa, è possibile specificare un oggetto chiamabile, che deve essere chiamabile Q#. |
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
Programmare le risorse in termini di conteggi di gate logici. |
run
Esegue l'espressione Q# specificata per il numero specificato di scatti. Ogni scatto usa un'istanza indipendente del simulatore.
run(entry_expr: str | Callable | GlobalCallable | Closure, shots: int, *args, on_result: Callable[[ShotResult], None] | None = None, save_events: bool = False, noise: Tuple[float, float, float] | PauliNoise | BitFlipNoise | PhaseFlipNoise | DepolarizingNoise | NoiseConfig | None = None, qubit_loss: float | None = None, seed: int | None = None, type: Literal['sparse', 'clifford'] | None = None, num_qubits: int | None = None) -> List[Any]
Parametri
| Nome | Descrizione |
|---|---|
|
entry_expr
Necessario
|
Espressione di immissione. In alternativa, è possibile specificare un oggetto chiamabile, che deve essere chiamabile Q#. |
|
shots
Necessario
|
Numero di colpi da eseguire. |
|
*args
Necessario
|
Argomenti da passare all'oggetto chiamabile, se disponibile. |
|
on_result
Necessario
|
Funzione di callback che verrà chiamata con ogni risultato. |
|
save_events
Necessario
|
Se true, l'output di ogni colpo verrà salvato. Se false, verranno stampate. |
|
noise
Necessario
|
Rumore da usare nella simulazione. |
|
qubit_loss
Necessario
|
Probabilità di perdita di qubit nella simulazione. |
|
seed
Necessario
|
Valore di inizializzazione da usare per il generatore di numeri casuali nella simulazione, se presente. |
|
type
Necessario
|
Tipo di simulatore da usare. Se non specificato, verrà usata la simulazione del vettore di stato sparse predefinita. |
|
num_qubits
Necessario
|
Numero di qubit da usare per il tipo di simulazione "clifford". Se non specificato, il simulatore Clifford presuppone un valore predefinito di 1000 qubit. |
Parametri di sole parole chiave
| Nome | Descrizione |
|---|---|
|
on_result
|
Valore predefinito: None
|
|
save_events
|
Valore predefinito: False
|
|
noise
|
Valore predefinito: None
|
|
qubit_loss
|
Valore predefinito: None
|
|
seed
|
Valore predefinito: None
|
|
type
|
Valore predefinito: None
|
|
num_qubits
|
Valore predefinito: None
|
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
Elenco di risultati o errori di runtime. Se |
Eccezioni
| Tipo | Descrizione |
|---|---|
|
Se si verifica un errore durante l'interpretazione dell'input. |
|
|
Se il numero di colpi è minore di 1. |
set_classical_seed
Imposta il valore di inizializzazione per il generatore di numeri casuali utilizzato per le operazioni numeri casuali classiche della libreria standard. Questo vale per tutto il codice Q# eseguito, compilato o stimato.
set_classical_seed(seed: int | None) -> None
Parametri
| Nome | Descrizione |
|---|---|
|
seed
Necessario
|
Valore di inizializzazione da utilizzare per il generatore di numeri casuali classici. Se Nessuno, il valore di inizializzazione verrà generato dall'entropia. |
set_quantum_seed
Imposta il valore di inizializzazione per il generatore di numeri casuali usato per le misurazioni quantistiche. Questo vale per tutto il codice Q# eseguito, compilato o stimato.
set_quantum_seed(seed: int | None) -> None
Parametri
| Nome | Descrizione |
|---|---|
|
seed
Necessario
|
Valore di inizializzazione da usare per il generatore di numeri casuali quantistici. Se Nessuno, il valore di inizializzazione verrà generato dall'entropia. |