Teleportation Task 1.2-1.4 added

katas/content/index.json

@@ -14,5 +14,6 @@
   "oracles",
   "deutsch_algo",
   "deutsch_jozsa",
-  "qec_shor"
+  "qec_shor",
+  "teleportation"
 ]

katas/content/teleportation/Common.qs

@@ -1,7 +1,7 @@
 namespace Kata.Verification {
-
-    open Microsoft.Quantum.Intrinsic;
     open Microsoft.Quantum.Diagnostics;
+    open Microsoft.Quantum.Math;
+
     operation EntangleWrapper_Reference(qs : Qubit[]) : Unit is Adj + Ctl {
         let (qAlice, qBob) = (qs[0], qs[1]);
         H(qAlice);
@@ -14,7 +14,7 @@ namespace Kata.Verification {
     // 1 - |Φ⁻⟩ = (|00⟩ - |11⟩) / sqrt(2)
     // 2 - |Ψ⁺⟩ = (|01⟩ + |10⟩) / sqrt(2)
     // 3 - |Ψ⁻⟩ = (|01⟩ - |10⟩) / sqrt(2)
-    operation StatePrep_BellState (q1 : Qubit, q2 : Qubit, state : Int) : Unit {
+    operation StatePrep_BellState(q1 : Qubit, q2 : Qubit, state : Int) : Unit {
         H(q1);
         CNOT(q1, q2);
 
@@ -30,18 +30,15 @@ namespace Kata.Verification {
     }
 
     // ------------------------------------------------------
-    // Helper operation that runs teleportation using two building blocks
-    // specified as first two parameters.
-    operation ComposeTeleportation (
-        setupPsiOp : (Qubit => Unit is Adj),
+    // Helper operation that run teleportation using the given operations to prepare the message qubit
+    // and the entangled pair, and to run sender and receiver parts of the protocol.
+    operation ComposeTeleportation(
         bellPrepOp : ((Qubit, Qubit) => Unit), 
         getDescriptionOp : ((Qubit, Qubit) => (Bool, Bool)), 
-        reconstructOp : ((Qubit, (Bool, Bool)) => Unit), 
+        reconstructOp : ((Qubit, (Bool, Bool)) => Unit),
         qAlice : Qubit, 
         qBob : Qubit, 
         qMessage : Qubit) : Unit {
-
-        setupPsiOp(qMessage);
 
         bellPrepOp(qAlice, qBob);
         let classicalBits = getDescriptionOp(qAlice, qMessage);
@@ -50,13 +47,14 @@ namespace Kata.Verification {
         // Bob uses these bits to transform his part of the entangled pair into the message.
         reconstructOp(qBob, classicalBits);
     }
+
     operation SendMessage_Reference(qAlice: Qubit, qMessage: Qubit) : (Bool, Bool) {
         CNOT(qMessage, qAlice);
         H(qMessage);
         return (M(qMessage) == One, M(qAlice) == One);
     }
 
-    operation ReconstructMessage_Reference (qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
+    operation ReconstructMessage_Reference(qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
         if b1 {
             Z(qBob);
         }
@@ -65,47 +63,61 @@ namespace Kata.Verification {
         }
     }
 
-    operation CheckTeleportationWithFeedback(protocolTeleportation : (((Qubit => Unit is Adj),Qubit,Qubit,Qubit) => Unit)) : Bool {
-        let numRepetitions = 100;
-        let setupPsiOps = [I, X, H, Ry(42.0, _)];
-        let operationName = ["|0>","|1>","|+>","Unequal Superposition"];
-        mutable index = 0;
-        while index < Length(setupPsiOps) {
-            use (qAlice, qBob, qMessage) = (Qubit(),Qubit(),Qubit());
-            protocolTeleportation(setupPsiOps[index],qAlice,qBob,qMessage);
-            Adjoint (setupPsiOps[index])(qBob);
-            if not CheckZero(qBob){
-                Message($"Incorrect. {operationName[index]} state was teleported incorrectly.");
-                ResetAll([qMessage, qAlice, qBob]);
-                return false;
-            }
+    // ------------------------------------------------------
+    // Helper operation that runs a teleportation operation (specified by teleportOp).
+    // The state to teleport is set up using an operation (specified by setupPsiOp).
+    //
+    // Specifying the state to teleport through an operation allows to get the inverse
+    // which makes testing easier.
+    operation TeleportTestHelper(
+        teleportOp : ((Qubit, Qubit, Qubit) => Unit), 
+        setupPsiOp : (Qubit => Unit is Adj)) : Bool {
+
+        use (qMessage, qAlice, qBob) = (Qubit(), Qubit(), Qubit());
+        setupPsiOp(qMessage);
+
+        // This should modify qBob to be identical to the state
+        // of qMessage before the function call.
+        teleportOp(qAlice, qBob, qMessage);
+
+        // Applying the inverse of the setup operation to qBob
+        // should make it Zero.
+        Adjoint setupPsiOp(qBob);
+        if not CheckZero(qBob){
+            Message("Incorrect. The state was teleported incorrectly.");
+            DumpMachine();
             ResetAll([qMessage, qAlice, qBob]);
-            set index += 1;
+            return false;
         }
+        ResetAll([qMessage, qAlice, qBob]);
         Message("Correct.");
         return true;
     }
 
-    operation CheckTeleportationCompleteWithFeedback(protocolTeleportation : ((Qubit,Qubit,Qubit) => Unit)) : Bool {
+    // ------------------------------------------------------
+    // Run teleportation for a number of different states.
+    // After each teleportation success is asserted.
+    // Also repeats for each state several times as
+    // code is expected to take different paths each time because
+    // measurements done by Alice are not deterministic.
+    operation TeleportTestLoop(teleportOp : ((Qubit, Qubit, Qubit) => Unit)) : Bool {
+        // Define setup operations for the message qubit
+        // on which to test teleportation: |0⟩, |1⟩, |0⟩ + |1⟩, unequal superposition.
+        let setupPsiOps = [I, X, H, Ry(ArcCos(0.6) * 2.0, _)];
+
+        // As part of teleportation Alice runs some measurements
+        // with nondeterministic outcome.
+        // Depending on the outcomes different paths are taken on Bob's side.
+        // We repeat each test run several times to ensure that all paths are checked.
         let numRepetitions = 100;
-        let setupPsiOps = [I, X, H, Ry(42.0, _)];
-        let operationName = ["|0>","|1>","|+>","Unequal Superposition"];
-        mutable index = 0;
-        while index < Length(setupPsiOps) {
-            use (qAlice, qBob, qMessage) = (Qubit(),Qubit(),Qubit());
-            (setupPsiOps[index]) (qMessage);
-            protocolTeleportation(qAlice,qBob,qMessage);
-            Adjoint (setupPsiOps[index])(qBob);
-            if not CheckZero(qBob){
-                Message($"Incorrect. {operationName[index]} state was teleported incorrectly.");
-                ResetAll([qMessage, qAlice, qBob]);
-                return false;
+        for psiOp in setupPsiOps {
+            for j in 1 .. numRepetitions {
+                let validation = TeleportTestHelper(teleportOp, psiOp);
+                if not validation{
+                    return false;
+                }
             }
-            ResetAll([qMessage, qAlice, qBob]);
-            set index += 1;
         }
-        Message("Correct.");
         return true;
     }
-
 }

katas/content/teleportation/index.md

@@ -36,8 +36,8 @@ We split the teleportation protocol into several steps:
 
 @[exercise]({
     "id": "teleportation__send_message",
-    "title": "Send the message (Alice's task)",
-    "path": "./send_the_message/",
+    "title": "Send Message (Alice's Task)",
+    "path": "./send_message/",
     "qsDependencies": [
         "../KatasLibrary.qs",
         "./Common.qs"
@@ -46,8 +46,8 @@ We split the teleportation protocol into several steps:
 
 @[exercise]({
     "id": "teleportation__reconstruct_message",
-    "title": "Reconstruct the message (Bob's task)",
-    "path": "./reconstruct_the_message/",
+    "title": "Reconstruct Message (Bob's Task)",
+    "path": "./reconstruct_message/",
     "qsDependencies": [
         "../KatasLibrary.qs",
         "./Common.qs"

katas/content/teleportation/reconstruct_message/Placeholder.qs

@@ -0,0 +1,5 @@
+namespace Kata {
+    operation ReconstructMessage(qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
+        // ...
+    }
+}

katas/content/teleportation/reconstruct_the_message/Solution.qs → katas/content/teleportation/reconstruct_message/Solution.qs

@@ -1,5 +1,5 @@
 namespace Kata {
-    operation ReconstructMessage (qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
+    operation ReconstructMessage(qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
         if b1 {
             Z(qBob);
         }

katas/content/teleportation/reconstruct_message/Verification.qs

@@ -0,0 +1,10 @@
+namespace Kata.Verification {
+    open Microsoft.Quantum.Diagnostics;
+    open Microsoft.Quantum.Katas;
+
+    @EntryPoint()
+    operation CheckSolution() : Bool {
+        let teleport = ComposeTeleportation(StatePrep_BellState(_, _, 0), SendMessage_Reference, Kata.ReconstructMessage, _, _, _);
+        return TeleportTestLoop(teleport);  
+    }
+}

katas/content/teleportation/reconstruct_the_message/index.md → katas/content/teleportation/reconstruct_message/index.md

@@ -1,8 +1,8 @@
 Transform Bob's qubit into the required state using the two classical bits received from Alice.
 
-**Input:** 
-1. Bob's part of the entangled pair of qubits qBob.
+**Inputs:** 
+1. Bob's part of the entangled pair of qubits `qBob`.
 2. The tuple of classical bits received from Alice, in the format used in previous exercise.
 
-**Output:**  
+**Output:** 
 Transform Bob's qubit qBob into the state in which the message qubit had been originally.

katas/content/teleportation/send_the_message/Placeholder.qs → katas/content/teleportation/send_message/Placeholder.qs

@@ -1,5 +1,5 @@
 namespace Kata {
-    operation SendMessage (qAlice : Qubit, qMessage : Qubit) : (Bool, Bool) {
+    operation SendMessage(qAlice : Qubit, qMessage : Qubit) : (Bool, Bool) {
         // Implement your solution here...
         return (false, false);
     }

katas/content/teleportation/send_the_message/Solution.qs → katas/content/teleportation/send_message/Solution.qs

@@ -1,5 +1,5 @@
 namespace Kata {
-    operation SendMessage (qAlice : Qubit, qMessage : Qubit) : (Bool, Bool) {
+    operation SendMessage(qAlice : Qubit, qMessage : Qubit) : (Bool, Bool) {
         CNOT(qMessage, qAlice);
         H(qMessage);
         return (M(qMessage) == One, M(qAlice) == One);

katas/content/teleportation/send_message/Verification.qs

@@ -0,0 +1,10 @@
+namespace Kata.Verification {
+    open Microsoft.Quantum.Diagnostics;
+    open Microsoft.Quantum.Katas;
+
+    @EntryPoint()
+    operation CheckSolution() : Bool {        
+        let teleport = ComposeTeleportation(StatePrep_BellState(_, _, 0), Kata.SendMessage, ReconstructMessage_Reference, _, _, _);
+        return TeleportTestLoop(teleport);        
+    }
+}

katas/content/teleportation/send_message/index.md

@@ -0,0 +1,8 @@
+Entangle the message qubit with Alice's qubit and extract two classical bits to be sent to Bob.
+
+**Inputs:** 
+1. Alice's part of the entangled pair of qubits `qAlice`.
+2. The message qubit `qMessage`.
+
+**Output:** 
+Two classical bits Alice will send to Bob via classical channel as a tuple of Boolean values. The first bit in the tuple should hold the result of measurement of the message qubit, the second bit - the result of measurement of Alice's qubit. Represent measurement result `One` as `true` and `Zero` as `false`. The state of the qubits in the end of the operation doesn't matter.

katas/content/teleportation/standard_teleportation_protocol/Placeholder.qs

@@ -1,5 +1,26 @@
 namespace Kata {
-    operation StandardTeleport (qAlice : Qubit, qBob : Qubit, qMessage : Qubit) : Unit {
-        // ...
+    operation StandardTeleport(qAlice : Qubit, qBob : Qubit, qMessage : Qubit) : Unit {
+        //..
+    }
+
+    // You might find these helper operations from earlier tasks useful.
+    operation Entangle(qAlice : Qubit, qBob : Qubit) : Unit is Adj + Ctl {
+        H(qAlice);
+        CNOT(qAlice, qBob);
+    }
+
+    operation SendMessage(qAlice: Qubit, qMessage: Qubit) : (Bool, Bool) {
+        CNOT(qMessage, qAlice);
+        H(qMessage);
+        return (M(qMessage) == One, M(qAlice) == One);
+    }
+
+    operation ReconstructMessage(qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
+        if b1 {
+            Z(qBob);
+        }
+        if b2 {
+            X(qBob);
+        }
     }
 }

katas/content/teleportation/standard_teleportation_protocol/Solution.qs

@@ -1,4 +1,9 @@
 namespace Kata {
+    operation StandardTeleport(qAlice : Qubit, qBob : Qubit, qMessage : Qubit) : Unit {
+        Entangle(qAlice, qBob);
+        let classicalBits = SendMessage(qAlice, qMessage);
+        ReconstructMessage(qBob, classicalBits);
+    }
 
     operation Entangle(qAlice : Qubit, qBob : Qubit) : Unit is Adj + Ctl {
         H(qAlice);
@@ -11,17 +16,12 @@ namespace Kata {
         return (M(qMessage) == One, M(qAlice) == One);
     }
 
-    operation ReconstructMessage (qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
+    operation ReconstructMessage(qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
         if b1 {
             Z(qBob);
         }
         if b2 {
             X(qBob);
         }
     }
-    operation StandardTeleport (qAlice : Qubit, qBob : Qubit, qMessage : Qubit) : Unit {
-        Entangle(qAlice, qBob);
-        let classicalBits = SendMessage(qAlice, qMessage);
-        ReconstructMessage(qBob, classicalBits);
-    }
 }

katas/content/teleportation/standard_teleportation_protocol/Verification.qs

@@ -1,10 +1,10 @@
 namespace Kata.Verification {
-    open Microsoft.Quantum.Diagnostics;
     open Microsoft.Quantum.Katas;
 
     @EntryPoint()
-    operation CheckSolution() : Bool {        
-        return CheckTeleportationCompleteWithFeedback(Kata.StandardTeleport);
+    operation CheckSolution() : Bool {
+        let teleport = Kata.StandardTeleport(_, _, _);
+        return TeleportTestLoop(teleport);
     }
 
 }

katas/content/teleportation/standard_teleportation_protocol/index.md

@@ -1,8 +1,8 @@
 Put together the steps implemented in previous three exercises to implement the full teleportation protocol.
 
-**Input:** 
-1. The two qubits qAlice and qBob in $\ket{0}$ state.
-2. The message qubit qMessage in the state $\ket{\psi}$ to be teleported.
+**Inputs:** 
+1. The two qubits `qAlice` and `qBob` in $\ket{0}$ state.
+2. The message qubit `qMessage` in the state $\ket{\psi}$ to be teleported.
 
-**Output:**  
+**Goal:** 
 Transform Bob's qubit qBob into the state $\ket{\psi}$. The state of the qubits qAlice and qMessage in the end of the operation doesn't matter.