Migrate tasks 6-10 from MarkingOracles Kata

katas/content/KatasLibrary.qs

@@ -332,15 +332,5 @@ namespace Microsoft.Quantum.Katas {
             }
         }
         return true;
-    }
-
-    function F_PeriodicGivenPeriod(args : Bool[], P : Int) : Bool {
-        let N = Length(args);
-        for i in 0 .. N - P - 1 {
-            if args[i] != args[i + P] {
-                return false;
-            }
-        }
-        return true;
-    }
+    } 
 }

katas/content/marking_oracles/Common.qs

@@ -0,0 +1,20 @@
+namespace Kata.Verification {   
+    function F_PeriodicGivenPeriod(args : Bool[], P : Int) : Bool {
+        let N = Length(args);
+        for i in 0 .. N - P - 1 {
+            if args[i] != args[i + P] {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    function  F_ContainsSubstringAtPosition(args : Bool[], r : Bool[], p : Int) : Bool {
+        for i in 0 .. Length(r) - 1 {
+            if r[i] != args[i + p] {
+                return false;
+            }
+        }
+        return true;
+    }     
+}

katas/content/marking_oracles/balanced/Placeholder.qs

@@ -0,0 +1,6 @@
+namespace Kata {
+    operation Oracle_Balanced (x : Qubit[], y : Qubit) : Unit is Adj + Ctl {
+        // Implement your solution here...
+
+    }
+}

katas/content/marking_oracles/balanced/Solution.qs

@@ -0,0 +1,23 @@
+namespace Kata {
+    open Microsoft.Quantum.Math;
+
+    operation Oracle_Balanced (x : Qubit[], y : Qubit) : Unit is Adj + Ctl {
+        let N = Length(x);
+        let log = BitSizeI(N);
+        use inc = Qubit[log];
+        within {
+            for q in x {
+                Controlled IncrementBE([q], inc);
+            }
+        } apply {
+            ApplyControlledOnInt(N / 2, X, inc, y);
+        }
+    }
+
+    operation IncrementBE (register : Qubit[]) : Unit is Adj + Ctl {
+        if Length(register) > 1 {
+            Controlled IncrementBE([register[0]], register[1 ...]);
+        }
+        X(register[0]);
+    }    
+}

katas/content/marking_oracles/balanced/Verification.qs

@@ -0,0 +1,21 @@
+namespace Kata.Verification {
+    open Microsoft.Quantum.Katas;
+    open Microsoft.Quantum.Arrays;
+
+    function F_Balanced(args : Bool[]) : Bool {
+        return Count(x -> x, args) == Length(args) / 2;
+    }
+
+    @EntryPoint()
+    operation CheckSolution() : Bool {
+        for n in 2 .. 2 .. 6 {
+            if not CheckOracleImplementsFunction(n, Kata.Oracle_Balanced, F_Balanced) {
+                Message($"Test failed for n = {n}");
+                return false;
+            }
+        }
+
+        Message("Correct!");
+        true
+    }
+}

katas/content/marking_oracles/balanced/index.md

@@ -0,0 +1,12 @@
+**Inputs:** 
+
+1. $N$ qubits in an arbitrary state $\ket{x}$ (input/query register).
+2. A qubit in an arbitrary state $\ket{y}$ (output/target qubit).
+
+**Goal:** 
+Implement a quantum oracle which checks whether the input register is a balanced bit string, i.e., whether it contains exactly $N/2$ $0$'s and $N/2$ $1$'s. $N$ will be an even number.
+
+For example, for $N = 4$ basis states $\ket{0011}$ and $\ket{0101}$ are balanced, and $\ket{0010}$ and $\ket{1111}$ are not.
+
+Leave the qubits in the input register in the same state they started in.
+Your solution should work on inputs in superposition, and not use any measurements.

katas/content/marking_oracles/balanced/solution.md

@@ -0,0 +1,6 @@
+[placeholder for solution text]
+
+@[solution]({
+    "id": "marking_oracles__balanced_solution",
+    "codePath": "./Solution.qs"
+})

katas/content/marking_oracles/bit_sum_div_3/Placeholder.qs

@@ -0,0 +1,6 @@
+namespace Kata {
+    operation Oracle_BitSumDivisibleBy3 (x : Qubit[], y : Qubit) : Unit is Adj + Ctl {
+        // Implement your solution here...
+
+    }
+}

katas/content/marking_oracles/bit_sum_div_3/Solution.qs

@@ -0,0 +1,19 @@
+namespace Kata {
+    operation Oracle_BitSumDivisibleBy3 (x : Qubit[], y : Qubit) : Unit is Adj + Ctl {
+        use counter = Qubit[2];
+        within {
+            for q in x {
+                Controlled IncrementMod3([q], counter);
+            }
+        } apply {
+            ApplyControlledOnInt(0, X, counter, y);
+        }
+    }
+
+    operation IncrementMod3 (counterRegister : Qubit[]) : Unit is Adj + Ctl {
+        let sum = counterRegister[0];
+        let carry = counterRegister[1];
+        ApplyControlledOnInt(0, X, [carry], sum);
+        ApplyControlledOnInt(0, X, [sum], carry);
+    }    
+}

katas/content/marking_oracles/bit_sum_div_3/Verification.qs

@@ -0,0 +1,21 @@
+namespace Kata.Verification {
+    open Microsoft.Quantum.Katas;
+    open Microsoft.Quantum.Arrays;
+
+    function F_BitSumDivisibleBy3(args : Bool[]) : Bool {
+        return Count(x -> x, args) % 3 == 0;
+    }
+
+    @EntryPoint()
+    operation CheckSolution() : Bool {
+        for n in 3 .. 6 {
+            if not CheckOracleImplementsFunction(n, Kata.Oracle_BitSumDivisibleBy3, F_BitSumDivisibleBy3) {
+                Message($"Test failed for n = {n}");
+                return false;
+            }
+        }
+
+        Message("Correct!");
+        true
+    }
+}

katas/content/marking_oracles/bit_sum_div_3/index.md

@@ -0,0 +1,12 @@
+**Inputs:** 
+
+1. $N$ qubits in an arbitrary state $\ket{x}$ (input/query register).
+2. A qubit in an arbitrary state $\ket{y}$ (output/target qubit).
+
+**Goal:** 
+Implement a quantum oracle which checks whether the sum of bits in the bit string is divisible by $3$.
+
+For example, for $N = 3$ the only basis states that should be marked are $\ket{000}$ and $\ket{111}$.
+
+Leave the qubits in the input register in the same state they started in.
+Your solution should work on inputs in superposition, and not use any measurements.

katas/content/marking_oracles/bit_sum_div_3/solution.md

@@ -0,0 +1,6 @@
+[placeholder for solution text]
+
+@[solution]({
+    "id": "marking_oracles__bit_sum_div_3_solution",
+    "codePath": "./Solution.qs"
+})

katas/content/marking_oracles/contains_substring/Placeholder.qs

@@ -0,0 +1,11 @@
+namespace Kata {
+    operation Oracle_ContainsSubstring (x : Qubit[], y : Qubit, r : Bool[]) : Unit is Adj + Ctl {
+        // Implement your solution here...
+
+    }  
+
+    // You might find this helper operation from an earlier task useful.  
+    operation Oracle_ContainsSubstringAtPosition (x : Qubit[], y : Qubit, r : Bool[], p : Int) : Unit is Adj + Ctl {
+        ApplyControlledOnBitString(r, X, x[p .. p + Length(r) - 1], y);
+    }     
+}

katas/content/marking_oracles/contains_substring/Solution.qs

@@ -0,0 +1,19 @@
+namespace Kata {
+    operation Oracle_ContainsSubstring (x : Qubit[], y : Qubit, r : Bool[]) : Unit is Adj + Ctl {
+        let N = Length(x);
+        let K = Length(r);
+        use aux = Qubit[N - K + 1];
+        within {
+            for P in 0 .. N - K {
+                Oracle_ContainsSubstringAtPosition(x, aux[P], r, P);
+            }
+        } apply {
+            ApplyControlledOnInt(0, X, aux, y);
+            X(y);
+        }
+    }
+
+    operation Oracle_ContainsSubstringAtPosition (x : Qubit[], y : Qubit, r : Bool[], p : Int) : Unit is Adj + Ctl {
+        ApplyControlledOnBitString(r, X, x[p .. p + Length(r) - 1], y);
+    }    
+}

katas/content/marking_oracles/contains_substring/Verification.qs

@@ -0,0 +1,32 @@
+namespace Kata.Verification {
+    open Microsoft.Quantum.Katas;
+
+    function F_ContainsSubstring(args : Bool[], r : Bool[]) : Bool {
+        let N = Length(args);
+        let K = Length(r);
+        for P in 0 .. N - K {
+            if F_ContainsSubstringAtPosition(args, r, P) {
+                return true;
+            }
+        }
+        return false;
+    } 
+
+    @EntryPoint()
+    operation CheckSolution() : Bool {
+        for (n, r) in [
+            (2, [true]),
+            (3, [false, true]),
+            (4, [true, true, false]),
+            (5, [false, false])
+        ] {
+            if not CheckOracleImplementsFunction(n, Kata.Oracle_ContainsSubstring(_, _, r), F_ContainsSubstring(_, r)) {
+                Message($"Test failed for n = {n}, r = {r}");
+                return false;
+            }
+        }
+
+        Message("Correct!");
+        true 
+    }  
+}

katas/content/marking_oracles/contains_substring/index.md

@@ -0,0 +1,13 @@
+**Inputs:** 
+
+1. $N$ qubits in an arbitrary state $\ket{x}$ (input/query register).
+2. A qubit in an arbitrary state $\ket{y}$ (output/target qubit).
+3. A bit pattern $r$ of length $K$ represented as a `Bool[]` ($1 ≤ K ≤ N$).
+
+**Goal:** 
+Implement a quantum oracle which checks whether the input register contains the given pattern, i.e., whether there exists a position $P$ such that for all $j$ between $0$ and $K - 1$, inclusive, $r_j = x_{j+P}$.
+
+For example, for $N = 3$ a bit string `[false, true, false]` contains a pattern `[true, false]` (starting at index 1).
+
+Leave the qubits in the input register in the same state they started in.
+Your solution should work on inputs in superposition, and not use any measurements.

katas/content/marking_oracles/contains_substring/solution.md

@@ -0,0 +1,6 @@
+[placeholder for solution text]
+
+@[solution]({
+    "id": "marking_oracles__contains_substring_solution",
+    "codePath": "./Solution.qs"
+})

katas/content/marking_oracles/contains_substring_p/Verification.qs

@@ -1,15 +1,6 @@
 namespace Kata.Verification {
     open Microsoft.Quantum.Katas;
 
-    function  ContainsSubstringAtPositionF(args : Bool[], r : Bool[], p : Int) : Bool {
-        for i in 0 .. Length(r) - 1 {
-            if r[i] != args[i + p] {
-                return false;
-            }
-        }
-        return true;
-    }    
-
     @EntryPoint()
     operation CheckSolution() : Bool {
         for (n, p, r) in [
@@ -18,7 +9,7 @@ namespace Kata.Verification {
             (4, 1, [true, true, false]),
             (5, 3, [false])
         ] {
-            if not CheckOracleImplementsFunction(n, Kata.Oracle_ContainsSubstringAtPosition(_, _, r, p), ContainsSubstringAtPositionF(_, r, p)) {
+            if not CheckOracleImplementsFunction(n, Kata.Oracle_ContainsSubstringAtPosition(_, _, r, p), F_ContainsSubstringAtPosition(_, r, p)) {
                 Message($"Test failed for n = {n}, p = {p}, r = {r}");
                 return false;    
             }