qsharp Module

API publique de l’interpréteur Q#.

Ce module est l’aire publique des fonctionnalités d’interpréteur Q# au sein du qdk package.

Exportations clés :

init — initialisez ou réinitialisez l’interpréteur Q#.
eval : évaluez une expression Q# et retournez sa valeur.
run — exécutez une expression d’entrée Q# pour une ou plusieurs captures.
compile — compilez la source Q# en QIR pour la soumission matérielle.
circuit — synthétiser un diagramme de circuit à partir du code Q#.
estimate — estimer les ressources quantiques (déconseillées ; utiliser qre à la place).
logical_counts : extrayez les nombres de portes logiques à partir du code Q#.
dump_machine — retourne l’état actuel du simulateur en tant que StateDump.
dump_circuit — retourner le circuit suivi (requis trace_circuit=True dans init).
dump_operation — calcule la matrice unitaire d’une opération Q#.
set_quantum_seed, — set_classical_seed contrôler les graines RNG.
estimate_custom : exécutez l’estimateur de ressource générique avec des paramètres d’algorithme, qubit et de code fournis par l’utilisateur.
QSharpError — déclenché sur les erreurs de compilation ou d’exécution Q#.
TargetProfile — énumération du profil cible de compilation.
Result, — Pauli Types primitifs Q#.
CircuitGenerationMethod — contrôle la façon dont les circuits sont synthétisés.
StateDump, — ShotResult types de sortie d’interpréteur.
PauliNoise, , DepolarizingNoise, BitFlipNoise, PhaseFlipNoise — modèles de bruit pour la simulation.

Classes

BitFlipNoise	Bruit de retournement de bit à utiliser dans la simulation. Crée une nouvelle instance BitFlipNoise. Le canal de retournement de bits applique une erreur Pauli-X avec probabilité `p`.
CircuitGenerationMethod	API publique de l’interpréteur Q#. Ce module est l’aire publique des fonctionnalités d’interpréteur Q# au sein du `qdk` package. Exportations clés : init — initialisez ou réinitialisez l’interpréteur Q#. eval : évaluez une expression Q# et retournez sa valeur. run — exécutez une expression d’entrée Q# pour une ou plusieurs captures. compile — compilez la source Q# en QIR pour la soumission matérielle. circuit — synthétiser un diagramme de circuit à partir du code Q#. estimate — estimer les ressources quantiques (déconseillées ; utiliser qre à la place). logical_counts : extrayez les nombres de portes logiques à partir du code Q#. dump_machine — retourne l’état actuel du simulateur en tant que StateDump. dump_circuit — retourner le circuit suivi (requis `trace_circuit=True` dans init). dump_operation — calcule la matrice unitaire d’une opération Q#. set_quantum_seed, — set_classical_seed contrôler les graines RNG. estimate_custom : exécutez l’estimateur de ressource générique avec des paramètres d’algorithme, qubit et de code fournis par l’utilisateur. QSharpError — déclenché sur les erreurs de compilation ou d’exécution Q#. TargetProfile — énumération du profil cible de compilation. Result, — Pauli Types primitifs Q#. CircuitGenerationMethod — contrôle la façon dont les circuits sont synthétisés. StateDump, — ShotResult types de sortie d’interpréteur. PauliNoise, , DepolarizingNoise, BitFlipNoise, PhaseFlipNoise — modèles de bruit pour la simulation.
DepolarizingNoise	Bruit dépolarisant à utiliser dans la simulation. Crée une nouvelle instance DepolarizingNoise. Le canal dépolarisant applique Pauli-X, Pauli-Y ou Pauli-Z erreurs chacune avec probabilité `p / 3`.
Pauli	Opérateur Q# Pauli.
PauliNoise	Le bruit de Pauli à utiliser dans la simulation représenté comme des probabilités de Pauli-X, Pauli-Y et Pauli-Z erreurs Crée une PauliNoise instance avec les probabilités d’erreur données.
PhaseFlipNoise	Le bruit de retournement de phase à utiliser dans la simulation. Crée une nouvelle instance PhaseFlipNoise. Le canal de retourne de phase applique une erreur Pauli-Z avec probabilité `p`.
QSharpError	Erreur retournée par l’interpréteur Q#.
Result	Résultat de mesure Q#.
ShotResult	Résultat unique d’un coup.
StateDump	Vidage d’état retourné par l’interpréteur Q#.
TargetProfile	Profil cible Q#. Un profil cible décrit les fonctionnalités du matériel ou du simulateur qui seront utilisées pour exécuter le programme Q#.

Functions

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 non`Unrestricted` 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_circuit

Vide un circuit affichant l’état actuel du simulateur.

Ce circuit contiendra les portes qui ont été appliquées dans le simulateur jusqu’au point actuel.

Nécessite que l’interpréteur soit initialisé avec trace_circuit=True.

dump_circuit() -> Circuit

Retours

Type	Description
<xref:Circuit>	Trace du circuit actuel.

Exceptions

Type	Description
QSharpError	Si l’interpréteur n’a pas été initialisé avec `trace_circuit=True`

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.

dump_operation

Retourne une matrice carrée de nombres complexes représentant l’opération effectuée.

dump_operation(operation: str, num_qubits: int) -> List[List[complex]]

Paramètres

Nom	Description
operation Obligatoire	Opération à effectuer, qui doit fonctionner sur une liste de qubits.
num_qubits Obligatoire	Nombre de qubits à utiliser.

Retours

Type	Description
List[List[complex]]	Matrice représentant l’opération.

estimate

Estime les ressources pour le code source Q#. Une expression d’entrée ou une expression pouvant être appelée avec des arguments doit être fournie.

Déconseillé depuis la version Suivante : la fonction utilise l’API d’estimateur de ressource héritée. Utilisez qdk.qre à la place.

estimate(entry_expr: str | Callable | GlobalCallable | Closure, params: Dict[str, Any] | List | EstimatorParams | None = None, *args) -> EstimatorResult

Paramètres

Nom	Description
entry_expr Obligatoire	Expression d’entrée. Vous pouvez également fournir un appelant, qui doit être un appelant Q#.
params	Paramètres pour configurer l’estimation physique. Valeur par défaut: None
*args Obligatoire	Arguments à passer à l’appelant, s’il est fourni.

Retours

Type	Description
EstimatorResult	Ressources estimées.

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)

Paramètres

Nom	Description
algorithm Obligatoire
qubit Obligatoire
qec Obligatoire
factories	Valeur par défaut: Ellipsis

Paramètres de mot clé uniquement

Nom	Description
error_budget	Valeur par défaut: 0.01
max_factories	Valeur par défaut: None
logical_depth_factor	Valeur par défaut: None
max_physical_qubits	Valeur par défaut: None
max_duration	Valeur par défaut: None
error_budget_pruning	Valeur par défaut: False

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.

init

Initialise l’interpréteur 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

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 du formulaire de bloc d’allocation qubit délimité (`use q = Qubit() { ... }`), nécessitant plutôt le formulaire d’instruction (`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	Active le suivi du circuit pendant l’exécution. La transmission de true est requise pour que la fonction dump_circuit retourne un circuit. La fonction de circuitn’est pas affectée par ce paramètre et génère toujours un circuit. Valeur par défaut: None

Retours

Type	Description
<xref:Config>	Configuration de l’interpréteur Q#.

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.

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.

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.