Эксперименты с игрой GHZ

В игре GHZ Алиса, Боб и Чарли получают один из входов 000,011,101,110 и без общения возвращают биты $A,B,C$. Победа означает $R\lor S\lor T=A\oplus B\oplus C$.

В приведённой программе выделяют три кубита и готовят

$$\frac{|000\rangle-|011\rangle-|101\rangle-|110\rangle}{2}.$$

Каждый игрок получает свой кубит и действует только на нём, выбирая измерение $Z$ или $X$ по собственному входному биту. Передача кубитов виртуальна. Измеренные кубиты возвращают в $|0\rangle$, а ответы игроков сравнивают с условием победы. Пример позволяет сравнить долю побед классической и квантовой стратегий.

Измените исходный код и проверьте, меняется ли результат в следующих случаях:

1. Судья выбирает входные биты не случайно. Как судье минимизировать вероятность победы игроков?
2. Игроки получают обычное состояние GHZ $(|000\rangle+|111\rangle)/\sqrt2$. Как изменить квантовые стратегии, чтобы вероятность победы была 100%?

Оба пункта относятся к одному авторскому эксперименту. Полный исходный пример приведён ниже.

Заготовка Q#:

namespace Quantum.Kata.GHZGame {
    open Microsoft.Quantum.Random;
    open Microsoft.Quantum.Convert;

    function WinCondition (rst : Bool[], abc : Bool[]) : Bool {
        return (rst[0] or rst[1] or rst[2]) == (abc[0] != abc[1] != abc[2]);
    }

    function AliceClassical (r : Bool) : Bool {
        return true;
    }

    function BobClassical (s : Bool) : Bool {
        return true;
    }

    function CharlieClassical (t : Bool) : Bool {
        return true;
    }

    operation CreateEntangledTriple (qs : Qubit[]) : Unit is Adj {
        X(qs[0]);
        X(qs[1]);
        H(qs[0]);
        H(qs[1]);
        Controlled Z([qs[0]], qs[1]);
        ApplyControlledOnBitString([false, true], X, [qs[0], qs[1]], qs[2]);
        ApplyControlledOnBitString([true, false], X, [qs[0], qs[1]], qs[2]);
    }

    operation AliceQuantum (bit : Bool, qubit : Qubit) : Bool {
        if bit {
            return MResetX(qubit) == One;
        }
        return MResetZ(qubit) == One;
    }

    operation BobQuantum (bit : Bool, qubit : Qubit) : Bool {
        if bit {
            return MResetX(qubit) == One;
        }
        return MResetZ(qubit) == One;
    }

    operation CharlieQuantum (bit : Bool, qubit : Qubit) : Bool {
        if bit {
            return MResetX(qubit) == One;
        }
        return MResetZ(qubit) == One;
    }

    operation getRandomRefereeBits () : Bool[] {
        let bits = [[false, false, false],
                    [true, true, false],
                    [false, true, true],
                    [true, false, true]];
        return bits[DrawRandomInt(0, 3)];
    }

    @EntryPoint()
    operation GHZ_GameDemo () : Unit {
        use (aliceQubit, bobQubit, charlieQubit) = (Qubit(), Qubit(), Qubit());
        mutable classicalWins = 0;
        mutable quantumWins = 0;
        let iterations = 1000;
        for _ in 1 .. iterations {
            CreateEntangledTriple([aliceQubit, bobQubit, charlieQubit]);
            let inputs = getRandomRefereeBits();
            let coutputs = [AliceClassical(inputs[0]), BobClassical(inputs[1]), CharlieClassical(inputs[2])];
            if WinCondition(inputs, coutputs) {
                set classicalWins += 1;
            }
            let qoutputs = [AliceQuantum(inputs[0], aliceQubit), BobQuantum(inputs[1], bobQubit), CharlieQuantum(inputs[2], charlieQubit)];
            if WinCondition(inputs, qoutputs) {
                set quantumWins += 1;
            }
            ResetAll([aliceQubit, bobQubit, charlieQubit]);
        }
        Message($"Percentage of classical wins is {100.0*IntAsDouble(classicalWins)/IntAsDouble(iterations)}%");
        Message($"Percentage of quantum wins is {100.0*IntAsDouble(quantumWins)/IntAsDouble(iterations)}%");
    }
}