Een circuit met Qiskit verzenden naar Azure Quantum
Meer informatie over het verzenden van een Qiskit-kwantumcircuit met behulp van het azure-quantumPython pakket. U kunt Qiskit-circuits verzenden naar Azure Quantum met behulp van een Azure Quantum-notebook met een ingebouwd azure-quantumPython pakket of vanaf uw lokale computer. U kunt uw circuits ook testen met behulp van de lokale sparsesimulator.
Zie Quantum-circuits voor meer informatie.
Vereisten
Zie De QDK-extensie instellenvoor installatiedetails.
Een Azure Quantum-werkruimte in uw Azure-abonnement. Om een werkruimte te maken, zie Een Azure Quantum-werkruimte maken.
Een Python omgeving met Python en Pip geïnstalleerd.
VS Code met de Azure Quantum Development KitPython en Jupyter-extensies geïnstalleerd.
Het Azure Quantum-pakket
azure-quantumPython met de tag [qiskit].python -m pip install --upgrade azure-quantum[qiskit] qsharp ipykernelBelangrijk
Zorg ervoor dat u de nieuwste versie van Qiskit hebt. Zie Update de azure-quantum Python package voor meer informatie.
Notitie
Als de Jupyter-kernel Python
ipykernelniet wordt gedetecteerd, wordt u door VS Code gevraagd deze te installeren.
Een nieuw Jupyter-notebook maken
- Selecteer in VS Code Weergave > Commandopalet en selecteer Maken: Nieuw Jupyter Notebook.
- In de rechterbovenhoek detecteert en geeft VS Code de versie van Python en de virtuele Python omgeving weer die is geselecteerd voor het notebook. Als u meerdere Python omgevingen hebt, moet u mogelijk een kernel selecteren met behulp van de kernelkiezer in de rechterbovenhoek. Als er geen omgeving wordt gedetecteerd, bekijk dan Jupyter Notebooks in VS Code voor informatie over de installatie.
De vereiste importbewerkingen laden
Voer in de eerste cel van uw notebook de volgende code uit om de vereiste importbewerkingen te laden:
import azure.quantum
from azure.quantum import Workspace
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider
Verbinding maken met de Azure Quantum-service
Als u verbinding wilt maken met de Azure Quantum-service, hebt u de resource-id en de locatie van uw Azure Quantum-werkruimte nodig.
Meld u aan bij uw Azure-account, https://portal.azure.com
Selecteer uw Azure Quantum-werkruimte en navigeer naar Overzicht.
Kopieer de parameters in de velden.
Voeg een nieuwe cel toe aan uw notebook en gebruik uw accountgegevens om Workspace en AzureQuantumProvider objecten aan te maken, zodat u verbinding kunt maken met uw Azure Quantum-werkruimte.
workspace = Workspace(
resource_id = "", # Add the resourceID of your workspace
location = "" # Add the location of your workspace (for example "westus")
)
provider = AzureQuantumProvider(workspace)
Alle back-ends weergeven
U kunt nu alle back-ends van kwantumcomputing afdrukken die beschikbaar zijn in uw werkruimte:
print("This workspace's targets:")
for backend in provider.backends():
print("- " + backend.name())
This workspace's targets:
- ionq.qpu
- ionq.qpu.aria-1
- ionq.simulator
- microsoft.estimator
- quantinuum.hqs-lt-s1
- quantinuum.hqs-lt-s1-apival
- quantinuum.hqs-lt-s2
- quantinuum.hqs-lt-s2-apival
- quantinuum.hqs-lt-s1-sim
- quantinuum.hqs-lt-s2-sim
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-3
Een eenvoudig circuit uitvoeren
Maak eerst een eenvoudig Qiskit-circuit om uit te voeren.
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0,1,2], [0, 1, 2])
# Print out the circuit
circuit.draw()
┌───┐ ┌─┐
q_0: ┤ H ├──■───────┤M├──────
└───┘┌─┴─┐ └╥┘┌─┐
q_1: ─────┤ X ├──■───╫─┤M├───
└───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
└───┘ ║ ║ └╥┘
c: 3/════════════════╩══╩══╩═
0 1 2
Selecteer een target om uw programma uit te voeren
Uitvoeren op de IonQ-simulator
Voordat we het circuit op echte hardware laten draaien, laten we het testen in de simulator. Hiermee get_backend maakt u een Backend object om verbinding te maken met de back-end van de IonQ Simulator:
simulator_backend = provider.get_backend("ionq.simulator")
IonQ-back-ends ondersteunen poorten van een gedefinieerde gateset, die zijn gecompileerd om optimaal op de hardware te worden uitgevoerd. Als uw circuit poorten bevat die niet in deze lijst staan, moet u transpileren in de ondersteunde gatesettranspile functie die wordt geleverd door Qiskit:
from qiskit import transpile
circuit = transpile(circuit, simulator_backend)
De transpile-functie retourneert een nieuw circuitobject waarbij poorten worden opgesplitst in poorten die worden ondersteund op de opgegeven back-end.
U kunt het programma nu uitvoeren via de Azure Quantum-service en het resultaat ophalen. De volgende cel verstuurt een taak die het circuit 100 keer uitvoert:
job = simulator_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)
Job id 00000000-0000-0000-0000-000000000000
Voer de volgende opdracht uit om te wachten totdat de taak is voltooid en de resultaten te retourneren:
result = job.result()
print(result)
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '000', '000', '000', '111', '111', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
Omdat het resultaat een object is dat systeemeigen is voor het Qiskit-pakket, kunt u Qiskit's result.get_counts gebruiken en plot_histogram de resultaten visualiseren. Als u ervoor wilt zorgen dat alle mogelijke bittekenreekslabels worden weergegeven, voegt u deze toe aan counts.
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}
U kunt de get_memory() functie gebruiken om afzonderlijke opnamegegevens uit de taak weer te geven
result.get_memory(circuit)
['000', '000', '000', '000', '111', '111', '111', '111']
Notitie
Als u bij IonQ targets een taak met een oneven aantal shots indient, worden de resultaten naar beneden afgerond naar het dichtstbijzijnde even getal. Als u bijvoorbeeld 9 opnamen opgeeft, worden in de resultaten gegevens weergegeven voor 8 opnamen.
Werk kosten inschatten
Voordat u een taak uitvoert op de QPU, moet u schatten hoeveel het kost om uit te voeren.
Zie IonQ-prijzen voor de meest recente prijsinformatie of zoek uw werkruimte en bekijk prijsopties op het tabblad Provider van uw werkruimte via: aka.ms/aq/myworkspaces.
Uitvoeren op IonQ QPU
Als u verbinding wilt maken met echte hardware (een Quantum Processor Unit (QPU)), geeft u eenvoudig de naam van de target"ionq.qpu.aria-1" aan de get_backend-methode op:
qpu_backend = provider.get_backend("ionq.qpu.aria-1")
Verzend het circuit om het te laten uitvoeren op Azure Quantum, haal de resultaten op, en voer plot_histogram uit om de resultaten te plotten.
Notitie
De tijd die nodig is om een circuit uit te voeren op de QPU kan variëren, afhankelijk van de huidige wachtrijtijden.
# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)
# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='ionq.qpu.aria-1', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}
Belangrijk
Het verzenden van meerdere circuits op één taak wordt momenteel niet ondersteund. Als tijdelijke oplossing kunt u de backend.run methode aanroepen om elk circuit asynchroon te verzenden en vervolgens de resultaten van elke taak op te halen. Voorbeeld:
jobs = []
for circuit in circuits:
jobs.append(backend.run(circuit, shots=N))
results = []
for job in jobs:
results.append(job.result())
Vereisten
- Een Azure-account met een actief abonnement. Als u geen Azure-account hebt, registreert u zich gratis en registreert u zich voor een abonnement op basis van betalen per gebruik.
- Een Azure Quantum-werkruimte. Zie Een Azure Quantum-werkruimte maken voor meer informatie.
Een nieuw notitieblok maken in uw werkruimte
- Meld u aan bij Azure Portal en selecteer de werkruimte die u in de vorige stap hebt gemaakt.
- Selecteer Notitieblokken op de linkerblade.
- Klik op Mijn notitieblokken en klik op Nieuw toevoegen.
- Typ een naam voor het bestand, bijvoorbeeld Qiskit.ipynb, en klik op Bestand maken.
Wanneer uw nieuwe notitieblok wordt geopend, wordt automatisch de code voor de eerste cel gemaakt op basis van uw abonnement en werkruimtegegevens.
from azure.quantum import Workspace
workspace = Workspace (
resource_id = "", # Add your resource_id
location = "" # Add your workspace location (for example, "westus")
)
Notitie
Tenzij anders vermeld, moet u elke cel in de gewenste volgorde uitvoeren terwijl u deze maakt om compilatieproblemen te voorkomen.
Klik op het driehoekige afspeelpictogram links van de cel om de code uit te voeren.
De vereiste importbewerkingen laden
Eerst moet u enkele extra modules importeren.
Klik op + Code om een nieuwe cel toe te voegen en voeg de volgende code toe en voer deze uit:
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider
Verbinding maken met de Azure Quantum-service
Maak vervolgens een AzureQuantumProvider object met behulp van het Workspace object uit de vorige cel om verbinding te maken met uw Azure Quantum-werkruimte. Voeg een nieuwe cel toe met de volgende code:
provider = AzureQuantumProvider(workspace)
Een eenvoudig circuit definiëren
Maak een circuit object in een nieuwe cel. Dit voorbeeld is een eenvoudige kwantumgenerator voor willekeurige bits. Voeg de volgende code toe om het circuit te definiëren en weer te geven:
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0, 1, 2], [0, 1, 2])
# Print out the circuit
circuit.draw()
┌───┐ ┌─┐
q_0: ┤ H ├──■───────┤M├──────
└───┘┌─┴─┐ └╥┘┌─┐
q_1: ─────┤ X ├──■───╫─┤M├───
└───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
└───┘ ║ ║ └╥┘
c: 3/════════════════╩══╩══╩═
0 1 2
Alles weergeven targets
U kunt nu alle kwantumcomputing targets, of back-ends, die beschikbaar zijn in uw werkruimte weergeven. Voeg een nieuwe cel toe en voer de volgende regel uit:
print("This workspace's targets:")
for backend in provider.backends():
print("- " + backend.name())
This workspace's targets:
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-3
Selecteer een target om uw programma uit te voeren
Als u uw code wilt controleren voordat u deze uitvoert op daadwerkelijke kwantumhardware, kunt u de IonQ-kwantumsimulator gebruiken. ionq.simulator
Voeg een nieuwe cel toe en maak een object om de IonQ-kwantumsimulator targetweer te geven:
# Get IonQ quantum simulator target:
simulator_backend = provider.get_backend("ionq.simulator")
Uitvoeren op de IonQ-simulator
Voeg de volgende code toe om uw circuit uit te voeren op de simulator. Dit voorbeeld gebruikt de run methode van de target om uw klus te verzenden en controleert vervolgens de status van de taak.
# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)
Wanneer de taak is uitgevoerd, haalt u de taakresultaten op en geeft u deze weer:
# Get the job results:
result = job.result()
print(result)
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '000', '000', '000', '111', '111', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
Omdat dit result type een object is dat systeemeigen is voor het Qiskit-pakket, kunt u Qiskit's result.get_counts gebruiken en plot_histogram de resultaten visualiseren. Als u ervoor wilt zorgen dat alle mogelijke bittekenreekslabels worden weergegeven, voegt u deze toe aan counts.
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}
U kunt de get_memory() functie ook gebruiken om afzonderlijke schotgegevens uit de taak weer te geven
result.get_memory(circuit)
['000', '000', '000', '000', '111', '111', '111', '111']
Notitie
Als u op IonQ targets een taak met een oneven aantal metingen indient, worden de resultaten naar beneden afgerond naar het dichtstbijzijnde even getal. Als u bijvoorbeeld 9 opnamen opgeeft, worden in de resultaten gegevens weergegeven voor 8 opnamen.
Taakkosten schatten
Voordat u een taak uitvoert op werkelijke kwantumhardware of een QPU (kwantumverwerkingseenheid ), moet u schatten hoeveel het kost om uit te voeren.
Zie IonQ-prijzen voor de meest recente prijsinformatie of zoek uw werkruimte en bekijk prijsopties op de blade Providers van uw werkruimte.
Uitvoeren op IonQ QPU
Nadat u uw taak hebt uitgevoerd op de IonQ-simulator en de QPU-kosten hebt geschat, is het tijd om uw circuit uit te voeren op de hardware.
Notitie
De tijd die nodig is om een circuit uit te voeren op de QPU, is afhankelijk van de huidige wachtrijtijden. u kunt de gemiddelde wachttijd voor een target bekijken door het Providers-blade van uw werkruimte te selecteren.
Gebruik dezelfde run methode en bewerkingen die u eerder met de API Validator hebt gebruikt om uw taak in te dienen en te bewaken:
# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)
Wanneer de taak is voltooid, haalt u de taakresultaten op zoals voorheen en geeft u deze weer in een grafiek:
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
Job id 910b5ac8-98cd-11ec-b3ba-00155d5528cf
Job Status: job has successfully run
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='Job id 54e8c740-98d9-11ec-b382-00155d957f5d', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}
Belangrijk
Het verzenden van meerdere circuits op één taak wordt momenteel niet ondersteund. Als tijdelijke oplossing kunt u de backend.run methode aanroepen om elk circuit asynchroon te verzenden en vervolgens de resultaten van elke taak op te halen. Voorbeeld:
jobs = []
for circuit in circuits:
jobs.append(backend.run(circuit, shots=N))
results = []
for job in jobs:
results.append(job.result())
Vereisten
Zie De QDK-extensie instellenvoor installatiedetails.
Een Python omgeving met Python en Pip geïnstalleerd.
VS Code waarop de Azure Quantum Development Kit en Python extensies zijn geïnstalleerd.
Het Azure Quantum-pakket
qsharpPython met deqiskitenwidgettags.python pip install "qsharp[qiskit,widgets]>=1.9"Belangrijk
Zorg ervoor dat u de nieuwste versie van Qiskit hebt. Voor meer informatie, zie bijwerken van het azure-quantum Python pakket.
Een basiscircuit uitvoeren
Open in VS Code een nieuw Python bestand om een basiscircuit te definiëren en uit te voeren met behulp van de ingebouwde sparsesimulator in het Qsharp-pakket.
# load the required imports
from qiskit.circuit.random import random_circuit
from qsharp.interop.qiskit import QSharpBackend
# define and display the circuit
circuit = random_circuit(2, 2, measure=True)
print(circuit)
# run the circuit using the built-in sparse simulator
backend = QSharpBackend()
job = backend.run(circuit)
counts = job.result().get_counts()
print(counts)
Als u het programma wilt uitvoeren, selecteert u het pictogram Uitvoeren in de rechterbovenhoek en selecteert u Bestand uitvoerenPython. De uitvoer wordt weergegeven in een nieuw terminalvenster.
┌─────────────────────────┐┌─┐
q_0: ─■───────────┤0 ├┤M├───
│P(0.79983) │ (XX-YY)(1.9337,1.7385) │└╥┘┌─┐
q_1: ─■───────────┤1 ├─╫─┤M├
└─────────────────────────┘ ║ └╥┘
c: 2/═════════════════════════════════════════╩══╩═
0 1
{'11': 680, '00': 344}
QIR genereren voor het circuit
Met hetzelfde circuit kunt u QIR genereren die wordt gebruikt voor uitvoering op kwantumhardware.
Notitie
Bij het genereren van QIR moeten alle registers zijn gemeten in. Als er ongebruikte registers zijn, wordt er een fout gegenereerd. Daarnaast treedt er een fout op wanneer geprobeerd wordt QIR te genereren terwijl het profiel is ingesteld op Unrestricted. Het Unrestricted-profiel is alleen geldig voor simulatie. Of TargetProfile.Base of TargetProfile.Adaptive_RI moet worden gebruikt. De target_profile kan worden overschreven in de backend.qir(...) aanroep om van profiel te wisselen.
QSharpErrorenTargetProfileimporterenfrom qsharp import QSharpError, TargetProfileDe uitvoer wijzigen om QIR te genereren
print(backend.qir(circuit, target_profile=TargetProfile.Adaptive_RI))
Uw code moet er nu als volgt uitzien:
# load the required imports
from qiskit.circuit.random import random_circuit
from qsharp.interop.qiskit import QSharpBackend
from qsharp import QSharpError, TargetProfile
# define and display the circuit
circuit = random_circuit(2, 2, measure=True)
print(circuit)
# generate QIR for the circuit
print(backend.qir(circuit, target_profile=TargetProfile.Adaptive_RI))
met de uitvoer:
┌────────────┐ ┌─┐
q_0: ┤ Rx(2.7195) ├─■───────────┤M├───
└──┬─────┬───┘ │U1(5.5924) └╥┘┌─┐
q_1: ───┤ Tdg ├─────■────────────╫─┤M├
└─────┘ ║ └╥┘
c: 2/════════════════════════════╩══╩═
0 1
%Result = type opaque
%Qubit = type opaque
define void @ENTRYPOINT__main() #0 {
block_0:
call void @__quantum__qis__rx__body(double 2.7194945105768586, %Qubit* inttoptr (i64 0 to %Qubit*))
call void @__quantum__qis__rz__body(double 2.796204066686262, %Qubit* inttoptr (i64 0 to %Qubit*))
call void @__quantum__qis__t__adj(%Qubit* inttoptr (i64 1 to %Qubit*))
call void @__quantum__qis__cx__body(%Qubit* inttoptr (i64 0 to %Qubit*), %Qubit* inttoptr (i64 1 to %Qubit*))
call void @__quantum__qis__rz__body(double -2.796204066686262, %Qubit* inttoptr (i64 1 to %Qubit*))
call void @__quantum__qis__cx__body(%Qubit* inttoptr (i64 0 to %Qubit*), %Qubit* inttoptr (i64 1 to %Qubit*))
call void @__quantum__qis__rz__body(double 2.796204066686262, %Qubit* inttoptr (i64 1 to %Qubit*))
call void @__quantum__qis__m__body(%Qubit* inttoptr (i64 0 to %Qubit*), %Result* inttoptr (i64 0 to %Result*))
call void @__quantum__qis__m__body(%Qubit* inttoptr (i64 1 to %Qubit*), %Result* inttoptr (i64 1 to %Result*))
call void @__quantum__rt__array_record_output(i64 2, i8* null)
call void @__quantum__rt__result_record_output(%Result* inttoptr (i64 1 to %Result*), i8* null)
call void @__quantum__rt__result_record_output(%Result* inttoptr (i64 0 to %Result*), i8* null)
ret void
}
declare void @__quantum__qis__rx__body(double, %Qubit*)
declare void @__quantum__qis__rz__body(double, %Qubit*)
declare void @__quantum__qis__t__adj(%Qubit*)
declare void @__quantum__qis__cx__body(%Qubit*, %Qubit*)
declare void @__quantum__qis__m__body(%Qubit*, %Result*) #1
declare void @__quantum__rt__array_record_output(i64, i8*)
declare void @__quantum__rt__result_record_output(%Result*, i8*)
attributes #0 = { "entry_point" "output_labeling_schema" "qir_profiles"="adaptive_profile" "required_num_qubits"="2" "required_num_results"="2" }
attributes #1 = { "irreversible" }
; module flags
!llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9, !10}
!0 = !{i32 1, !"qir_major_version", i32 1}
!1 = !{i32 7, !"qir_minor_version", i32 0}
!2 = !{i32 1, !"dynamic_qubit_management", i1 false}
!3 = !{i32 1, !"dynamic_result_management", i1 false}
!4 = !{i32 1, !"classical_ints", i1 true}
!5 = !{i32 1, !"qubit_resetting", i1 true}
!6 = !{i32 1, !"classical_floats", i1 false}
!7 = !{i32 1, !"backwards_branching", i1 false}
!8 = !{i32 1, !"classical_fixed_points", i1 false}
!9 = !{i32 1, !"user_functions", i1 false}
!10 = !{i32 1, !"multiple_target_branching", i1 false}
Niet alle programma's kunnen op alle hardware worden uitgevoerd. Hier kunt u proberen het target-profiel te Base, maar er zullen gedetailleerde fouten worden weergegeven over welke onderdelen van het programma niet worden ondersteund.
try:
backend.qir(qc, target_profile=TargetProfile.Base)
except QSharpError as e:
print(e)