QuantumKatas/Measurements/Tests.qs

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.

//////////////////////////////////////////////////////////////////////
// This file contains testing harness for all tasks.
// You should not modify anything in this file.
// The tasks themselves can be found in Tasks.qs file.
//////////////////////////////////////////////////////////////////////

namespace Quantum.Kata.Measurements {

    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Diagnostics;
    open Microsoft.Quantum.Convert;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Arrays;
    open Microsoft.Quantum.Random;

    open Quantum.Kata.Utils;

    //////////////////////////////////////////////////////////////////

    // "Framework" operation for testing single-qubit tasks for distinguishing states of one qubit
    // with Bool return
    operation DistinguishTwoStates_OneQubit (statePrep : ((Qubit, Int) => Unit), testImpl : (Qubit => Bool), stateName : String[]) : Unit {
        let nTotal = 100;
        let nStates = 2;
        mutable misclassifications = [0, size = nStates];
        
        use q = Qubit();
        for i in 1 .. nTotal {
            // get a random bit to define whether qubit will be in a state corresponding to true return (1) or to false one (0)
            // state = 0 false return
            // state = 1 true return
            let state = DrawRandomInt(0, 1);

            // do state prep: convert |0⟩ to outcome with false return or to outcome with true return depending on state
            statePrep(q, state);

            // get the solution's answer and verify if NOT a match, then differentiate what kind of mismatch
            let ans = testImpl(q);
            if ans != (state == 1) {
                set misclassifications w/= state <- misclassifications[state] + 1;
            }

            // we're not checking the state of the qubit after the operation
            Reset(q);
        }
        
        mutable totalMisclassifications = 0;
        for i in 0 .. nStates - 1 {
            if misclassifications[i] != 0 {
                set totalMisclassifications += misclassifications[i];
                Message($"Misclassified {stateName[i]} as {stateName[1 - i]} in {misclassifications[i]} test runs.");   
            }
        }
        
        // This check will tell the total number of failed classifications
        Fact(totalMisclassifications == 0, $"{totalMisclassifications} test runs out of {nTotal} returned incorrect state (see output for details).");
    }


    // ------------------------------------------------------
    operation StatePrep_IsQubitOne (q : Qubit, state : Int) : Unit {
        if state != 0 {
            // convert |0⟩ to |1⟩
            X(q);
        }
    }

    @Test("QuantumSimulator")
    operation T101_IsQubitOne () : Unit {
        DistinguishTwoStates_OneQubit(StatePrep_IsQubitOne, IsQubitOne, ["|0⟩", "|1⟩"]);
    }


    // ------------------------------------------------------
    @Test("QuantumSimulator")
    operation T102_InitializeQubit () : Unit {
        use q = Qubit();
        for i in 0 .. 36 {
            let alpha = ((2.0 * PI()) * IntAsDouble(i)) / 36.0;
            Ry(2.0 * alpha, q);

            // Test Task 1
            InitializeQubit(q);

            // Confirm that the state is |0⟩.
            AssertQubit(Zero, q);
        }
    }


    // ------------------------------------------------------
    operation StatePrep_IsQubitPlus (q : Qubit, state : Int) : Unit {
        if state == 0 {
            // convert |0⟩ to |-⟩
            X(q);
            H(q);
        } else {
            // convert |0⟩ to |+⟩
            H(q);
        }
    }

    @Test("QuantumSimulator")
    operation T103_IsQubitPlus () : Unit {
        DistinguishTwoStates_OneQubit(StatePrep_IsQubitPlus, IsQubitPlus, ["|-⟩", "|+⟩"]);
    }


    // ------------------------------------------------------
    // |A⟩ =   cos(alpha) * |0⟩ + sin(alpha) * |1⟩,
    // |B⟩ = - sin(alpha) * |0⟩ + cos(alpha) * |1⟩.
    operation StatePrep_IsQubitA (alpha : Double, q : Qubit, state : Int) : Unit {
        if state == 0 {
            // convert |0⟩ to |B⟩
            X(q);
            Ry(2.0 * alpha, q);
        } else {
            // convert |0⟩ to |A⟩
            Ry(2.0 * alpha, q);
        }
    }

