Split the MeasureQubitArray task into two

MeasureQubitArray used to implement both the random basis selection and measurement processes. Now there are two separate tasks for these: RandomBasesArray and MeasureQubitArray.

Author: kurabirko

KeyDistribution_E91/KeyDistribution_E91.ipynb

@@ -31,7 +31,7 @@
    "cell_type": "code",
    "execution_count": null,
    "source": [
-    "operation EntangledPairs (qsAlice : Qubit[], qsBob : Qubit[]) : Unit {\n",
+    "operation EntangledPairs (qsAlice : Qubit[], qsBob : Qubit[]) : Unit is Adj{\n",
     "    Fact(Length(qsAlice) == Length(qsBob), \"Alice and Bob should have the same number of qubits\");\n",
     "    // ...\n",
     "\n",
@@ -97,7 +97,7 @@
     "\n",
     "**Inputs:**  \n",
     "1) `q`: the qubit to be measured\n",
-    "2) `basis_index`: The index of measurement operator to be used\n",
+    "2) `basisIndex`: The index of measurement operator to be used\n",
     "\n",
     "**Output:** The result of the measurement."
    ],
@@ -107,7 +107,7 @@
    "cell_type": "code",
    "execution_count": null,
    "source": [
-    "operation RotateAndMeasure(q : Qubit, rotationMultiplier: Int) : Result {\n",
+    "operation RotateAndMeasure(q : Qubit, basisIndex: Int) : Result {\n",
     "    // ...\n",
     "\n",
     "    return Zero;\n",
@@ -131,29 +131,53 @@
   {
    "cell_type": "markdown",
    "source": [
-    "#### Task 2.2 Measure Qubit Arrays\n",
+    "#### Task 2.2. Random Bases Array\n",
+    "\n",
+    "Using a list of possible measurement basis indices, create a random array of $N$ measurement bases.\n",
+    "\n",
+    "**Inputs:**  \n",
+    "1) `basesIndices`: An array of possible bases indices,\n",
+    "2) `N`: The length of the output aray.\n",
+    "\n",
+    "**Outputs:** An array of random bases indices."
+   ],
+   "metadata": {}
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "operation RandomBasesArray (basesIndices: Int[], N: Int) : Int[] {\n",
+    "    // ...\n",
+    "\n",
+    "    return new Int[N];\n",
+    "}"
+   ],
+   "outputs": [],
+   "metadata": {}
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "#### Task 2.3 Measure Qubit Arrays\n",
     "Measure either Alice's or Bob's qubits in bases constructed using randomly selected bases.\n",
     "\n",
     "**Inputs:**  \n",
     "1) `qs`: An array of qubits to be measured,\n",
-    "2) `basisList`: A list of possible basis indices for choosing measurement operators.\n",
+    "2) `basesIndices`: An array of random bases indices.\n",
     "\n",
-    "**Outputs:**\n",
-    "1) The list of basis choices,\n",
-    "2) The list of measurement results."
+    "**Outputs:** The list of measurement results."
    ],
    "metadata": {}
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "source": [
-    "operation MeasureQubitArray (qs: Qubit[], basisList: Int[]) : (Int[], Result[]) {\n",
-    "    let results = new Result[0];\n",
-    "    let bases = new Int[0];\n",
+    "operation MeasureQubitArray (qs: Qubit[], basesIndices: Int[]) : Result[] {\n",
     "    // ...\n",
     "\n",
-    "    return (bases, results);\n",
+    "    return new Result[0];\n",
     "\n",
     "}"
    ],
@@ -192,9 +216,9 @@
   {
    "cell_type": "markdown",
    "source": [
-    "#### Task 2.4 Putting it all together \n",
+    "#### Task 2.5 Putting it all together \n",
     "\n",
-    "Implement the entire BB84 protocol using tasks 1.1 - 2.3 and following the comments in the operation template. This is an open ended task."
+    "Implement the entire E91 protocol using tasks 1.1 - 2.4 and following the comments in the operation template. This is an open ended task."
    ],
    "metadata": {}
   },
