チュートリアル Linear Algebra Part3解答例

Exercise 13: Finding an eigenvalue

@exercise

def find_eigenvalue(a : Matrix, v : Matrix) -> float:

    n = len(v)
    x = matrix_mult(a, v)

    for i in range(n):
        if v[i][0] ==0:
            continue
        else:
            return x[i][0] / v[i][0]

Exercise 14**: Finding an eigenvector

@exercise
def find_eigenvector(a : Matrix, x : float) -> Matrix:
    v = create_empty_matrix(2, 1)
    if a[0][0] == 0 and a[1][0] == 0:
        v[0][0] = 0
        v[1][0] = a[1][1] / x
    elif a[1][0] == 0 and a[1][1] == 0:
        v[0][0] = a[0][0] / x
        v[1][0] = 0
    else:
        v[0][0] = a[0][1]
        v[1][0] = x - a[0][0]

    return v

チュートリアル Linear Algebra Part2解答例

Exercise 9: Inner product. (行列の内積)

@exercise
def inner_prod(v : Matrix, w : Matrix) -> complex:
    n = len(v)
    
    c = create_empty_matrix(n, 0)
    c = conjugate(v)
    
    x = 0 + 0j
    for i in range(n):
        x =x + c[i][0] * w[i][0]

    return(x)

Exercise 10: Normalized vectors

@exercise
def normalize(v : Matrix) -> Matrix:
    n = len(v)
    m = len(v[0])
    
    w = inner_prod(v, v)
    a = math.sqrt(w.real)
    c = create_empty_matrix(n, m)

    for i in range(n):
        c[i][0] = v[i][0] / a

    return c

Exercise 11: Outer product

@exercise
def outer_prod(v : Matrix, w : Matrix) -> Matrix:
    n = len(v)
    m = len(w)    

    c = create_empty_matrix(m, 0)
    c = conjugate(w)

    d = create_empty_matrix(n, m)
    for i in range(n):
        for j in range(m):
            d[i][j] = v[i][0] * c[j][0]
    return(d)

Exercise 12*: Tensor Product.

@exercise
def tensor_product(a : Matrix, b : Matrix) -> Matrix:
    n = len(a)
    m = len(a[0])    
    k = len(b)
    l = len(b[0])

    c = create_empty_matrix(n * k, m * l)
    for ia in range(n):
        for ja in range(m):
            for ib in range(k):
                for jb in range(l):
                    c[ia*k+ib][ja*l+jb] = a[ia][ja]*b[ib][jb]
    return c

チュートリアル Linear Algebra Part1解答例

Exercise 1: Matrix addition. (行列の足し算)

@exercise
def matrix_add(a : Matrix, b : Matrix) -> Matrix:
    # You can get the size of a matrix like this:
    n = len(a)
    m = len(a[0])
    
    # You can use the following function to initialize an n×m matrix filled with 0s to store your answer
    c = create_empty_matrix(n, m)
    
    # You can use a for loop to execute its body several times;
    # in this loop variable i will take on each value from 0 to n-1, inclusive
    for i in range(n):
        # Loops can be nested
        for j in range(m):
            # You can access elements of a matrix like this:
            x = a[i][j]
            y = b[i][j]
            
            # You can modify the elements of a matrix like this:
            c[i][j] = x + y
    
    return c

Exercise 2: Scalar multiplication (行列の整数倍)

@exercise
def scalar_mult(x : complex, a : Matrix) -> Matrix:
    n = len(a)
    m = len(a[0])    
    c = create_empty_matrix(n, m)
    
    for i in range(n):
        for j in range(m):
            c[i][j] = a[i][j] * x
            
    return c

Exercise 3: Matrix multiplication (行列の掛け算)

@exercise
def matrix_mult(a : Matrix, b : Matrix) -> Matrix:
    n = len(a)
    m = len(a[0])
    l = len(b[0])

    
    c = create_empty_matrix(n, l)
    
    for i in range(n):
        for j in range(l):
            for k in range(m):
                x = a[i][k]
                y = b[k][j]
                c[i][j] += x * y
    
    return c

Exercise 4: Matrix Inversion.  (逆行列)

@exercise
def matrix_inverse(a : Matrix) -> Matrix:
    n = len(a)
    m = len(a[0])

    c = create_empty_matrix(n, m)
    d = (a[0][0]*a[1][1] - a[0][1]*a[1][0])

    c[0][0] = a[1][1] / d
    c[0][1] = a[0][1] / d * -1
    c[1][0] = a[1][0] / d * -1
    c[1][1] = a[0][0] / d
    
    return c

Exercise 5: Transpose. (転置行列)