    @Test("QuantumSimulator")
    operation T104_IsQubitA () : Unit {
        // cross-test
        // alpha = 0.0 or PI() => !isQubitOne
        // alpha = PI() / 2.0 => isQubitOne
        DistinguishTwoStates_OneQubit(StatePrep_IsQubitOne, IsQubitA(PI() / 2.0, _), 
            [$"|B⟩=(-sin(π/2)|0⟩ + cos(π/2)|1⟩)", $"|A⟩=(cos(π/2)|0⟩ + sin(π/2)|1⟩)"]);

        // alpha = PI() / 4.0 => isQubitPlus
        DistinguishTwoStates_OneQubit(StatePrep_IsQubitPlus, IsQubitA(PI() / 4.0, _), 
            [$"|B⟩=(-sin(π/4)|0⟩ + cos(π/4)|1⟩)", $"|A⟩=(cos(π/4)|0⟩ + sin(π/4)|1⟩)"]);

        for i in 0 .. 10 {
            let alpha = (PI() * IntAsDouble(i)) / 10.0;
            DistinguishTwoStates_OneQubit(StatePrep_IsQubitA(alpha, _, _), IsQubitA(alpha, _), 
                [$"|B⟩=(-sin({i}π/10)|0⟩ + cos({i}π/10)|1⟩)", $"|A⟩=(cos({i}π/10)|0⟩ + sin({i}π/10)|1⟩)"]);
        }
    }


    // ------------------------------------------------------

    // "Framework" operation for testing multi-qubit tasks for distinguishing states of an array of qubits
    // with Int return
    operation DistinguishStates_MultiQubit (nQubits : Int,
                                            nStates : Int,
                                            statePrep : ((Qubit[], Int) => Unit),
                                            testImpl : (Qubit[] => Int),
                                            measurementsPerRun : Int,
                                            stateNames : String[]) : Unit {
        let nTotal = 100;
        // misclassifications will store the number of times state i has been classified as state j (dimension nStates^2)
        mutable misclassifications = [0, size = nStates * nStates];
        // unknownClassifications will store the number of times state i has been classified as some invalid state (index < 0 or >= nStates)
        mutable unknownClassifications = [0, size = nStates];
                
        use qs = Qubit[nQubits];
        for _ in 1 .. nTotal {
            // get a random integer to define the state of the qubits
            let state = DrawRandomInt(0, nStates - 1);

            // do state prep: convert |0...0⟩ to outcome with return equal to state
            statePrep(qs, state);

            if measurementsPerRun > 0 {
                ResetOracleCallsCount();
            }
            // get the solution's answer and verify that it's a match, if not, increase the exact mismatch count
            let ans = testImpl(qs);
            if ((ans >= 0) and (ans < nStates)) {
                // classification result is a valid state index - check if is it correct
                if ans != state {
                    set misclassifications w/= ((state * nStates) + ans) <- (misclassifications[(state * nStates) + ans] + 1);
                }
            }
            else {
                // classification result is an invalid state index - file it separately
                set unknownClassifications w/= state <- (unknownClassifications[state] + 1);  
            }
            // if we have a max number of measurements per solution run specified, check that it is not exceeded
            if measurementsPerRun > 0 {
                let nm = GetOracleCallsCount(Measure);
                EqualityFactB(nm <= 1, true, $"You are allowed to do at most one measurement, and you did {nm}");
            }

            // we're not checking the state of the qubit after the operation
            ResetAll(qs);
        }
        
        mutable totalMisclassifications = 0;
        for i in 0 .. nStates - 1 {
            for j in 0 .. nStates - 1 {
                if misclassifications[(i * nStates) + j] != 0 {
                    set totalMisclassifications += misclassifications[i * nStates + j];
                    Message($"Misclassified {stateNames[i]} as {stateNames[j]} in {misclassifications[(i * nStates) + j]} test runs.");
                }
            }
            if unknownClassifications[i] != 0 {
                set totalMisclassifications += unknownClassifications[i];
                Message($"Misclassified {stateNames[i]} as Unknown State in {unknownClassifications[i]} test runs.");
            }
        }
        // This check will tell the total number of failed classifications
        Fact(totalMisclassifications == 0, $"{totalMisclassifications} test runs out of {nTotal} returned incorrect state (see output for details).");
    }


    // ------------------------------------------------------
    operation StatePrep_ZeroZeroOrOneOne (qs : Qubit[], state : Int) : Unit {
        if state == 1 {
            // |11⟩
            X(qs[0]);
            X(qs[1]);
        }
    }

