Sdílet prostřednictvím

Odeslání okruhu pomocí Qiskitu do Azure Quantum

  • Článek

Zjistěte, jak odeslat kvantový okruh Qiskit pomocí azure-quantumPython balíčku. Okruhy Qiskit můžete odeslat do Azure Quantum pomocí poznámkového bloku Azure Quantum, který má integrovaný azure-quantumPython balíček nebo z místního počítače. Okruhy můžete otestovat také pomocí místního řídkého simulátoru.

Další informace najdete v tématu Kvantové obvody.

Požadavky

Podrobnosti o instalaci najdete v tématu Nastavení rozšíření QDK.

  • Pracovní prostor Azure Quantum ve vašem předplatném Azure Pokud chcete vytvořit pracovní prostor, přečtěte si téma Vytvoření pracovního prostoru Azure Quantum.

  • Prostředí Python s nainstalovaným Python nástrojem Pip .

  • VS Code s nainstalovanou sadou Azure Quantum Development KitPython a rozšířeními Jupyter.

  • Balíček Azure Quantum azure-quantumPython se značkou [qiskit].

    python -m pip install --upgrade azure-quantum[qiskit] qsharp ipykernel

    Důležité

    Ujistěte se, že máte nejnovější verzi Qiskitu. Další informace najdete v tématu Python azure-quantum.

    Poznámka:

    Pokud se nerozpoznalo jádro Python Jupyteripykernel, nástroj VS Code vás vyzve k jeho instalaci.

Vytvoření nového poznámkového bloku Jupyter

  1. Ve VS Code vyberte > Zobrazit příkaz a vyberte Vytvořit: Nový poznámkový blok Jupyter.
  2. V pravém horním rohu nástroj VS Code rozpozná a zobrazí verzi Python a virtuální Python prostředí vybrané pro poznámkový blok. Pokud máte více Python prostředí, možná budete muset vybrat jádro pomocí nástroje pro výběr jádra v pravém horním rohu. Pokud nebylo zjištěno žádné prostředí, informace o nastavení najdete v poznámkových blocích Jupyter v editoru VS Code .

Načtení požadovaných importů

V první buňce poznámkového bloku spusťte následující kód, který načte požadované importy:

import azure.quantum
from azure.quantum import Workspace 
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

Připojení ke službě Azure Quantum

Pokud se chcete připojit ke službě Azure Quantum, potřebujete ID prostředku a umístění pracovního prostoru Azure Quantum.

  1. Přihlaste se ke svému účtu Azure, https://portal.azure.com

  2. Vyberte pracovní prostor Azure Quantum a přejděte na Přehled.

  3. Zkopírujte parametry v polích.

    Snímek obrazovky editoru Visual Studio Code znázorňující, jak rozbalit podokno přehledu pracovního prostoru Quantum

Přidejte do poznámkového bloku novou buňku a pomocí informací o účtu vytvořte Workspace a AzureQuantumProvider objekty pro připojení k pracovnímu prostoru Azure Quantum.

workspace = Workspace(  
    resource_id = "", # Add the resourceID of your workspace
    location = "" # Add the location of your workspace (for example "westus")
    )

provider = AzureQuantumProvider(workspace)

Výpis všech back-endů

Teď můžete vytisknout všechny back-endy kvantových výpočtů, které jsou dostupné ve vašem pracovním prostoru:

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

Spuštění jednoduchého okruhu

Nejprve vytvořte jednoduchý okruh Qiskit, který se má spustit.

# 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

Vyberte program, který target chcete spustit.

Spuštění na simulátoru IonQ

Před spuštěním na skutečném hardwaru otestujeme okruh v simulátoru. Slouží get_backend k vytvoření objektu Backend pro připojení k back-endu Simulátoru IonQ:

simulator_backend = provider.get_backend("ionq.simulator")

Back-endy IonQ podporují brány z definované sady bran, které se kompilují tak, aby běžely optimálně na hardwaru. Pokud váš okruh obsahuje brány, které nejsou v tomto seznamu, musíte převést do podporované gatesettranspile funkce poskytované Qiskitem:

from qiskit import transpile
circuit = transpile(circuit, simulator_backend)

Funkce transpile vrátí nový objekt okruhu, kde jsou brány rozloženy do bran podporovaných v zadaném back-endu.

Program teď můžete spustit prostřednictvím služby Azure Quantum a získat výsledek. Následující buňka odešle úlohu, která spouští okruh s 100 snímky:

job = simulator_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)

Job id 00000000-0000-0000-0000-000000000000

Pokud chcete počkat na dokončení úlohy a vrátit výsledky, spusťte:

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)