@exercise
def transpose(a : Matrix) -> Matrix:
    n = len(a)
    m = len(a[0])    
    c = create_empty_matrix(m, n)
    
    for i in range(m):
        for j in range(n):
            c[i][j] = a[j][i]
            
    return c

Exercise 6: Conjugate. (共役行列)

@exercise
def conjugate(a : Matrix) -> Matrix:
    n = len(a)
    m = len(a[0])
    
    c = create_empty_matrix(n, m)
    
    for i in range(n):
        for j in range(m):
            c[i][j] = a[i][j].real - a[i][j].imag * 1j
    
    return c

Exercise 7: Adjoint. (随伴行列)

@exercise
def adjoint(a : Matrix) -> Matrix:
    n = len(a)
    m = len(a[0])

    c = create_empty_matrix(n, m)
    c = transpose(conjugate(a))
    return c

Exercise 8: Unitary Verification (ユニタリー行列)

from pytest import approx

@exercise
def is_matrix_unitary(a : Matrix) -> bool:
    n = len(a)

    c = create_empty_matrix(n, n)
    d = create_empty_matrix(n, n)

    c = adjoint(a)

    d = matrix_mult(a,c)
    for i in range(n):
        for j in range(n):
            if i == j:
                if d[i][j] != approx(1):
                    return False
            else:
                if d[i][j] != approx(0):
                    return False
    return True

QuantumKatas チュートリアルComplexArithmetic の解答例

Exercise 1: Powers of  𝑖 

@exercise
def imaginary_power(n : int) -> int:
    # If n is divisible by 4
    if n % 4 == 0:
        return 1
    else:
        return -1

@exercise
def imaginary_power(n : int) -> int:
    return 1j**n

Exercise 2: Complex addition (複素数の足し算)

@exercise
def complex_add(x : Complex, y : Complex) -> Complex:
    # You can extract elements from a tuple like this
    a = x[0]
    b = x[1]
    
    c = y[0]
    d = y[1]
    
    # This creates a new variable and stores the real component into it
    real = a + c
    # Replace the ... with code to calculate the imaginary component
    imaginary = b + d
    
    # You can create a tuple like this
    ans = (real, imaginary)
    
    return ans

Exercise 3: Complex multiplication (複素数の掛け算)

@exercise
def complex_mult(x : Complex, y : Complex) -> Complex:
    # Fill in your own code
    a = x[0]
    b = x[1]
    
    c = y[0]
    d = y[1]
    # This creates a new variable and stores the real component into it
    real = a*c - b*d
    # Replace the ... with code to calculate the imaginary component
    imaginary = a*d + b*c
    
    ans = (real, imaginary)
    return ans

Exercise 4: Complex conjugate (複素共役)

@exercise
def conjugate(x : Complex) -> Complex:
    a = x[0]
    b = x[1]
    ans = (a, -b)
    return ans

Exercise 5: Complex division (複素数の割り算)

@exercise
def complex_div(x : Complex, y : Complex) -> Complex:
    a = x[0]
    b = x[1]
    
    c = y[0]
    d = y[1]

    r = (a*c + b*d) / (c**2 + d**2)
    i = (b*c - a*d) / (c**2 + d**2)
    ans = (r, i)
    return ans

Exercise 6: Modulus. (複素数の絶対値)

@exercise
def modulus(x : Complex) -> float:
    a = x[0]
    b = x[1]
    
    ans = (math.sqrt(a**2 + b**2))
    return ans

Exercise 7: Complex exponents (複素数の指数演算)

@exercise
def complex_exp(x : Complex) -> Complex:
    a = x[0]
    b = x[1]

    ans = (math.pow(math.e, a) * math.cos(b), math.pow(math.e, a) * math.sin(b)) 
    return ans

Exercise 8*: Complex powers of real numbers (複素数の指数演算)

@exercise
def complex_exp_real(r : float, x : Complex) -> Complex:
    a = x[0]
    b = x[1]

    if r==0:
        return (0, 0)
    else:
        c = math.log(r)
    
    ans = (math.pow(math.e, c*a) * math.cos(c*b), math.pow(math.e, c*a) * math.sin(c*b))
    return ans

Exercise 9: Cartesian to polar conversion (極座標系)

@exercise
def polar_convert(x : Complex) -> Polar:
    a = x[0]
    b = x[1]

    theta = math.atan2(b,a)
    r = a / math.cos(theta)
        
    return (r, theta)

Exercise 10: Polar to Cartesian conversion (極座標系)

@exercise
def cartesian_convert(x : Polar) -> Complex:
    r = x[0]
    theta = x[1]
    
    ans = (r * math.cos(theta), r * math.sin(theta))
    return ans

Exercise 11: Polar multiplication (極座標系の掛け算)