    @Test("Microsoft.Quantum.Katas.CounterSimulator")
    operation T105_ZeroZeroOrOneOne () : Unit {
        DistinguishStates_MultiQubit(2, 2, StatePrep_ZeroZeroOrOneOne, ZeroZeroOrOneOne, 0, ["|00⟩", "|11⟩"]);
    }


    // ------------------------------------------------------
    operation StatePrep_BasisStateMeasurement (qs : Qubit[], state : Int) : Unit {

        if state / 2 == 1 {
            // |10⟩ or |11⟩
            X(qs[0]);
        }

        if state % 2 == 1 {
            // |01⟩ or |11⟩
            X(qs[1]);
        }
    }

    @Test("Microsoft.Quantum.Katas.CounterSimulator")
    operation T106_BasisStateMeasurement () : Unit {
        DistinguishStates_MultiQubit(2, 4, StatePrep_BasisStateMeasurement, BasisStateMeasurement, 0, ["|00⟩", "|01⟩", "|10⟩", "|11⟩"]);
    }


    // ------------------------------------------------------
    operation StatePrep_Bitstring (qs : Qubit[], bits : Bool[]) : Unit {
        for i in 0 .. Length(qs) - 1 {
            if bits[i] {
                X(qs[i]);
            }
        }
    }


    operation StatePrep_TwoBitstringsMeasurement (qs : Qubit[], bits1 : Bool[], bits2 : Bool[], state : Int) : Unit {
        let bits = state == 0 ? bits1 | bits2;
        StatePrep_Bitstring(qs, bits);
    }


    // Helper function to convert a boolean array to its ket state representation
    function BoolArrayAsKetState (bits : Bool[]) : String {
        mutable stateName = "|";
        for i in 0 .. Length(bits) - 1 {
            set stateName += (bits[i] ? "1" | "0");
        }
        return stateName + "⟩";
    }


    operation CheckTwoBitstringsMeasurement (b1 : Bool[], b2 : Bool[]) : Unit {
        DistinguishStates_MultiQubit(Length(b1), 2, StatePrep_TwoBitstringsMeasurement(_, b1, b2, _), 
            TwoBitstringsMeasurement(_, b1, b2), 1, 
            [BoolArrayAsKetState(b1), BoolArrayAsKetState(b2)]);
    }

    @Test("Microsoft.Quantum.Katas.CounterSimulator")
    operation T107_TwoBitstringsMeasurement () : Unit {
        mutable b1 = [false, true];
        mutable b2 = [true, false];
        CheckTwoBitstringsMeasurement(b1, b2);

        set b1 = [true, true, false];
        set b2 = [false, true, true];
        CheckTwoBitstringsMeasurement(b1, b2);

        set b1 = [false, true, true, false];
        set b2 = [false, true, true, true];
        CheckTwoBitstringsMeasurement(b1, b2);
        
        set b1 = [true, false, false, false];
        set b2 = [true, false, true, true];
        CheckTwoBitstringsMeasurement(b1, b2);
    }


    // ------------------------------------------------------
    operation StatePrep_FindFirstDiff (bits1 : Bool[], bits2 : Bool[]) : Int {
        for i in 0 .. Length(bits1) - 1 {
            if bits1[i] != bits2[i] {
                return i;
            }
        }
        return -1;
    }


