2018-10-21

Q# で 1+1 を計算してみる

この前参加した勉強会で話題にでていたこの記事のコードをQ#で書いてみることにしました。

Q#の場合、現状シミュレーターしかないというのもありますが、あくまでQ#のQubitは論理量子ビットで、Q#で定義した論理量子ビットの操作から物理量子ビットへの変換はエラー訂正含めてよしなにやってくれる（はず）というのがあるので、Half Adderの回路を記述すればよいことになります。こちらのQ&Aも参考になりました。

quantumcomputing.stackexchange.com

２番目のQiitaの記事にもあるHalf Adderの回路をそのまま実装することにします。入力に2量子ビット、出力に2量子ビットを使うことにします。AND操作は二重制御NOT(CCNOT)操作を使います。

CCNOT operation (Microsoft.Quantum.Primitive) | Microsoft Docs

XORはCNOT操作を使います。

CNOT operation (Microsoft.Quantum.Primitive) | Microsoft Docs

というわけで、まずは入力に2量子ビット、出力に2量子ビットを確保した引数がくると想定したOperationは次のように書けます。

operation Add(input: Qubit[], output: Qubit[]) : ()
{
    body
    {
        CCNOT(input[0], input[1], output[0]);
        CNOT(input[0], output[1]);
        CNOT(input[1], output[1]);
    }
}

さて、この操作はQubitを渡してもらっているので、室温系から直接実行できません。室温系からは2要素のビット配列を渡してそれを足し算した結果を整数で受け取るようにしましょう。Operationの定義は次のようにかけるはずです。

operation ApplyAdd(input1: Bool, input2: Bool) : (Int)
{}

受け取ったビット配列から入力用のQubitを準備する必要があります。Qubitは0で初期化されるので、入力が1(ビットがtrue)の場合にX操作で反転させることにします。

X operation (Microsoft.Quantum.Primitive) | Microsoft Docs

というわけで、第一引数のビット配列に対応した状態に第２引数のQubit配列を変化させるOperationを用意します。

operation PrepareInput(input1: Bool, input2: Bool, input: Qubit[]) : ()
{
    body
    {
        if (input1)
        {
            X(input[0]);
        }
        if (input2)
        {
            X(input[1]);
        }
    }
}

以上を踏まえて、Q#全体のコードは次のようになります。

namespace Addition
{
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Primitive;

    operation ApplyAdd(input1: Bool, input2: Bool) : (Int)
    {
        body
        {
            mutable result = 0;
            using (qs = Qubit[4])
            {
                let input = qs[0..1];
                let output = qs[2..3];
                
                PrepareInput(input1, input2, input);

                Add(input, output);

                if (M(output[0]) == One)
                {
                    set result = result + 2;
                }
                if (M(output[1]) == One)
                {
                    set result = result + 1;
                }
                ResetAll(qs);
            }
            return result;
        }
    }

    operation PrepareInput(input1: Bool, input2: Bool, input: Qubit[]) : ()
    {
        body
        {
            if (input1)
            {
                X(input[0]);
            }
            if (input2)
            {
                X(input[1]);
            }
        }
    }

    operation Add(input: Qubit[], output: Qubit[]) : ()
    {
        body
        {
            CCNOT(input[0], input[1], output[0]);
            CNOT(input[0], output[1]);
            CNOT(input[1], output[1]);
        }
    }
}

usingで4量子ビットを用意し、入力用出力用の変数にそれぞれ割り当てます。配列の引数にRange型である0..1という記述をするとsliceされた配列を作ることができます。この例だと、indexが0と1の2要素配列となります。Add操作をしたとの結果の読み取りですが、M操作を利用し、出力の2¹を表すQubitが1ならば答えに2を足しています。測定結果はResult型のOneもしくはZeroであらわされます。2⁰のQubitが1ならば結果に1を足した後、ResetAll操作でusingで用意したQubitをすべて初期状態にリセットします。usingを抜けるときは必ずQubitの状態を0に戻さないといけないのがQ#のルールです。

M operation (Microsoft.Quantum.Primitive) | Microsoft Docs

ResetAll operation (Microsoft.Quantum.Primitive) | Microsoft Docs

最後にApplyAdd操作を呼び出すC#コードをMainメソッド内に記述します。

using System.Threading.Tasks;
using Microsoft.Quantum.Simulation.Core;
using Microsoft.Quantum.Simulation.Simulators;

namespace Addition
{
    class Driver
    {
        static void Main(string[] args)
        {
            RunAsync().GetAwaiter().GetResult();
        }

        static async Task RunAsync()
        {
            using (var sim = new QuantumSimulator())
            {
                var res = await ApplyAdd.Run(sim, false, false);
                System.Console.WriteLine($"0+0= {res}");

                res = await ApplyAdd.Run(sim, false, true);
                System.Console.WriteLine($"0+1= {res}");

                res = await ApplyAdd.Run(sim, true, false);
                System.Console.WriteLine($"1+0= {res}");

                res = await ApplyAdd.Run(sim, true, true);
                System.Console.WriteLine($"1+1= {res}");
            }
            System.Console.WriteLine("Press any key to continue...");
            System.Console.ReadKey();
        }
    }
}

実行すると次のように出力されるはずです。これで計算ができました。

> dotnet run
0+0= 0
0+1= 1
1+0= 1
1+1= 2
Press any key to continue...