@@ -203,9 +227,9 @@
    "execution_count": null,
    "source": [
     "operation T24_E91Protocol () : Unit {\n",
-    "    // 1. Alice and Bob choose basis multipliers\n",
+    "    // 1. Alice and Bob are distributed arrays of entangled pairs\n",
     "\n",
-    "    // 2. Alice and Bob are distributed arrays of entangled pairs\n",
+    "    // 2. Alice and Bob choose random measurement bases\n",
     "\n",
     "    // 3. Measurements by Alice and Bob\n",
     "\n",
@@ -259,7 +283,7 @@
    "cell_type": "code",
    "execution_count": null,
    "source": [
-    "function CorrelationCheck(basesAlice: Int[], basesBob: Int[], resAlice: Result[], resBob: Result[]) : Double {\n",
+    "function CorrelationCheck(basesAlice: Int[], basesBob: Int[], resultsAlice: Result[], resultsBob: Result[]) : Double {\n",
     "    // ...\n",
     "\n",
     "    return 0.0;\n",
@@ -289,7 +313,7 @@
     "**Inputs:**  \n",
     "1) `qAlice`: a qubit that Alice will use,\n",
     "2) `qBob`: Bob's corresponding qubit,\n",
-    "3) `basis`: Eve's guess of the basis she should use for measuring.\n",
+    "3) `basisIndex`: Eve's guess of the basis she should use for measuring.\n",
     "\n",
     "**Output:** the bits encoded in given qubits."
    ],
@@ -299,8 +323,8 @@
    "cell_type": "code",
    "execution_count": null,
    "source": [
-    "operation Eavesdrop (qAlice : Qubit, qBob : Qubit, basis : Int) : (Result, Result) {\n",
-    "    Fact(basis == 2 or basis == 3, \"Eve should measure in one of Alice's and Bob's compatible basis\");\n",
+    "operation Eavesdrop (qAlice : Qubit, qBob : Qubit, basisIndex : Int) : (Result, Result) {\n",
+    "    Fact(basisIndex == 2 or basisIndex == 3, \"Eve should measure in one of Alice's and Bob's compatible basis\");\n",
     "    // ...\n",
     "\n",
     "    return (Zero, Zero);\n",
@@ -314,7 +338,7 @@
    "source": [
     "#### Task 3.3. Catch the Eavesdropper\n",
     "\n",
-    "Add an eavesdropper into Task 2.4, then try to detect them using a CHSH correlation check. This is an open-ended task and is not covered by a test."
+    "Add an eavesdropper into Task 2.5, then try to detect them using a CHSH correlation check. This is an open-ended task and is not covered by a test."
    ],
    "metadata": {}
   },
@@ -323,12 +347,12 @@
    "execution_count": null,
    "source": [
     "operation T33_E91ProtocolWithEavesdropper() : Unit {\n",
-    "    // 1. Alice and Bob choose basis multipliers\n",
-    "\n",
-    "    // 2. Alice and Bob are distributed arrays of entangled pairs\n",
-    "\n",
+    "    // 1. Alice and Bob are distributed arrays of entangled pairs\n",
+    "    \n",
     "    // Eve eavesdrops on all qubits, guessing the basis at random\n",
     "\n",
+    "    // 2. Alice and Bob choose random measurement bases\n",
+    "\n",
     "    // 3. Measurements by Alice and Bob\n",
     "\n",
     "    // 4. Keys generated by Alice and Bob\n",

KeyDistribution_E91/ReferenceImplementation.qs

@@ -39,9 +39,9 @@ namespace Quantum.Kata.KeyDistributionE91 {
     //////////////////////////////////////////////////////////////////
 
     // Task 2.1 Rotate and Measure
-    operation RotateAndMeasure_Reference (q : Qubit, rotationMultiplier: Int) : Result {
+    operation RotateAndMeasure_Reference (q : Qubit, basisIndex: Int) : Result {
         mutable result = Zero;
-        let rotationAngle = PI() * IntAsDouble(rotationMultiplier) / 4.0;
+        let rotationAngle = PI() * IntAsDouble(basisIndex - 1) / 4.0;
 
         within {
             Ry(rotationAngle, q);
@@ -52,20 +52,31 @@ namespace Quantum.Kata.KeyDistributionE91 {
         return result;
     }
 
-    // Task 2.2 Measure Qubit Arrays
-    operation MeasureQubitArray_Reference (qs: Qubit[], basisList: Int[]) : (Int[], Result[]) {
-        mutable results = new Result[0];
+    // Task 2.2. Random Bases Array
+    operation RandomBasesArray_Reference (basesIndices: Int[], N: Int) : Int[] {
+        // ...
         mutable bases = new Int[0];
 
-        for q in qs {
-            let basis = basisList[DrawRandomInt(0,2)];
-            let res = RotateAndMeasure(q, basis);
+        for _ in 1..N {
+            let randomIndex = DrawRandomInt(0, Length(basesIndices) - 1);
+            set bases += [basesIndices[randomIndex]];
+        }
+
+        return bases;
+    }
+
+
+    // Task 2.2 Measure Qubit Arrays
+    operation MeasureQubitArray_Reference (qs: Qubit[], basesIndices: Int[]) : Result[] {
+        // ...
 
-            set bases += [basis];
-            set results += [res];
+        mutable results = new Result[0];
+
+        for (q, b) in Zipped(qs, basesIndices) {
+            set results += [RotateAndMeasure(q,b)];
         }
 
-        return (bases, results);
+        return results;
 
     }
 
@@ -82,17 +93,47 @@ namespace Quantum.Kata.KeyDistributionE91 {
         return key;
     }
 
-    // Task 2.4 CHSH Correlation Check
-    function CorrelationCheck_Reference (basesAlice: Int[], basesBob: Int[], resAlice: Result[], resBob: Result[]) : Double {
+    // Task 2.5 Putting it all together 
+    operation T25_E91Protocol_Reference () : Unit {
+        // 1. Alice and Bob are distributed arrays of entangled pairs
+        let N = 10;
+        use (qsAlice, qsBob) = (Qubit[N] ,Qubit[N]);
+        EntangledPairs(qsAlice, qsBob);
+
+        // 2. Alice and Bob choose random measurement bases
+        let basesAlice = RandomBasesArray([1,2,3], N);
+        let basesBob = RandomBasesArray([2,3,4], N);
+
+        // 3. Measurements by Alice and Bob
+        let resultsAlice = MeasureQubitArray(qsAlice, basesAlice);
+        let resultsBob = MeasureQubitArray(qsBob, basesBob);
+
+        // 4. Keys generated by Alice and Bob
+        let keyAlice = GenerateSharedKey(basesAlice, basesBob, resultsAlice);
+        let keyBob = GenerateSharedKey(basesAlice, basesBob, resultsBob);
+        Message($"Alice's Key: {keyAlice}");
+        Message($"Bob's Key:   {keyBob}\n");
+
+        // Reset all qubits to |0⟩
+        ResetAll(qsAlice + qsBob);
+        
+    }
+
+    //////////////////////////////////////////////////////////////////
+    // Part III. Eavesdropping
+    //////////////////////////////////////////////////////////////////
+
+    // Task 3.1 CHSH Correlation Check
+    function CorrelationCheck_Reference (basesAlice: Int[], basesBob: Int[], resultsAlice: Result[], resultsBob: Result[]) : Double {
         mutable expectationValues = new Double[0];
 
-        for (i, j) in [(0,1), (0, 3), (2, 1), (2, 3)] {
+        for (i, j) in [(1,2), (1, 4), (3, 2), (3, 4)] {
             mutable sum = 0;
             mutable counter = 0;
 
             for idx in IndexRange(basesAlice) {
                 if basesAlice[idx] == i and basesBob[idx] == j {
-                    if resAlice[idx] == resBob[idx] {
+                    if resultsAlice[idx] == resultsBob[idx] {
                         set sum += 1;
                     } else {
                         set sum -= 1;
@@ -115,79 +156,44 @@ namespace Quantum.Kata.KeyDistributionE91 {
         return s;
     }
 
-
-    // Task 2.5 Putting it all together 
-    operation T25_E91Protocol_Reference () : Unit {
-        // 1. Alice and Bob choose basis multipliers
-        let basisListAlice = [0, 1, 2];
-        let basisListBob = [1, 2, 3];
-
-        // 2. Alice and Bob are distributed arrays of entangled pairs
-        let N = 13;
-        use (qsAlice, qsBob) = (Qubit[N] ,Qubit[N]);
-        EntangledPairs(qsAlice, qsBob);
-
-        // 3. Measurements by Alice and Bob
-        let (basesAlice, resAlice) = MeasureQubitArray(qsAlice, basisListAlice);
-        let (basesBob, resBob) = MeasureQubitArray(qsBob, basisListBob);
-
-        // 4. Keys generated by Alice and Bob
-        let keyAlice = GenerateSharedKey(basesAlice, basesBob, resAlice);
-        let keyBob = GenerateSharedKey(basesAlice, basesBob, resBob);
-        Message($"Alice's Key: {keyAlice}");
-        Message($"Bob's Key:   {keyBob}\n");
-
-        // 5. Compute the CHSH correlation value
-        let s = CorrelationCheck(basesAlice, basesBob, resAlice, resBob);
-        Message($"S = {s}");
-
-        // Reset all qubits to |0⟩
-        ResetAll(qsAlice + qsBob);
-        
-    }
-
-    //////////////////////////////////////////////////////////////////
-    // Part III. Eavesdropping
-    //////////////////////////////////////////////////////////////////
-
-    // Task 3.1. Eavesdrop!
+    // Task 3.2. Eavesdrop!
     operation Eavesdrop_Reference (qAlice : Qubit, qBob : Qubit, basis : Int) : (Result, Result) {
-        Fact(basis == 1 or basis == 2, "Eve should measure in one of Alice's and Bob's compatible basis");
+        Fact(basis == 2 or basis == 3, "Eve should measure in one of Alice's and Bob's compatible basis");
 
-        let resAlice = RotateAndMeasure(qAlice, basis);
-        let resBob = RotateAndMeasure(qBob, basis);
+        let resultsAlice = RotateAndMeasure(qAlice, basis);
+        let resultsBob = RotateAndMeasure(qBob, basis);
 
-        return (resAlice, resBob);
+        return (resultsAlice, resultsBob);
     }
 
-    // Task 3.2. Catch the eavesdropper
+    // Task 3.3. Catch the eavesdropper
     operation T32_E91ProtocolWithEavesdropper_Reference () : Unit {
-        // 1. Alice and Bob choose basis multipliers
-        let basisListAlice = [0, 1, 2];
-        let basisListBob = [1, 2, 3];
-
-        // 2. Alice and Bob are distributed arrays of entangled pairs
-        let N = 13;
+        // 1. Alice and Bob are distributed arrays of entangled pairs
+        let N = 10;
         use (qsAlice, qsBob) = (Qubit[N] ,Qubit[N]);
         EntangledPairs(qsAlice, qsBob);
 
         // Eve eavesdrops on all qubits, guessing the basis at random
         for (qAlice, qBob) in Zipped(qsAlice, qsBob) {
-            let n = Eavesdrop(qAlice, qBob, DrawRandomInt(1,2));
+            let _ = Eavesdrop(qAlice, qBob, DrawRandomInt(1,2));
         }
 
+        // 2. Alice and Bob choose random measurement bases
+        let basesAlice = RandomBasesArray([1,2,3], N);
+        let basesBob = RandomBasesArray([2,3,4], N);
+
         // 3. Measurements by Alice and Bob
-        let (basesAlice, resAlice) = MeasureQubitArray(qsAlice, basisListAlice);
-        let (basesBob, resBob) = MeasureQubitArray(qsBob, basisListBob);
+        let resultsAlice = MeasureQubitArray(qsAlice, basesAlice);
+        let resultsBob = MeasureQubitArray(qsBob, basesBob);
 
         // 4. Keys generated by Alice and Bob
-        let keyAlice = GenerateSharedKey(basesAlice, basesBob, resAlice);
-        let keyBob = GenerateSharedKey(basesAlice, basesBob, resBob);
+        let keyAlice = GenerateSharedKey(basesAlice, basesBob, resultsAlice);
+        let keyBob = GenerateSharedKey(basesAlice, basesBob, resultsBob);
         Message($"Alice's Key: {keyAlice}");
         Message($"Bob's Key:   {keyBob}\n");
 
         // 5. Compute the CHSH correlation value
-        let s = CorrelationCheck(basesAlice, basesBob, resAlice, resBob);
+        let s = CorrelationCheck(basesAlice, basesBob, resultsAlice, resultsBob);
         Message($"S = {s}");
 
         // Reset all qubits to |0⟩