    // a combination of tasks 14 and 15 from the Superposition kata
    operation StatePrep_BitstringSuperposition (qs : Qubit[], bits : Bool[][]) : Unit {
        let L = Length(bits);
        Fact(L == 1 or L == 2 or L == 4, "State preparation only supports arrays of 1, 2 or 4 bit strings");
        if L == 1 {
            for i in 0 .. Length(qs) - 1 {
                if bits[0][i] {
                    X(qs[i]);
                }
            }
        }
        if L == 2 {
            // find the index of the first bit at which the bit strings are different
            let firstDiff = StatePrep_FindFirstDiff(bits[0], bits[1]);

            // Hadamard corresponding qubit to create superposition
            H(qs[firstDiff]);

            // iterate through the bit strings again setting the final state of qubits
            for i in 0 .. Length(qs) - 1 {
                if bits[0][i] == bits[1][i] {
                    // if two bits are the same, apply X or nothing
                    if bits[0][i] {
                        X(qs[i]);
                    }
                } else {
                    // if two bits are different, set their difference using CNOT
                    if i > firstDiff {
                        CNOT(qs[firstDiff], qs[i]);
                        if bits[0][i] != bits[0][firstDiff] {
                            X(qs[i]);
                        }
                    }
                }
            }
        }
        if L == 4 {
            let N = Length(qs);

            use anc = Qubit[2];
            // Put two ancillas into equal superposition of 2-qubit basis states
            ApplyToEachA(H, anc);

            // Set up the right pattern on the main qubits with control on ancillas
            for i in 0 .. 3 {
                for j in 0 .. N - 1 {
                    if bits[i][j] {
                        (ControlledOnInt(i, X))(anc, qs[j]);
                    }
                }
            }

            // Uncompute the ancillas, using patterns on main qubits as control
            for i in 0 .. 3 {
                if i % 2 == 1 {
                    (ControlledOnBitString(bits[i], X))(qs, anc[0]);
                }
                if i / 2 == 1 {
                    (ControlledOnBitString(bits[i], X))(qs, anc[1]);
                }
            }
        }
    }


    operation StatePrep_SuperpositionMeasurement (qs : Qubit[], bits1 : Bool[][], bits2 : Bool[][], state : Int) : Unit {
        let bits = state == 0 ? bits1 | bits2;
        StatePrep_BitstringSuperposition(qs, bits);
    }


    // Helper function to convert an array of bit strings to its ket state representation
    function IntArrayAsStateName (qubits : Int, bitStrings : Bool[][]) : String {
        mutable statename = "";
        for i in 0 .. Length(bitStrings) - 1 {
            if i > 0 {
                set statename += " + ";
            }
            set statename += BoolArrayAsKetState(bitStrings[i]);
        }
        return statename;
    }


    operation CheckSuperpositionBitstringsOneMeasurement (nQubits : Int, ints1 : Int[], ints2 : Int[]): Unit {
        let bits1 = Mapped(IntAsBoolArray(_, nQubits), ints1);
        let bits2 = Mapped(IntAsBoolArray(_, nQubits), ints2);

        DistinguishStates_MultiQubit(nQubits, 2, StatePrep_SuperpositionMeasurement(_, bits1, bits2, _), 
                                     SuperpositionOneMeasurement(_, bits1, bits2), 1, 
                                     [IntArrayAsStateName(nQubits, bits1), IntArrayAsStateName(nQubits, bits2)]);
    }

    @Test("Microsoft.Quantum.Katas.CounterSimulator")
    operation T108_SuperpositionOneMeasurement () : Unit {
        // note that bit strings in the comments (big endian) are the reverse of the bit strings passed to the solutions (little endian)
        CheckSuperpositionBitstringsOneMeasurement(2, [2],  // [10]
                                                      [1]); // [01]

        CheckSuperpositionBitstringsOneMeasurement(2, [2,3],    // [10,11]
                                                      [1,0]);   // [01,00]

        CheckSuperpositionBitstringsOneMeasurement(2, [2],    // [10]
                                                      [1,0]); // [01,00]

        CheckSuperpositionBitstringsOneMeasurement(4, [15,7],    // [1111,0111]
                                                      [0,8]);    // [0000,1000]

        CheckSuperpositionBitstringsOneMeasurement(4, [15,7],       // [1111,0111]
                                                      [0,8,10,12]); // [0000,1000,1010,1100]

        CheckSuperpositionBitstringsOneMeasurement(5, [30,14,10,6],     // [11110,01110,01010,00110]
                                                      [1,17,21,25]);    // [00001,10001,10101,11001]

        CheckSuperpositionBitstringsOneMeasurement(2, [0,2],       // [00,10]
                                                      [3]); // [11]

        CheckSuperpositionBitstringsOneMeasurement(3, [5,7],       // [101,111]
                                                      [2]); // [010]

        CheckSuperpositionBitstringsOneMeasurement(4, [13,11,7,3], // [1101,1011,0111,0011]
                                                      [2,4]); // [0010,0100]
    }