ちなみに量子回路の勉強のためにこうやって記述しましたが、Q#コード中で数値計算もできるので、普通に計算したい場合は例えばこんな風にQ#でかけます。量子ビットを扱わない処理はfunctionとして定義することができます。

function AddFunc(input1: Int, input2: Int) : (Int)
{
    return input1 + input2;
}

2018-10-18

Q# Coding Contestを題材にQuantum Oracleについてがんばって理解してみる

以前話題に出した Q# Coding ContestでQuantum Oracleについての問題があったのですが、Quantum Oracleとはなんなのか？というのを出てきた問題を題材に自分なりにまとめてみました。まず、Quantum Oracleについてはcoding contestのブログにて記事が出ています。

codeforces.com

このブログの記事の概要としては、古典的関数 ${f: \{0, 1 \}^n \rightarrow \{0, 1\}^m}$ を扱うことにあるようですが、要はn-bitのバイナリを受け取ってm-bitのバイナリを返すという意味で、古典関数をバイナリの入出力で表現したと考えればよさそうです。で、これをQ#の中で考えるには、Qubitの操作として定義したいものの、nとmが異なる場合はそもそもそのまま扱えないし、たとえ同じだとしても随伴操作が作れなくてユニタリ変換にならないのでQubitの操作として定義することができないといっています。そこで、n Qubitからなる状態 x とm Qubitからなる状態 y を重ね合わせたものに対する操作 O を考えると、これはユニタリ変換になってて（というよりそうしていて）、次のように古典関数 f を定義できてうれしいといっています。

${ \displaystyle O(|x \rangle \otimes |y \rangle) = |x \rangle \otimes |y \oplus f(x) \rangle }$

つまり、出力 |y> も入力 |x> とあわせて入力として扱い、出力 |y> と古典関数f の排他的論理和をとったものと入力 |x> とのテンソル積が欲しいものになる、ということのようです。これだけだと、自分はわかったようなわからんような感じだったので、とりあえずCoding Contestの問題を見てみます。

codeforces.com

入力 |x> に対し、kが指定されたときに、k番目の要素を返す古典関数fに対するQuantum Oracleに関する問題です。ここでは、入力がn Qubitの|x>、出力が1 Qubitなので、Q#のOperationの第一引数がn個のQubit配列、第二引数が単一のQubitでこれが出力となります。解答としては、|x>に古典関数fを施したものは結局k番目の要素を返すのでx[k]にほかならず、これとyでCNOTをとったものが答えになっています。

namespace Solution
{
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Primitive;

    operation Solve (x : Qubit[], y : Qubit, k : Int) : ()
    {
        body
        {
            CNOT(x[k], y);
        }
    }
}

次の問題は、入力|x> を全部足した値を2を法とした場合の剰余をもとめる問題です。

codeforces.com

全部足した値の2を法とした剰余というのが、結局XORであり、入力 |x> の各要素を順番に*1 出力 |y> とCNOTをとればよいことになります。ここは一応、前の問題がヒントになっています。

namespace Solution
{
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Primitive;

    operation Solve (x : Qubit[], y : Qubit, k : Int) : ()
    {
        body
        {
            for (i in 0..Length(x)-1) 
            {
                CNOT(x[i], y);
            }
        }
    }
}

ここからは本戦の問題です。この問題は直前の問題と並べるとよく似ていることに気づきます。

codeforces.com

違いは、bit配列 b が追加されていて、bと |x> との内積の和の2を法とした場合の剰余になっています。bと |x> との内積に対して、2を法とするということで、結局bit配列であるbの要素が1のときだけ入力|x>のXORをとっていればよいことになり、答えは次のようになっています。

namespace Solution
{
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Primitive;

    operation Solve (x : Qubit[], y : Qubit, k : Int) : ()
    {
        body
        {
            for (i in 0..Length(x)-1) 
            {
                if (b[i] == 1) 
                {
                    CNOT(x[i], y);
                }
            }
        }
    }
}

次がQuantum Oracleに関する最後の問題です。今度は b * x + (1 - b) * (1 - x) という形の内積になっています。

codeforces.com

内積の前半 b*x については直前の問題と同じなので、bit配列bの要素の値が1のときはCNOTをとればいいことになります。後半については (1-b) というのは結局bの否定なのでbが0のときに計算する必要があり(1-x) というのはx の否定になります。そのため、bが0のときは入力|x>の要素の否定=PauliX操作の結果をCNOTすればいいことになります。注意しないといけないのが、Quantum Oracleとなる操作はユニタリ操作でないといけないので、入力|x>の状態を変えてはいけません。そのためPauliX操作を行ったものは同じ操作をしてもとに戻しておく必要があります。

namespace Solution
{
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Primitive;

    operation Solve (x : Qubit[], y : Qubit, k : Int) : ()
    {
        body
        {
            for (i in 0..Length(x)-1) 
            {
                if (b[i] == 1) 
                {
                    CNOT(x[i], y);
                }
                else 
                {
                    // do a 0-controlled NOT
                    X(x[i]);
                    CNOT(x[i], y);
                    X(x[i]);
                }
            }
        }
    }
}

Coding Contestの問題と答えがあるので、照らし合わせてなんとかという感じでまとめました。もうちょっと具体的な問題とアルゴリズムに対するQuantum Oracleがあればよりわかるようになるかもしれません...

*1:順番自体はどうでもよく、とにかく全要素を１回ずつ適用すればよい