Vzhledem k tomu, že výsledek je objekt nativní pro balíček Qiskit, můžete použít Qiskit result.get_counts a plot_histogram vizualizovat výsledky. Chcete-li zajistit, aby byly reprezentovány všechny možné popisky bitstringu, přidejte je do 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}

Výsledek obvodu Qiskit v simulátoru IonQ

Pomocí funkce můžete také get_memory() zobrazit jednotlivá zastřelená data z úlohy.

result.get_memory(circuit)

['000', '000', '000', '000', '111', '111', '111', '111']

Poznámka:

Pokud na IonQ targetsodešlete úlohu s lichým počtem snímků, výsledky se zaokrouhlí dolů na další sudé číslo. Pokud například zadáte 9 snímků, výsledky zobrazí data pro 8 snímků.

Odhad nákladů na úlohu

Před spuštěním úlohy v QPU byste měli odhadnout, kolik stojí na spuštění.

Nejaktuálnější podrobnosti o cenách najdete v tématu Ceny IonQ nebo vyhledejte svůj pracovní prostor a zobrazte cenové možnosti na kartě Poskytovatel vašeho pracovního prostoru prostřednictvím: aka.ms/aq/myworkspaces.

Spuštění v QPU IonQ

Pokud se chcete připojit k skutečnému hardwaru (QPU ), jednoduše zadejte název target"ionq.qpu.aria-1"get_backend metody:

qpu_backend = provider.get_backend("ionq.qpu.aria-1")

Odešlete okruh ke spuštění v Azure Quantum, získejte výsledky a spusťte plot_histogram ho, abyste výsledky vykreslili.

Poznámka:

Doba potřebná ke spuštění okruhu v QPU se může lišit v závislosti na aktuální době fronty.

# 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}

Výsledek obvodu Qiskit v QPU IonQ

Důležité

Odesílání více okruhů v jedné úloze se v současné době nepodporuje. Jako alternativní řešení můžete volat metodu backend.run pro asynchronní odeslání každého okruhu a pak načíst výsledky každé úlohy. Příklad:

jobs = []
for circuit in circuits:
    jobs.append(backend.run(circuit, shots=N))

results = []
for job in jobs:
    results.append(job.result())

Požadavky

Vytvoření nového poznámkového bloku v pracovním prostoru

  1. Přihlaste se k webu Azure Portal a vyberte pracovní prostor, který jste vytvořili v předchozím kroku.
  2. V levém okně vyberte Poznámkové bloky.
  3. Klikněte na Moje poznámkové bloky a klikněte na Přidat nový.
  4. Zadejte název souboru, například Qiskit.ipynb, a klikněte na Vytvořit soubor.

Když se nový poznámkový blok otevře, automaticky vytvoří kód pro první buňku na základě informací o vašem předplatném a pracovním prostoru.

from azure.quantum import Workspace
workspace = Workspace ( 
    resource_id = "", # Add your resource_id 
    location = ""  # Add your workspace location (for example, "westus") 
)

Poznámka:

Pokud není uvedeno jinak, měli byste při vytváření spustit každou buňku, abyste se vyhnuli problémům s kompilací.

Kliknutím na trojúhlou ikonu "přehrát" vlevo od buňky spusťte kód.

Načtení požadovaných importů

Nejprve budete muset importovat některé další moduly.

Kliknutím na + Kód přidejte novou buňku a pak přidejte a spusťte následující kód:

from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

Připojení ke službě Azure Quantum

Dále vytvořte AzureQuantumProvider objekt pomocí objektu Workspace z předchozí buňky pro připojení k pracovnímu prostoru Azure Quantum. Přidejte novou buňku s následujícím kódem:

provider = AzureQuantumProvider(workspace)

Definování jednoduchého okruhu

V nové buňce vytvořte circuit objekt. Tento příklad je jednoduchý kvantový generátor náhodných bitů. Přidejte následující kód pro definování a zobrazení okruhu:

# 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

Zobrazit seznam všech targets

Teď můžete zobrazit všechny kvantové výpočty targetsnebo back-endy, které jsou dostupné ve vašem pracovním prostoru. Přidejte novou buňku a spusťte následující řádek:

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

Vyberte program, který target chcete spustit.

Pokud chcete zkontrolovat kód před jeho spuštěním na skutečném kvantovém hardwaru, můžete použít kvantový simulátor IonQ. ionq.simulator

Přidejte novou buňku a vytvořte objekt představující kvantový simulátor targetIonQ:

# Get IonQ quantum simulator target:
simulator_backend = provider.get_backend("ionq.simulator")

Spuštění na simulátoru IonQ

Pokud chcete spustit okruh v simulátoru, přidejte následující kód. Tento příklad používá run metodu target odeslání úlohy a pak monitoruje stav úlohy.

# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)