    // ------------------------------------------------------
    operation CheckSuperpositionBitstringsMeasurement (nQubits : Int, ints1 : Int[], ints2 : Int[]): Unit {
        let bits1 = Mapped(IntAsBoolArray(_, nQubits), ints1);
        let bits2 = Mapped(IntAsBoolArray(_, nQubits), ints2);

        DistinguishStates_MultiQubit(nQubits, 2, StatePrep_SuperpositionMeasurement(_, bits1, bits2, _), 
                                     SuperpositionMeasurement(_, bits1, bits2), 0, 
                                     [IntArrayAsStateName(nQubits, bits1), IntArrayAsStateName(nQubits, bits2)]);
    }

    @Test("Microsoft.Quantum.Katas.CounterSimulator")
    operation T109_SuperpositionMeasurement () : Unit {
        // note that bit strings in the comments (big endian) are the reverse of the bit strings passed to the solutions (little endian)
        CheckSuperpositionBitstringsMeasurement(2, [2],  // [10]
                                                   [1]); // [01]

        CheckSuperpositionBitstringsMeasurement(2, [2,1],  // [10,01]
                                                   [3,0]); // [11,00]

        CheckSuperpositionBitstringsMeasurement(2, [2],    // [10]
                                                   [3,0]); // [11,00]

        CheckSuperpositionBitstringsMeasurement(4, [15,6], // [1111,0110]
                                                   [0,14]); // [0000,1110]

        CheckSuperpositionBitstringsMeasurement(4, [15,7],       // [1111,0111]
                                                   [0,8,10,13]); // [0000,1000,1010,1101]

        CheckSuperpositionBitstringsMeasurement(5, [30,14,10,7],  // [11110,01110,01010,00111]
                                                   [1,17,21,27]); // [00001,10001,10101,11011]

        CheckSuperpositionBitstringsMeasurement(2, [2,1],       // [10,01]
                                                   [3]); // [11]

        CheckSuperpositionBitstringsMeasurement(3, [7,5],       // [111,101]
                                                   [2]); // [010]
                                                   
        CheckSuperpositionBitstringsMeasurement(4, [13,11,7,3], // [1101,1011,0111,0011]
                                                   [5,2]); // [0101,0010]
    }


    // ------------------------------------------------------
    operation WState_Arbitrary_Reference (qs : Qubit[]) : Unit is Adj + Ctl {
        let N = Length(qs);

        if N == 1 {
            // base case of recursion: |1⟩
            X(qs[0]);
        } else {
            // |W_N⟩ = |0⟩|W_(N-1)⟩ + |1⟩|0...0⟩
            // do a rotation on the first qubit to split it into |0⟩ and |1⟩ with proper weights
            // |0⟩ -> sqrt((N-1)/N) |0⟩ + 1/sqrt(N) |1⟩
            let theta = ArcSin(1.0 / Sqrt(IntAsDouble(N)));
            Ry(2.0 * theta, qs[0]);

            // do a zero-controlled W-state generation for qubits 1..N-1
            X(qs[0]);
            Controlled WState_Arbitrary_Reference(qs[0 .. 0], qs[1 .. N - 1]);
            X(qs[0]);
        }
    }

    operation StatePrep_AllZerosOrWState (qs : Qubit[], state : Int) : Unit {

        if state == 1 {
            // prep W state
            WState_Arbitrary_Reference(qs);
        }
    }

    @Test("Microsoft.Quantum.Katas.CounterSimulator")
    operation T110_AllZerosOrWState () : Unit {

        for i in 2 .. 6 {
            DistinguishStates_MultiQubit(i, 2, StatePrep_AllZerosOrWState, AllZerosOrWState, 0, ["|0...0⟩", "|W⟩"]);
        }
    }


    // ------------------------------------------------------
    operation GHZ_State_Reference (qs : Qubit[]) : Unit is Adj {
        H(Head(qs));
        for q in Rest(qs) {
            CNOT(Head(qs), q);
        }
    }


    operation StatePrep_GHZOrWState (qs : Qubit[], state : Int) : Unit {

        if state == 0 {
            // prep GHZ state
            GHZ_State_Reference(qs);
        } else {
            // prep W state
            WState_Arbitrary_Reference(qs);
        }
    }

    @Test("Microsoft.Quantum.Katas.CounterSimulator")
    operation T111_GHZOrWState () : Unit {
        for i in 2 .. 6 {
            DistinguishStates_MultiQubit(i, 2, StatePrep_GHZOrWState, GHZOrWState, 0, ["|GHZ⟩", "|W⟩"]);
        }
    }


