Visualisera kvantkretsdiagram med Q#

Kvantkretsdiagram är en visuell representation av kvantåtgärder. De visar flödet av kvantbitar genom kvantprogrammet, inklusive de grindar och mätningar som tillämpas på dem.

I den här artikeln får du lära dig hur du visuellt representerar kvantalgoritmer med kvantkretsdiagram med hjälp av Visual Studio Code eller Jupyter Notebooks.

Mer information om konventioner för kvantkretsdiagram finns i Quantum Circuits-konventioner.

Förutsättningar

VS-kod

• Den senaste versionen av Visual Studio Code eller öppna VS Code på webben.

• Den senaste versionen av Azure Quantum Development Kit-tillägget.

• De senaste Azure Quantum qsharp - och azure-quantum Python-paketen.

  python -m pip install --upgrade qsharp azure-quantum
  

Jupyter Notebook

• Den senaste versionen av Visual Studio Code eller öppna VS Code på webben.

• VS Code med Tilläggen Azure Quantum Development Kit, Python och Jupyter installerade.

• De senaste Azure Quantum qsharp och qsharp-widgets paketen ipykernel och paketet.

  python -m pip install --upgrade qsharp qsharp-widgets ipykernel
  

Kvantkretsar med Visual Studio Code

Följ de här stegen för att visualisera kvantkretsar i Q# program i Visual Studio Code. Mer information om konventioner för kvantkretsdiagram finns i Quantum Circuits-konventioner.

Visa kretsdiagram för ett Q# program

1. Öppna en Q# fil i Visual Studio Code eller läs in något av kvantexemplen.

2. Om du vill visualisera programmets Q# kvantkrets väljer du Visa –> kommandopalett och skriver "krets" som ska ta upp Q#alternativet : Visa krets . Du kan också klicka på Krets i listan med kommandon nedan @EntryPoint().

   

3. Kretsen visas i Q# kretsfönstret. Följande krets motsvarar till exempel en åtgärd som placerar en kvantbit i en superposition och sedan mäter den. Kretsdiagrammet visar ett qubitregister som initieras till tillståndet |0⟩. Sedan tillämpas en Hadamard-grind, H, på kvantbiten, följt av en mätningsåtgärd som representeras av en mätarsymbol.

   

Visa kretsdiagram för åtgärder

Du kan visualisera kvantkretsen för en enda Q# åtgärd. Det gör du genom att klicka på knappen Krets i kodlinsen som visas ovanför åtgärdsdeklarationen.

Visa kretsdiagram vid felsökning

När du felsöker ett Q# program kan du visualisera kvantkretsen baserat på programmets aktuella tillstånd.

1. Välj knappen Felsök i listan med kodobjektivkommandon nedan @EntryPoint().

2. I vyn Kör och felsöka till vänster expanderar du avsnittet Kvantkrets under fönstret Variabler för att visa kretsen när du går igenom programmet.

   

3. Du kan gå igenom koden och ange brytpunkter i olika punkter för att se kretsuppdateringen när programmet körs.

4. Den aktuella kvantkretsen visas på panelen Q#Krets. Det här kretsdiagrammet representerar simulatorns aktuella tillstånd, det vill säga de portar som har tillämpats fram till den aktuella körningspunkten.

   

Kvantkretsar med Jupyter Notebooks

I Jupyter Notebooks kan du visualisera kvantkretsar med hjälp av qsharp-widgets paketet. Det här paketet innehåller en widget som renderar ett kvantkretsdiagram som en SVG-avbildning.

1. I Visual Studio Code väljer du Visa > kommandopalett och väljer Skapa: Ny Jupyter Notebook.

2. I den första cellen i notebook-filen kör du följande kod för att importera modulenQ#.

   import qsharp
   

3. Lägg till en ny cell och ange Q# koden. Följande kod förbereder till exempel ett klocktillstånd.

   %%qsharp
   
   // Prepare a Bell State.
   use register = Qubit[2];
   H(register[0]);
   CNOT(register[0], register[1]);
   

4. Du kan använda dump_circuit() funktionen för att visa en kvantkrets baserat på programmets aktuella tillstånd. Kretsdiagrammet visar till exempel två qubitregister som initieras till tillståndet |0⟩. Sedan appliceras en Hadamard-grind, H, på den första qubiten. Därefter tillämpas en CNOT-grind med hjälp av den första qubiten som kontroll, som representeras som en punkt, och den andra qubiten som target, som representeras som ett X.

   qsharp.dump_circuit()
   

   q_0    ── H ──── ● ──
   q_1    ───────── X ──
   

5. Du kan visualisera kvantkretsar som en SVG-avbildning med hjälp qsharp-widgets av paketet. I det här fallet representeras CNOT-grinden som en linje som förbinder de två kvantbitarna med en punkt på kontrollkvabiten och ett begränsat kors på qubiten target . Mer information finns i Konventioner för kvantkretsar.

   from qsharp_widgets import Circuit
   
   Circuit(qsharp.dump_circuit())
   

   

Visa kretsdiagram för ett inmatningsuttryck

Du kan generera ett kretsdiagram för valfritt program med ett postuttryck genom att anropa qsharp.circuit() och skicka inmatningsuttrycket som ett argument.