@exercise
def polar_mult(x : Polar, y : Polar) -> Polar:
    r1 = x[0]
    t1 = x[1]
    r2 = y[0]
    t2 = y[1]

    a = r1 * math.cos(t1)
    b = r1 * math.sin(t1)
    c = r2 * math.cos(t2)
    d = r2 * math.sin(t2)
    
    theta = math.atan2((a*d + b*c), (a*c - b*d))
    r = (a*c - b*d) / math.cos(theta)
    return (r, theta)

@exercise
def polar_mult(x : Polar, y : Polar) -> Polar:
    r1 = x[0]
    t1 = x[1]
    r2 = y[0]
    t2 = y[1]

    t3 = (t1 + t2) % (2 * math.pi)
    if t3 > math.pi:
        t3 = t3 - 2*math.pi     
    return ((r1 * r2), t3)

Exercise 12**: Arbitrary complex exponents (任意の複素数の指数演算)

@exercise
def complex_exp_arbitrary(x : Complex, y : Complex) -> Complex:
    a = x[0]
    b = x[1]
    p = y[0]
    q = y[1]
    
    modulus = (math.sqrt(a**2 + b**2))
    if a == 0 and b == 0:
        return(0, 0)
    theta = math.atan2(b,a)
    alpha = p * math.log(modulus) - q * theta
    beta  = q * math.log(modulus) + p * theta

    real = math.pow(math.e, alpha) * math.cos(beta)
    imag = math.pow(math.e, alpha) * math.sin(beta)

    return(real, imag)

Microsoft Q# (qsharp)とは

Microsoft Quantum Katasとは

The Quantum Katas are a series of self-paced tutorials to help you learn quantum computing and Q# programming.

• Complex arithmetic. (複素数)
  Learn about complex numbers and the mathematics required to work with quantum computing.
  解答例・解説
• Linear algebra. (線型代数)
  Learn about vectors and matrices used to represent quantum states and quantum operations.
  解答例・解説(Part 1), (Part 2), (Part 3)
• The qubit. (量子ビット)
  Learn what a qubit is.
  解説
• Single-qubit gates.(1量子ビットゲート)
  Learn what a quantum gate is and about the most common single-qubit gates.
  解答例・解説
• Multi-qubit systems.(複数量子ビットシステム)
  Learn to represent multi-qubit systems.
  解答例・解説
• Multi-qubit gates. (複数量子ビットゲート)
  Learn about the most common multi-qubit gates.
  解答例・解説
• Exploring Deutsch–Jozsa algorithm.
  Learn to implement classical functions and equivalent quantum oracles, and compare the quantum solution to the Deutsch–Jozsa problem to a classical one.
  解答例・解説 (Part 1), (Part 2), (Part 3), (Part 4)
• Exploring Grover's search algorithm.
  Learn more about Grover's search algorithm, picking up where the Grover's algorithm kata left off.

Quantum Katasを動かすための環境設定

Quantum Katasをonline動かす

Quantum Katasを自分のJupyterで動かす

jupyterインストール&起動

gitからクローン

git clone https://github.com/microsoft/QuantumKatas.git

Amazon Braket – A fully managed service that allows scientists, researchers, and developers to begin experimenting with computers from multiple quantum hardware providers in a single place.

基本的な量子処理を動かしてみる

Q# Operationの定義

namespace Quantum.Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

    operation Set(desired : Result, q1 : Qubit) : Unit {
        if (desired != M(q1)) {
            X(q1);
        }
    }
}

Setオペレーション についての解説

実際に動かしてみる

namespace Quantum.Bell {                                                                                                    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

    operation Set(desired : Result, q1 : Qubit) : Unit {
            if (desired != M(q1)) {
                    X(q1);
            }
    }

    operation TestBellState(count : Int, initial : Result) : (Int, Int) {
        mutable numOnes = 0;
        using (qubit = Qubit()) {
            for (test in 1..count) {
                 Set(initial, qubit);
                 let res = M(qubit);
                 // Count the number of ones we saw:
                 if (res == One) {
                     set numOnes += 1;
                }
            }
            Set(Zero, qubit);

            // Return number of times we saw a |0> and number of times we saw a |1>
            return (count-numOnes, numOnes);
        }
    }
}

import qsharp

from qsharp import Result
from Quantum.Bell import TestBellState

initials = (Result.Zero, Result.One)

for i in initials:
    res = TestBellState.simulate(count=1000, initial=i)
    (num_zeros, num_ones) = res
    print(f'Init:{i: <4} 0s={num_zeros: <4} 1s={num_ones: <4}')

$ python host.py
Preparing Q# environment...
..Init:0    0s=1000 1s=0
Init:1    0s=0    1s=1000