    // ------------------------------------------------------
    // 0 - |Φ⁺⟩ = (|00⟩ + |11⟩) / sqrt(2)
    // 1 - |Φ⁻⟩ = (|00⟩ - |11⟩) / sqrt(2)
    // 2 - |Ψ⁺⟩ = (|01⟩ + |10⟩) / sqrt(2)
    // 3 - |Ψ⁻⟩ = (|01⟩ - |10⟩) / sqrt(2)
    operation StatePrep_BellState (qs : Qubit[], state : Int) : Unit {
        H(qs[0]);
        CNOT(qs[0], qs[1]);

        // now we have |00⟩ + |11⟩ - modify it based on state arg
        if state % 2 == 1 {
            // negative phase
            Z(qs[1]);
        }
        if state / 2 == 1 {
            X(qs[1]);
        }
    }

    @Test("Microsoft.Quantum.Katas.CounterSimulator")
    operation T112_BellState () : Unit {
        DistinguishStates_MultiQubit(2, 4, StatePrep_BellState, BellState, 0, ["|Φ⁺⟩ = (|00⟩ + |11⟩) / sqrt(2)", 
                                                                               "|Φ⁻⟩ = (|00⟩ - |11⟩) / sqrt(2)", 
                                                                               "|Ψ⁺⟩ = (|01⟩ + |10⟩) / sqrt(2)", 
                                                                               "|Ψ⁻⟩ = (|01⟩ - |10⟩) / sqrt(2)"]);
    }

    // ------------------------------------------------------
    // 0 - (|00⟩ + |01⟩ + |10⟩ + |11⟩) / 2
    // 1 - (|00⟩ - |01⟩ + |10⟩ - |11⟩) / 2
    // 2 - (|00⟩ + |01⟩ - |10⟩ - |11⟩) / 2
    // 3 - (|00⟩ - |01⟩ - |10⟩ + |11⟩) / 2
    operation StatePrep_TwoQubitState (qs : Qubit[], state : Int) : Unit {
        // start with state prep of basis vectors
        StatePrep_BasisStateMeasurement(qs, state);
        H(qs[0]);
        H(qs[1]);
    }

    @Test("Microsoft.Quantum.Katas.CounterSimulator")
    operation T113_TwoQubitState () : Unit {
        DistinguishStates_MultiQubit(2, 4, StatePrep_TwoQubitState, TwoQubitState, 0, ["(|00⟩ + |01⟩ + |10⟩ + |11⟩) / 2", 
                                                                                       "(|00⟩ - |01⟩ + |10⟩ - |11⟩) / 2", 
                                                                                       "(|00⟩ + |01⟩ - |10⟩ - |11⟩) / 2", 
                                                                                       "(|00⟩ - |01⟩ - |10⟩ + |11⟩) / 2"]);
    }


    // ------------------------------------------------------
    // 0 - ( |00⟩ - |01⟩ - |10⟩ - |11⟩) / 2
    // 1 - (-|00⟩ + |01⟩ - |10⟩ - |11⟩) / 2
    // 2 - (-|00⟩ - |01⟩ + |10⟩ - |11⟩) / 2
    // 3 - (-|00⟩ - |01⟩ - |10⟩ + |11⟩) / 2
    operation StatePrep_TwoQubitStatePartTwo (qs : Qubit[], state : Int) : Unit {

        // start with state prep of basis vectors
        StatePrep_BasisStateMeasurement(qs, state);

        // now apply all gates for unitary in reference impl (in reverse + adjoint)
        within {
            ApplyToEachA(X, qs);
            Controlled Z([qs[0]], qs[1]);
            ApplyToEachA(X, qs);
        } apply {
            ApplyToEach(H, qs);
        }
        SWAP(qs[0], qs[1]);
    }

    @Test("Microsoft.Quantum.Katas.CounterSimulator")
    operation T114_TwoQubitStatePartTwo () : Unit {
        DistinguishStates_MultiQubit(2, 4, StatePrep_TwoQubitStatePartTwo, TwoQubitStatePartTwo, 0, ["(+|00⟩ - |01⟩ - |10⟩ - |11⟩) / 2", 
                                                                                                     "(-|00⟩ + |01⟩ - |10⟩ - |11⟩) / 2", 
                                                                                                     "(-|00⟩ - |01⟩ + |10⟩ - |11⟩) / 2", 
                                                                                                     "(-|00⟩ - |01⟩ - |10⟩ + |11⟩) / 2"]);
    }


