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.
// but feel free to look up the solution if you get stuck.
//////////////////////////////////////////////////////////////////////

namespace Quantum.Kata.Teleportation {
    
    open Microsoft.Quantum.Convert;
    open Microsoft.Quantum.Preparation;
    open Microsoft.Quantum.Intrinsic;
    
    
    //////////////////////////////////////////////////////////////////
    // Part I. Standard teleportation
    //////////////////////////////////////////////////////////////////
    
    // Task 1.1. Entangled pair
    operation Entangle_Reference (qAlice : Qubit, qBob : Qubit) : Unit is Adj {        
        H(qAlice);
        CNOT(qAlice, qBob);
    }
    
    
    // Task 1.2. Send the message (Alice's task)
    operation SendMessage_Reference (qAlice : Qubit, qMessage : Qubit) : (Bool, Bool) {
        CNOT(qMessage, qAlice);
        H(qMessage);
        return (M(qMessage) == One, M(qAlice) == One);
    }
    
    
    // Task 1.3. Reconstruct the message (Bob's task)
    operation ReconstructMessage_Reference (qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
        if (b1) {
            Z(qBob);
        }
        if (b2) {
            X(qBob);
        }
    }
    
    
    // Task 1.4. Standard teleportation protocol
    operation StandardTeleport_Reference (qAlice : Qubit, qBob : Qubit, qMessage : Qubit) : Unit {
        Entangle_Reference(qAlice, qBob);
        let classicalBits = SendMessage_Reference(qAlice, qMessage);
        
        // Alice sends the classical bits to Bob.
        // Bob uses these bits to transform his part of the entangled pair into |ψ⟩.
        ReconstructMessage_Reference(qBob, classicalBits);
    }
    
    
    // Task 1.5. Prepare the message specified and send it (Alice's task)
    operation PrepareAndSendMessage_Reference (qAlice : Qubit, basis : Pauli, state : Bool) : (Bool, Bool) {
        use message = Qubit();
        if (state) {
            X(message);
        }
            
        PreparePauliEigenstate(basis, message);
        let classicalBits = SendMessage_Reference(qAlice, message);
        Reset(message);
        return classicalBits;
    }
    
    
    // Task 1.6. Reconstruct the message and measure it (Bob's task)
    operation ReconstructAndMeasureMessage_Reference (qBob : Qubit, (b1 : Bool, b2 : Bool), basis : Pauli) : Bool {
        ReconstructMessage_Reference(qBob, (b1, b2));
        return Measure([basis], [qBob]) == One;
    }
    

    // Task 1.8. Entanglement swapping
    operation EntanglementSwapping_Reference () : ((Qubit, Qubit) => Int, (Qubit, Int) => Unit) {
        return (TeleportEntanglement_Reference, AdjustTeleportedState_Reference);
    }

    // Helper operations that wrap tasks 1.2 and 1.3 to the format required in task 1.8.
    // The integer message is an integer representation of the tuple used in 1.2 and 1.3.
    internal operation TeleportEntanglement_Reference (qAlice1 : Qubit, qBob1 : Qubit) : Int {
        let (c1, c2) = SendMessage_Reference(qAlice1, qBob1);
        return BoolArrayAsInt([c1, c2]);
    } 

    internal operation AdjustTeleportedState_Reference (qBob2 : Qubit, resultCharlie : Int) : Unit {
        let classicalBits = IntAsBoolArray(resultCharlie, 2);
        ReconstructMessage_Reference(qBob2, (classicalBits[0], classicalBits[1]));
    }
    

    //////////////////////////////////////////////////////////////////
    // Part II. Teleportation using different entangled pair
    //////////////////////////////////////////////////////////////////
    
    // Task 2.1. Reconstruct the message if the entangled qubits were in the state |Φ⁻⟩ = (|00⟩ - |11⟩) / sqrt(2).
    operation ReconstructMessage_PhiMinus_Reference (qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
        // Bob can apply a Z gate to his qubit to convert the pair to |Φ⁺⟩
        // and use the standard teleportation reconstruction process.
        if (not b1) {
            Z(qBob);
        }
        
        if (b2) {
            X(qBob);
        }
    }
    
    
    // Task 2.2. Reconstruct the message if the entangled qubits were in the state |Ψ⁺⟩ = (|01⟩ + |10⟩) / sqrt(2).
    operation ReconstructMessage_PsiPlus_Reference (qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
        // Bob can apply an X gate to his qubit to convert the pair to |Φ⁺⟩
        // and use the standard teleportation reconstruction process.
        if (b1) {
            Z(qBob);
        }
        
        if (not b2) {
            X(qBob);
        }
    }
    
    
    // Task 2.3. Reconstruct the message if the entangled qubits were in the state |Ψ⁻⟩ = (|01⟩ - |10⟩) / sqrt(2).
    operation ReconstructMessage_PsiMinus_Reference (qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {
        // Bob can apply a Z gate and an X gate to his qubit to convert the pair to |Φ⁺⟩
        // and use the standard teleportation reconstruction process.
        if (not b1) {
            Z(qBob);
        }
        
        if (not b2) {
            X(qBob);
        }
    }
    
    
    //////////////////////////////////////////////////////////////////
    // Part III. Principle of deferred measurement
    //////////////////////////////////////////////////////////////////
    
    // Task 3.1. Measurement-free teleportation.
    operation MeasurementFreeTeleport_Reference (qAlice : Qubit, qBob : Qubit, qMessage : Qubit) : Unit {
        // The first part of the circuit is similar to Alice's part, but without measurements.
        CNOT(qMessage, qAlice);
        H(qMessage);
        
        // Classically controlled gates applied by Bob are replaced by controlled gates
        Controlled Z([qMessage], qBob);
        Controlled X([qAlice], qBob);
    }
    
    
    //////////////////////////////////////////////////////////////////
    // Part IV. Teleportation with three entangled qubits
    //////////////////////////////////////////////////////////////////
    
    // Task 4.1. Entangled trio
    operation EntangleThreeQubits_Reference (qAlice : Qubit, qBob : Qubit, qCharlie : Qubit) : Unit is Adj {
        // Starting with |000⟩
        
        H(qBob);

        // now state is: 1/sqrt(2) (|000⟩ + |010⟩)

        CNOT(qBob, qCharlie);

        // state: 1/sqrt(2) (|000⟩ + |011⟩)

        H(qAlice);

        // state: 1/2 (|000⟩ + |011⟩ + |100⟩ + |111⟩)

        CNOT(qAlice, qCharlie);

        // final state:  1/2 (|000⟩ + |011⟩ + |101⟩ + |110⟩)
    }
    
    
    // Task 4.2. Reconstruct the message (Charlie's task)
    operation ReconstructMessageWhenThreeEntangledQubits_Reference (qCharlie : Qubit, (b1 : Bool, b2 : Bool), b3 : Bool) : Unit {
        if (b1) {
            Z(qCharlie);
        }
        
        if (b2) {
            X(qCharlie);
        }
        
        if (b3) {
            X(qCharlie);
        }
    }
}