Po úspěšném spuštění úlohy získejte výsledky úlohy a zobrazte je:

# 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)

Vzhledem k tomu, že tento result typ je objekt nativní pro balíček Qiskit, můžete použít Qiskit result.get_counts a plot_histogram vizualizovat výsledky. Chcete-li zajistit, aby byly reprezentovány všechny možné popisky bitstringu, přidejte je do 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}

Výsledek obvodu Qiskit v simulátoru IonQ

Pomocí funkce můžete také get_memory() zobrazit jednotlivá zastřelená data z úlohy.

result.get_memory(circuit)

['000', '000', '000', '000', '111', '111', '111', '111']

Poznámka:

Pokud na IonQ targetsodešlete úlohu s lichým počtem snímků, výsledky se zaokrouhlí dolů na další sudé číslo. Pokud například zadáte 9 snímků, výsledky zobrazí data pro 8 snímků.

Odhad nákladů na úlohu

Před spuštěním úlohy na skutečném kvantovém hardwaru nebo jednotce kvantového zpracování (QPU) byste měli odhadnout, kolik stojí na spuštění.

Nejaktuálnější podrobnosti o cenách najdete v tématu Ceny IonQ nebo vyhledejte pracovní prostor a v okně Poskytovatelé vašeho pracovního prostoru si prohlédněte cenové možnosti.

Spuštění v QPU IonQ

Po úspěšném spuštění úlohy na simulátoru IonQ a odhadu nákladů na QPU je čas spustit okruh na hardwaru.

Poznámka:

Doba potřebná ke spuštění okruhu v QPU se liší v závislosti na aktuálních časech fronty. Průměrnou dobu target fronty můžete zobrazit výběrem okna Poskytovatelé vašeho pracovního prostoru.

Použijte stejnou run metodu a operace, které jste dříve použili s validátorem rozhraní API k odeslání a monitorování úlohy:

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Po dokončení úlohy získejte výsledky úlohy jako předtím a zobrazte je v grafu:

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}

Výsledek obvodu Qiskit v QPU IonQ

Důležité

Odesílání více okruhů v jedné úloze se v současné době nepodporuje. Jako alternativní řešení můžete volat metodu backend.run pro asynchronní odeslání každého okruhu a pak načíst výsledky každé úlohy. Příklad:

jobs = []
for circuit in circuits:
    jobs.append(backend.run(circuit, shots=N))

results = []
for job in jobs:
    results.append(job.result())

Požadavky

Podrobnosti o instalaci najdete v tématu Nastavení rozšíření QDK.

  • Prostředí Python s nainstalovaným Python nástrojem Pip .

  • VS Code s nainstalovanou sadou Azure Quantum Development Kit a Python rozšířeními

  • Balíček Azure Quantum qsharpPython se značkami a qiskit značkamiwidget.

    python pip install "qsharp[qiskit,widgets]>=1.9"

    Důležité

    Ujistěte se, že máte nejnovější verzi Qiskitu. Další informace najdete v tématu Python azure-quantum.

Spuštění základního okruhu

Ve VS Code otevřete nový Python soubor, který definuje a spustí základní okruh pomocí integrovaného řídkého simulátoru v balíčku Qsharp.

# 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)

Pokud chcete program spustit, vyberte ikonu Spustit v pravém horním rohu a vyberte Spustit Python soubor. Výstup se zobrazí v novém okně terminálu.

                  ┌─────────────────────────┐┌─┐
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}

Generujte QIR pro okruh

Pomocí stejného okruhu můžete vygenerovat QIR, který se používá ke spuštění na kvantovém hardwaru.

Poznámka:

Při generování QIR musí být všechny registry změřeny. Pokud existují nějaké nepoužívané registry, vyvolá se chyba. Kromě toho se pokus o vygenerování QIR při nastavení profilu na Unrestricted vyvolá chybu. Profil Unrestricted je platný pouze pro simulaci. Musí se použít targetProfile.Base nebo TargetProfile.Adaptive_RI. target_profile lze přepsat ve volání backend.qir(...), aby se přepnuly profily.

  1. Import QSharpError a TargetProfile

    from qsharp import QSharpError, TargetProfile

  2. Úprava výstupu pro vygenerování QIR

        print(backend.qir(circuit, target_profile=TargetProfile.Adaptive_RI))

Váš kód by teď měl vypadat takto:

# 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))

s výstupem:

     ┌────────────┐             ┌─┐   
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}

Ne všechny programy můžou běžet na veškerém hardwaru. Tady můžete zkusit profil targetBase, ale obdržíme podrobné chyby o tom, které části programu nejsou podporované.

try:
    backend.qir(qc, target_profile=TargetProfile.Base)
except QSharpError as e:
    print(e)

Další kroky