    // ------------------------------------------------------
    operation StatePrep_ThreeQubitMeasurement (qs : Qubit[], state : Int) : Unit is Adj {

        WState_Arbitrary_Reference(qs);

        if state == 0 {
            // prep 1/sqrt(3) ( |100⟩ + ω |010⟩ + ω² |001⟩ )
            R1(2.0 * PI() / 3.0, qs[1]);
            R1(4.0 * PI() / 3.0, qs[2]);
        } else {
            //  prep 1/sqrt(3) ( |100⟩ + ω² |010⟩ + ω |001⟩ )
            R1(4.0 * PI() / 3.0, qs[1]);
            R1(2.0 * PI() / 3.0, qs[2]);
        }
    }

    @Test("Microsoft.Quantum.Katas.CounterSimulator")
    operation T115_ThreeQubitMeasurement () : Unit {
        DistinguishStates_MultiQubit(3, 2, StatePrep_ThreeQubitMeasurement, ThreeQubitMeasurement, 0, 
            ["1/sqrt(3) (|100⟩ + ω |010⟩ + ω² |001⟩)", 
             "1/sqrt(3) (|100⟩ + ω² |010⟩ + ω |001⟩)"]);
    }


    //////////////////////////////////////////////////////////////////
    // Part II*. Discriminating Nonorthogonal States
    //////////////////////////////////////////////////////////////////

    operation StatePrep_IsQubitZeroOrPlus (q : Qubit, state : Int) : Unit {

        if state != 0 {
            // convert |0⟩ to |+⟩
            H(q);
        }
    }


    // "Framework" operation for testing multi-qubit tasks for distinguishing states of an array of qubits
    // with Int return. Framework tests against a threshold parameter for the fraction of runs that must succeed.
    operation DistinguishStates_MultiQubit_Threshold (Nqubit : Int, Nstate : Int, threshold : Double, statePrep : ((Qubit, Int) => Unit), testImpl : (Qubit => Bool)) : Unit {
        let nTotal = 1000;
        mutable nOk = 0;

        use qs = Qubit[Nqubit];
        for i in 1 .. nTotal {
            // get a random integer to define the state of the qubits
            let state = DrawRandomInt(0, Nstate - 1);

            // do state prep: convert |0⟩ to outcome with return equal to state
            statePrep(qs[0], state);

            // get the solution's answer and verify that it's a match
            let ans = testImpl(qs[0]);
            if ans == (state == 0) {
                set nOk += 1;
            }

            // we're not checking the state of the qubit after the operation
            ResetAll(qs);
        }

        if IntAsDouble(nOk) < threshold * IntAsDouble(nTotal) {
            fail $"{nTotal - nOk} test runs out of {nTotal} returned incorrect state which does not meet the required threshold of at least {threshold * 100.0}%.";
        }
    }

    @Test("QuantumSimulator")
    operation T201_IsQubitZeroOrPlus () : Unit {
        DistinguishStates_MultiQubit_Threshold(1, 2, 0.8, StatePrep_IsQubitZeroOrPlus, IsQubitPlusOrZero);
    }


