Context Classe

Environnement d’interpréteur Q# isolé.

Un contexte fournit un environnement d’exécution Q# autonome dans lequel le code est évalué, compilé et exécuté séparément d’autres instances de contexte. Chaque contexte conserve son propre espace de noms de code.

Un contexte a un attribut code qui est un module Python contenant toutes les opérations et types Q# définis dans ce contexte. Cela vous permet d’appeler des opérations Q# à partir de Python.

Exemple :


   ctx = qdk.Context()
   ctx.eval("operation Main() : Result { use q = Qubit(); X(q); MResetZ(q) }")
   assert ctx.run("Main()", 2) == [qdk.Result.One, qdk.Result.One]
   assert ctx.code.Main() == qdk.Result.One

Initialise un nouveau contexte Q# isolé.

Constructeur

Context(*, 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, _is_global_context: bool = False)

Paramètres de mot clé uniquement

Nom Description
target_profile

La définition du profil cible permet à l’interpréteur Q# de générer des programmes compatibles avec une cible spécifique. Voir TargetProfile.

Valeur par défaut: Unrestricted
target_name

Nom facultatif de l’ordinateur cible à utiliser pour déduire le paramètre de target_profile compatible.

Valeur par défaut: None
project_root

Chemin facultatif d’un répertoire racine avec un projet Q# à inclure. Il doit contenir un manifeste de projet qsharp.json.

Valeur par défaut: None
language_features

Liste facultative des indicateurs de fonctionnalités linguistiques à activer. Celles-ci correspondent aux fonctionnalités expérimentales ou préliminaires du langage Q#. Les valeurs valides sont les suivantes :

  • "v2-preview-syntax": active la syntaxe d’aperçu Q# v2. Cela supprime la prise en charge de

formulaire de bloc d’allocation qubit délimité (use q = Qubit() { ... }), nécessitant le formulaire d’instruction à la place (use q = Qubit();). Il supprime également la nécessité d’utiliser le set mot clé pour les affectations de variables mutables.

Valeur par défaut: None
_trace_circuit
Valeur par défaut: None
_is_global_context
Valeur par défaut: False

Méthodes

circuit

Synthétise un circuit pour un programme Q#. Une expression d’entrée ou une opération doit être fournie.
compile

Compile le code source Q# dans un programme qui peut être envoyé à une cible. Une expression d’entrée ou une expression pouvant être appelée avec des arguments doit être fournie.

Exemple :
dump_machine

Retourne le vecteur d’état épars du simulateur en tant qu’objet StateDump.
eval

Évalue le code source Q#.

La sortie est imprimée dans la console.
get_target_profile

Retourne le profil cible pour ce contexte.
import_openqasm

Importe le code source OpenQASM dans l’interpréteur de ce contexte.
logical_counts

Extrait le nombre de ressources logiques à partir du code source Q#. Une expression d’entrée ou une expression pouvant être appelée avec des arguments doit être fournie.
run

Exécute l’expression Q# donnée pour le nombre donné de captures. Chaque capture utilise une instance indépendante du simulateur.
set_classical_seed

Définit la valeur initiale du générateur de nombres aléatoires utilisé pour les opérations de nombre aléatoire classique de bibliothèque standard. Cela s’applique à tous les codes Q# exécutés, compilés ou estimés dans ce contexte.
set_quantum_seed

Définit la valeur initiale du générateur de nombres aléatoires utilisé pour les mesures quantiques. Cela s’applique à tous les codes Q# exécutés, compilés ou estimés dans ce contexte.

circuit

Synthétise un circuit pour un programme Q#. Une expression d’entrée ou une opération doit être fournie.

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

Paramètres

Nom Description
entry_expr
str ou Callable

Expression d’entrée. Vous pouvez également fournir un appelant, qui doit être un appelant Q#.

Valeur par défaut: None
*args
Obligatoire

Arguments à passer à l’appelant, s’il est fourni.

Paramètres de mot clé uniquement

Nom Description
operation
str

Opération à synthétiser. Il peut s’agir d’un nom d’une opération ou d’une expression lambda. L’opération ne doit prendre que des qubits ou des tableaux de qubits en tant que paramètres.

