ReferenceImplementation.qs

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

//////////////////////////////////////////////////////////////////////
// This file contains reference solutions to all tasks. 
// The tasks themselves can be found in Tasks.qs file.
// We recommend that you try to solve the tasks yourself first,
// but feel free to look up the solution if you get stuck.
//////////////////////////////////////////////////////////////////////

namespace Quantum.Kata.QEC_BitFlipCode {
    open Microsoft.Quantum.Primitive;
    open Microsoft.Quantum.Canon;

    // Task 1. Parity Measurements
    operation MeasureParity_Reference (register : Qubit[]) : Result {
        body {
            return Measure([PauliZ; PauliZ; PauliZ], register);
        }
    }

    // Task 2. Encoding Codewords
    operation Encode_Reference(register : Qubit[]) : () {
        body {
            ApplyToEachA(CNOT(Head(register), _), Rest(register));
        }
        adjoint auto;
    }

    // Task 3. Error Detection I
    operation DetectErrorOnLeftQubit_Reference (register : Qubit[]) : Result {
        body {
            return Measure([PauliZ; PauliZ], register[0..1]);
        }
    }

    // Task 4. Error Correction I
    operation CorrectErrorOnLeftQubit_Reference (register : Qubit[]) : () {
        body {
            if (Measure([PauliZ; PauliZ], register[0..1]) == One) {
                X(register[0]);
            }
        }
    }

    // Task 5. Error Detection II
    operation DetectErrorOnAnyQubit_Reference (register : Qubit[]) : Int {
        body {
            let m1 = Measure([PauliZ; PauliZ], register[0..1]);
            let m2 = Measure([PauliZ; PauliZ], register[1..2]);
            if (m1 == One && m2 == Zero) {
                return 1;
            }
            if (m1 == One && m2 == One) {
                return 2;
            }
            if (m1 == Zero && m2 == One) {
                return 3;
            }
            return 0;
        }
    }

    // Task 6. Error Correction II
    operation CorrectErrorOnAnyQubit_Reference (register : Qubit[]) : () {
        body {
            let idx = DetectErrorOnAnyQubit_Reference(register);
            if (idx > 0) {
                X(register[idx - 1]);
            }
        }
    }

    // Task 7. Logical X Gate
    operation LogicalX_Reference (register : Qubit[]) : () {
        body {
            ApplyToEach(X, register);
        }
    }

    // Task 8. Logical Z Gate
    operation LogicalZ_Reference (register : Qubit[]) : () {
        body {
            ApplyToEach(Z, register);
        }
    }
}