1. Lägg till exempel till en ny cell och kopiera följande kod, som förbereder ett GHZ-tillstånd.

   %%qsharp
   
   open Microsoft.Quantum.Diagnostics;
   open Microsoft.Quantum.Measurement;
   
   operation GHZSample(n: Int) : Result[] {
       use qs = Qubit[n];
   
       H(qs[0]);
       ApplyToEach(CNOT(qs[0], _), qs[1...]);
   
       let results = MeasureEachZ(qs);
       ResetAll(qs);
       return results;
   }
   

2. Lägg till en ny cell och kör följande kod för att visualisera kretsen. Förbered till exempel ett GHZ-tillstånd med 3 qubits.

   Circuit(qsharp.circuit("GHZSample(3)"))
   

Visa kretsdiagram för åtgärder med kvantbitar

Du kan generera kretsdiagram för alla åtgärder som tar kvantbitar eller matriser med kvantbitar. Diagrammet visar så många kablar som det finns indatakvabit, plus eventuella ytterligare kvantbitar som allokeras inom åtgärden. När åtgärden tar en matris med kvantbitar (Qubit[])visar kretsen matrisen som ett register med 2 kvantbitar.

1. Lägg till en ny cell och kopiera följande exempel. Den här koden förbereder ett katttillstånd.

   %%qsharp
   
   operation PrepareCatState(register : Qubit[]) : Unit {
       H(register[0]);
       ApplyToEach(CNOT(register[0], _), register[1...]);
   }
   

2. Lägg till en ny cell och kör följande kod för att visualisera kretsen för PrepareCatState åtgärden.

   Circuit(qsharp.circuit(operation="PrepareCatState"))
   

Villkor som påverkar kretsdiagram

När du visualiserar kvantkretsar kan följande villkor påverka visualiseringen av kretsdiagrammet.

Dynamiska kretsar

Kretsdiagram genereras genom att köra all klassisk logik i ett Q# program och hålla reda på eventuella kvantbitar som har allokerats eller portar som har tillämpats. Loopar och villkor stöds så länge de bara hanterar klassiska värden.

Program som innehåller loopar och villkorsuttryck som använder qubitmätningsresultat är dock svårare att representera med ett kretsdiagram. Till exempel ett uttryck som följande

if (M(q) == One) {
   X(q)
}

kan inte representeras med ett enkelt kretsdiagram, eftersom grindarna är villkorade av ett mätresultat. En sådan krets kallas för en dynamisk krets.

Kretsdiagram kan genereras för dynamiska kretsar genom att köra programmet i kvantsimulatorn och spåra portarna när de tillämpas. Detta kallas spårningsläge eftersom kvantbitar och portar spåras när simuleringen utförs.

Nackdelen med spårningskretsar är att de bara avbildar mätresultatet och de efterföljande gateprogrammen för en enda simulering. I exemplet ovan ser du inte grinden X i diagrammet om mätresultatet är Zero. En annan körning av simuleringen kan visa en något annorlunda krets.

Målprofil

Den markerade target profilen påverkar hur kretsdiagram genereras. Målprofiler används för att ange funktionerna i maskinvaran target och de begränsningar som gäller för kvantprogrammet.

När profilen target är inställd på Obegränsad eller QIR Adaptiv RI visar kretsdiagrammen de kvantåtgärder som anropas i programmet Q# . När profilen target är inställd på QIR-bas visar kretsdiagrammen de kvantåtgärder som skulle köras på maskinvara om programmet skickas till Azure Quantum med den här target profilen.

Kommentar

• Om du vill välja profilen target i VS Code väljer du Visa –> kommandopalett och väljer Q#: Ange Azure Quantum QIR-profilentarget. Du kan välja QIR base, QIR Adaptive RIeller unrestricted i listrutan.

• Om du vill välja profilen target i Python anropar du qsharp.init(target_profile=qsharp.TargetProfile.Base)eller qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI)qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted).

Mer specifikt tillämpas port nedbrytningar som skulle göra den resulterande kretsen kompatibel med funktionerna i maskinvaran target . Det här är samma nedbrytningar som skulle tillämpas under kodgenerering och överföring till Azure Quantum.

1. Tänk dig till exempel följande Q# program som mäter en qubit och en matris med kvantbitar.

   namespace Sample {
       open Microsoft.Quantum.Measurement;
   
       @EntryPoint()
       operation Main() : (Result, Result[]) {
           // The `M` operation performs a measurement of a single qubit in the
           // computational basis, also known as the Pauli Z basis.
           use q = Qubit();
           let result = M(q);
           Reset(q);
   
           // The `MeasureEachZ` operation measures each qubit in an array in the
           // computational basis and returns an array of `Result` values.
           use qs = Qubit[2];
           let results = MeasureEachZ(qs);
   
           return (result, results);
       }
   }
   

2. När target profilen är inställd på Obegränsad eller QIR Adaptiv RI motsvarar portarna som visas på kretsen exakt de kvantåtgärder som anropas i Q# programmet.

   

3. När profilen target är QIR-bas ser kretsen annorlunda ut. Eftersom basprofilen targets inte tillåter återanvändning av kvantbitar efter mätning utförs mätningen nu på en sammanflätade kvantbit i stället. Eftersom Reset åtgärden inte stöds i basprofilen tas den bort. Den resulterande kretsen matchar vad som skulle köras på maskinvaran om det här programmet skickas till Azure Quantum med den här target profilen.