Valeur par défaut: None
generation_method
CircuitGenerationMethod

Méthode à utiliser pour la génération de circuit. ClassicalEval évalue le flux de contrôle classique au moment de la génération du circuit. Simulate exécute une simulation complète pour tracer le circuit. Static utilise une évaluation partielle et nécessite un profil nonUnrestricted cible. Par défaut, la None méthode de génération est sélectionnée automatiquement.

Valeur par défaut: None
max_operations
int

Nombre maximal d’opérations à inclure dans le circuit. Valeurs par défaut, None ce qui signifie qu’aucune limite n’est définie.

Valeur par défaut: None
source_locations
bool

Si True, annote chaque porte avec son emplacement source.

Valeur par défaut: False
group_by_scope
bool

Si True, regroupe les opérations par leur étendue contenante, telles que les déclarations de fonction ou les blocs de boucle.

Valeur par défaut: True
prune_classical_qubits
bool

Si True, supprime les qubits qui ne sont jamais utilisés dans une porte quantique (par exemple, les qubits utilisés uniquement comme contrôles classiques).

Valeur par défaut: False

Retours

Type Description
<xref:Circuit>

Circuit synthétisé.

Exceptions

Type Description
QSharpError

En cas d’erreur de synthèse du circuit.

compile

Compile le code source Q# dans un programme qui peut être envoyé à une cible. Une expression d’entrée ou une expression pouvant être appelée avec des arguments doit être fournie.

Exemple :

compile(entry_expr: str | Callable | GlobalCallable | Closure, *args) -> QirInputData

Paramètres

Nom Description
entry_expr
Obligatoire

Expression Q# qui sera utilisée comme point d’entrée pour le programme. Vous pouvez également fournir un appelant, qui doit être un appelant Q#.
*args
Obligatoire

Arguments à passer à l’appelant, s’il est fourni.

Retours

Type Description
<xref:QirInputData>

Programme compilé. Permet str() d’obtenir la chaîne QIR.

dump_machine

Retourne le vecteur d’état épars du simulateur en tant qu’objet StateDump.

dump_machine() -> StateDump

Retours

Type Description
StateDump

État du simulateur.

eval

Évalue le code source Q#.

La sortie est imprimée dans la console.

eval(source: str, *, save_events: bool = False) -> Any

Paramètres

Nom Description
source
Obligatoire

Code source Q# à évaluer.

Paramètres de mot clé uniquement

Nom Description
save_events

Si la valeur est true, toutes les sorties sont enregistrées et retournées. Si la valeur est false, elles sont imprimées.

Valeur par défaut: False

Retours

Type Description
Any

Valeur retournée par la dernière instruction dans le code source ou la sortie enregistrée si save_events la valeur est true.

Exceptions

Type Description
QSharpError

En cas d’erreur lors de l’évaluation du code source.

get_target_profile

Retourne le profil cible pour ce contexte.

get_target_profile() -> TargetProfile

import_openqasm

Importe le code source OpenQASM dans l’interpréteur de ce contexte.

import_openqasm(source: str, **kwargs: Any) -> Any

Paramètres

Nom Description
source
Obligatoire
str

Un programme ou un fragment OpenQASM.
**kwargs
Obligatoire

Arguments de mot clé supplémentaires. Options courantes :

  • name (str) : nom du programme. Il s’agit du point d’entrée du programme.

  • search_path (str) : chemin de recherche facultatif pour la résolution des références de fichier.

  • output_semantics (OutputSemantics) : sémantique de sortie pour la compilation.

  • program_type (ProgramType) : type de compilation de programme à effectuer :

    • ProgramType.Operation (par défaut) : la source devient une opération Q# dans l’espace de noms global avec des paramètres pour les entrées et paramètres classiques déclarés pour chacun des qubits déclarés, tandis que toutes les déclarations de sortie explicites ou implicites deviennent le type de retour de l’opération.

    • ProgramType.File: traite la source d’entrée comme un programme autonome et crée une opération dans l’espace qasm_import de noms qui accepte uniquement les paramètres classiques, alloue les qubits requis en interne et les libère à la fin de l’opération.

    • ProgramType.Fragments: exécute la source fournie dans l’interpréteur interactif actuel, en définissant toutes les variables ou opérations déclarées dans l’étendue actuelle et en retournant la valeur de la dernière instruction dans la source.