    // ------------------------------------------------------
    // "Framework" operation for testing multi-qubit tasks for distinguishing states of an array of qubits
    // with Int return. Framework tests against a threshold parameter for the fraction of runs that must succeed.
    // Framework tests in the USD scenario, i.e., it is allowed to respond "inconclusive" (with some probability)
    // up to given threshold, but it is never allowed to err if an actual conclusive response is given.
    operation USD_DistinguishStates_MultiQubit_Threshold (Nqubit : Int, Nstate : Int, thresholdInconcl : Double, thresholdConcl : Double, statePrep : ((Qubit, Int) => Unit), testImpl : (Qubit => Int)) : Unit {
        let nTotal = 10000;

        // counts total inconclusive answers
        mutable nInconc = 0;

        // counts total conclusive |0⟩ state identifications
        mutable nConclOne = 0;

        // counts total conclusive |+> state identifications
        mutable nConclPlus = 0;

        use qs = Qubit[Nqubit];
        for i in 1 .. nTotal {

            // get a random integer to define the state of the qubits
            let state = DrawRandomInt(0, Nstate - 1);

            // do state prep: convert |0⟩ to outcome with return equal to state
            statePrep(qs[0], state);

            // get the solution's answer and verify that it's a match
            let ans = testImpl(qs[0]);

            // check that the answer is actually in allowed range
            if (ans < -1 or ans > 1) {
                fail $"state {state} led to invalid response {ans}.";
            }

            // keep track of the number of inconclusive answers given
            if ans == -1 {
                set nInconc += 1;
            }

            if (ans == 0 and state == 0) {
                set nConclOne += 1;
            }

            if (ans == 1 and state == 1) {
                set nConclPlus += 1;
            }

            // check if upon conclusive result the answer is actually correct
            if (ans == 0 and state == 1 or ans == 1 and state == 0) {
                fail $"state {state} led to incorrect conclusive response {ans}.";
            }

            // we're not checking the state of the qubit after the operation
            ResetAll(qs);
        }

        if IntAsDouble(nInconc) > thresholdInconcl * IntAsDouble(nTotal) {
            fail $"{nInconc} test runs out of {nTotal} returned inconclusive which does not meet the required threshold of at most {thresholdInconcl * 100.0}%.";
        }

        if IntAsDouble(nConclOne) < thresholdConcl * IntAsDouble(nTotal) {
            fail $"Only {nConclOne} test runs out of {nTotal} returned conclusive |0⟩ which does not meet the required threshold of at least {thresholdConcl * 100.0}%.";
        }

        if IntAsDouble(nConclPlus) < thresholdConcl * IntAsDouble(nTotal) {
            fail $"Only {nConclPlus} test runs out of {nTotal} returned conclusive |+> which does not meet the required threshold of at least {thresholdConcl * 100.0}%.";
        }
    }

    @Test("QuantumSimulator")
    operation T202_IsQubitZeroOrPlusSimpleUSD () : Unit {
        USD_DistinguishStates_MultiQubit_Threshold(1, 2, 0.8, 0.1, StatePrep_IsQubitZeroOrPlus, IsQubitPlusZeroOrInconclusiveSimpleUSD);
    }


    // ------------------------------------------------------
    operation StatePrep_IsQubitNotInABC (q : Qubit, state : Int) : Unit {
        let alpha = (2.0 * PI()) / 3.0;
        H(q);

        if state == 0 {
            // convert |0⟩ to 1/sqrt(2) (|0⟩ + |1⟩)
        }
        elif state == 1 {
            // convert |0⟩ to 1/sqrt(2) (|0⟩ + ω |1⟩), where ω = exp(2iπ/3)
            R1(alpha, q);
        }
        else {
            // convert |0⟩ to 1/sqrt(2) (|0⟩ + ω² |1⟩), where ω = exp(2iπ/3)
            R1(2.0 * alpha, q);
        }
    }


    // "Framework" operation for testing multi-qubit tasks for distinguishing states of an array of qubits
    // with Int return. Framework tests instances of the Peres/Wootters game. In this game, one of three
    // "trine" states is presented and the algorithm must answer with a label that does not correspond
    // to one of the label of the input state.
    operation ABC_DistinguishStates_MultiQubit_Threshold (Nqubit : Int, Nstate : Int, statePrep : ((Qubit, Int) => Unit), testImpl : (Qubit => Int)) : Unit {

        let nTotal = 1000;

        use qs = Qubit[Nqubit];

        for i in 1 .. nTotal {
            // get a random integer to define the state of the qubits
            let state = DrawRandomInt(0, Nstate - 1);

            // do state prep: convert |0⟩ to outcome with return equal to state
            statePrep(qs[0], state);

            // get the solution's answer and verify that it's a match
            let ans = testImpl(qs[0]);

            // check that the value of ans is 0, 1 or 2
            if (ans < 0 or ans > 2) {
                fail "You can not return any value other than 0, 1 or 2.";
            }

            // check if upon conclusive result the answer is actually correct
            if ans == state {
                fail $"State {state} led to incorrect conclusive response {ans}.";
            }

            // we're not checking the state of the qubit after the operation
            ResetAll(qs);
        }
    }

    @Test("QuantumSimulator")
    operation T203_IsQubitNotInABC () : Unit {
        ABC_DistinguishStates_MultiQubit_Threshold(1, 3, StatePrep_IsQubitNotInABC, IsQubitNotInABC);
    }
}