Retours

Type Description
Any

Valeur retournée par la dernière instruction dans le code source.

Exceptions

Type Description
QasmError

En cas d’erreur lors de la génération, de l’analyse ou de l’analyse de la source OpenQASM.
QSharpError

En cas d’erreur lors de la compilation du programme.

logical_counts

Extrait le nombre de ressources logiques à partir du code source Q#. Une expression d’entrée ou une expression pouvant être appelée avec des arguments doit être fournie.

logical_counts(entry_expr: str | Callable | GlobalCallable | Closure, *args) -> LogicalCounts

Paramètres

Nom Description
entry_expr
Obligatoire

Expression d’entrée. Vous pouvez également fournir un appelant, qui doit être un appelant Q#.

Retours

Type Description
LogicalCounts

Ressources de programme en termes de nombre de portes logiques.

run

Exécute l’expression Q# donnée pour le nombre donné de captures. Chaque capture utilise une instance indépendante du simulateur.

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]

Paramètres

Nom Description
entry_expr
Obligatoire

Expression d’entrée. Vous pouvez également fournir un appelant, qui doit être un appelant Q#.
shots
Obligatoire

Nombre de tirs à exécuter.
*args
Obligatoire

Arguments à passer à l’appelant, s’il est fourni.
on_result
Obligatoire

Fonction de rappel qui sera appelée avec chaque résultat.
save_events
Obligatoire

Si la valeur est true, la sortie de chaque capture est enregistrée. Si la valeur est false, elles sont imprimées.
noise
Obligatoire

Bruit à utiliser dans la simulation.
qubit_loss
Obligatoire

Probabilité de perte de qubit dans la simulation.
seed
Obligatoire

Valeur initiale à utiliser pour le générateur de nombres aléatoires dans la simulation, le cas échéant.
type
Obligatoire

Type de simulateur à utiliser. S’il n’est pas spécifié, la simulation de vecteur d’état éparse par défaut est utilisée.
num_qubits
Obligatoire

Nombre de qubits à utiliser pour le type de simulation « clifford ». S’il n’est pas spécifié, le simulateur Clifford suppose une valeur par défaut de 1 000 qubits.

Paramètres de mot clé uniquement

Nom Description
on_result
Valeur par défaut: None
save_events
Valeur par défaut: False
noise
Valeur par défaut: None
qubit_loss
Valeur par défaut: None
seed
Valeur par défaut: None
type
Valeur par défaut: None
num_qubits
Valeur par défaut: None

Retours

Type Description
List[Any]

Liste des résultats ou des erreurs d’exécution. Si save_events la valeur est true, une liste d’éléments ShotResult est retournée.

Exceptions

Type Description
QSharpError

En cas d’erreur lors de l’interprétation de l’entrée.
ValueError

Si le nombre de tirs est inférieur à 1.

set_classical_seed

Définit la valeur initiale du générateur de nombres aléatoires utilisé pour les opérations de nombre aléatoire classique de bibliothèque standard. Cela s’applique à tous les codes Q# exécutés, compilés ou estimés dans ce contexte.

set_classical_seed(seed: int | None) -> None

Paramètres

Nom Description
seed
Obligatoire

Valeur initiale à utiliser pour le générateur de nombres aléatoires classique. Si aucune, la valeur initiale est générée à partir de l’entropie.

set_quantum_seed

Définit la valeur initiale du générateur de nombres aléatoires utilisé pour les mesures quantiques. Cela s’applique à tous les codes Q# exécutés, compilés ou estimés dans ce contexte.

set_quantum_seed(seed: int | None) -> None

Paramètres

Nom Description
seed
Obligatoire

Valeur initiale à utiliser pour le générateur de nombres aléatoires quantiques. Si aucune, la valeur initiale est générée à partir de l’entropie.

Attributs

code 

code: Any