DEV Community: Takumi Kato

Get Started 1 Qubit VQE with Blueqat

Takumi Kato — Thu, 13 Feb 2020 01:57:00 +0000

Get Started VQE with Blueqat

Blueqat, the quantum computing library assists to write variational quantum eigensolver (VQE) algorithm.

This article explains how to write VQE for 2x2 Hamiltonian in Blueqat.

If you want to know the overview of VQE, this article is prefer.

All you need is Hamiltonian and Ansatz

First, you have to make a Hamiltonian, it is the problem to solve with VQE.
Second, you have to prepare "ansatz", it is parametrized quantum circuit.

Blueqat prepares some built in ansatzes like QAOA ansatz. However, sometimes, it is not enough to solve your Hamiltonian.

In this article, we define new ansatz for 1 qubit (2x2 Hamiltonian) VQE.

`blueqat.pauli` helps to make the Hamiltonian

Making Hamiltonian by Pauli matrices is very easy.

from blueqat.pauli import X, Y, Z, I

h = 1.23 * I - 4.56 * X(0) + 2.45 * Y(0) + 2.34 * Z(0)

Making randomized Hamiltonian

We make randomized Hamiltonian.

from random import random
from blueqat.pauli import X, Y, Z, I

h = random() * I + random() * X(0) + random() * Y(0) + random() * Z(0)

Now, h is a Hamiltonian with random matrix coefficient.

Ansatz is a class which inherits `blueqat.vqe.AnsatzBase`

Ansatz is a class which inherits blueqat.vqe.AnsatzBase and is implemented get_circuit() method.

To make a arbitrary 1 qubit gate, apply a RY gate and a RZ gate is enough.
Let's make the ansatz.

from blueqat import Circuit
from blueqat.vqe import AnsatzBase

class OneQubitAnsatz(AnsatzBase):
    def __init__(self, hamiltonian):
        AnsatzBase.__init__(hamiltonian, 2) # Hamiltonian and the number of parameters

    def get_circuit(self, params):
        # Return a circuit which applied a RY gate and a RZ gate.
        a, b = params
        return Circuit().ry(a)[0].rz(b)[0]

Very simple.

VQE works with a Hamiltonian and an ansatz

from blueqat.vqe import Vqe

h = random() * I + random() * X(0) + random() * Y(0) + random() * Z(0)
runner = Vqe(OneQubitAnsatz(h))
result = runner.run()

print('Result by VQE')
print(runner.ansatz.get_energy(result.circuit, runner.sampler))

runner = Vqe(OneQubitAnsatz(h)): Make a runner to run the VQE with the ansatz.
result = runner.run(): Run the VQE and get the result.

runner.ansatz.get_energy(result.circuit, runner.sampler): Get the energy from result.
This is the most complicated line in this article. Copy and paste is your friend!

Now, you obtained the energy (smallest eigenvalue of the Hamiltonian matrix).

Compare the result with numpy's solution

Is our result correct answer? Let's compare with numpy's solution.

blueqat.pauli can transform Hamiltonian to numpy's array by to_matrix() method.
We can get the eigenvalue by np.linalg.eigh.

import numpy as np
# Hamiltonian to matrix
mat = h.to_matrix()
# Calculate by numpy
print('Result by numpy')
print(np.linalg.eigh(mat))

Run from the beginning to the end

Whole source code is as following:

from random import random
import numpy as np
from blueqat import Circuit
from blueqat.pauli import X, Y, Z, I
from blueqat.vqe import AnsatzBase, Vqe

class OneQubitAnsatz(AnsatzBase):
    def __init__(self, hamiltonian):
        super().__init__(hamiltonian, 2)

    def get_circuit(self, params):
        a, b = params
        return Circuit().ry(a)[0].rz(b)[0]


# Calculate by VQE
h = random() * I + random() * X(0) + random() * Y(0) + random() * Z(0)
runner = Vqe(OneQubitAnsatz(h))
result = runner.run()

print('Result by VQE')
print(runner.ansatz.get_energy(result.circuit, runner.sampler))

# Hamiltonian to matrix
mat = h.to_matrix()
# Calculate by numpy
print('Result by numpy')
print(np.linalg.eigh(mat)[0][0])

This is the example of result.
You can see VQE result and numpy result are almost same value.

Result by VQE
-0.7072131424381115
Result by numpy
-0.7072139372798669

Summary

Blueqat library can write the VQE easily.

Mastering Python’s getitem and slicing

Takumi Kato — Mon, 20 May 2019 03:29:04 +0000

In Python’s data model, when you write foo[i] , foo.__getitem__(i) is called. You can implement __getitem__ method in your class, and define the behaviour of slicing.

Example:

class Foo:
    def __getitem__(self, key):
        print(key)
        return None

foo = Foo()
foo[1] # => print(1)
foo["aaa"] # => print("aaa")

As you know, Python can slice more complicated object.

# comma separated slicing
d = {}
d[1, "hello"] = 3

# colon separated slicing
ls = [0, 1, 2, 3]
ls[:2]
ls[3:]
ls[2:4]
ls[::2]
ls[1:4:-1]
ls[:]
ls[::]

# both comma and colon
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
a[:2, 1:3]

Let’s inspect what kind of object is passed to __getitem__ argument.

Comma Separated Slicing

First, we check comma separated slicing.
To inspect, we define Inspector class.

class Inspector:
    def __getitem__(self, key):
        return key

Then, we can inspect the slicing.

a = Inspector()
a[1] # => 1: int

a[1, 2] # => (1, 2): tuple

a[1, 2, 3] # => (1, 2, 3): tuple

a[] # => SyntaxError

This behaviour is very similar to right hand side of assignment expression.

t = 1 # 1: int
t = 1, 2 # (1, 2): tuple
t = 1, 2, 3 # (1, 2, 3): tuple
t = # SyntaxError

More examples needed?

a[(1, 2, 3)] # (1, 2, 3): tuple
assert a[(1, 2, 3)] == a[1, 2, 3]
t = (1, 2, 3)
u = 1, 2, 3
assert t == u

# tuple of one element.
a[1,] # (1,): tuple
t = 1, # (1,): tuple
a[(1,)] # (1,): tuple
t = (1,) # (1,): tuple

# empty tuple
a[()] # (): tuple
t = () # (): tuple

t = 1, 2
assert a[t] == a[1, 2]

a[(1, 2), 3] # ((1, 2), 3): tuple
t = (1, 2), 3 # ((1, 2), 3): tuple

However, starred item and yield expression are not allowed for slicing.

t = *iter([]), 1 # (1,): tuple
a[*iter([]), 1] # SyntaxError: invalid syntax

def g():
    t = yield 1 # Valid.
    a = Inspector()
    a[yield 1] # SyntaxError: invalid syntax

Conclusion of comma separated slice

As same as right hand side of assignment expression, comma separated slice is interpreted as tuple.

Colon separated slice

Let us inspect colon separated slice.

# As same as above part.
class Inspector:
    def __getitem__(self, key):
        return key

a = Inspector()

Colon separated slice makes a slice object.

a[1:2:3] # => slice(1, 2, 3)
assert a[1:2:3] == slice(1, 2, 3)

Docstring of slice object is:

slice(stop)
slice(start, stop[, step])

Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).

Colon separated slice’s notifications are [start:], [start::], [:stop], [:stop:], [::step], [start:stop], [start:stop:], [start::step], [:stop:step] and [start:stop:step].

start = 1
stop = 2
step = 3

assert a[start:] == a[start::] == slice(start, None, None) == slice(start, None)

assert a[:stop] == a[:stop:] == slice(None, stop, None) == slice(stop)

assert a[start:stop] == a[start:stop:] == slice(start, stop, None) == slice(start, stop)

assert a[:stop:step] == slice(None, stop, step)

assert a[start:stop:step] == slice(start, stop, step)

Now, we understood relations between colon separated slicing and slice object.

Type of start, stop, step are not only integer. Any types are acceptable.

a[[]:{}:"abc"] # => slice([], {}, "abc")

class MyClass:
    pass

a[MyClass():MyClass()] # => slice(MyClass(), MyClass())

Handling of slice object

slice object have start, stop, and step properties.

sl = slice(1, '2', [3])

sl.start # => 1
sl.stop # => '2'
sl.step # => [3]

sl = slice('stop')

sl.start # => None
sl.stop # => 'stop'
sl.step # => None

slice object have indices(len) method.

Docstring is:

S.indices(len) -> (start, stop, stride)

Assuming a sequence of length len, calculate the start and stop
indices, and the stride length of the extended slice described by
S. Out of bounds indices are clipped in a manner consistent with the
handling of normal slices.

indices method returns if start , stop , step properties are not None and in the range of [0, len], returns them, otherwise, returns suitable value.

It helps to implement the slicing as same as list object.

li = [i for i in range(10)]
def make_list(start, stop, stride):
    t = []
    if stride > 0:
        while start < stop:
            t.append(start)
            start += stride
    else:
        while start > stop:
            t.append(start)
            start += stride
    return t

start, stop, stride = a[6:].indices(10)
# start, stop, stride = 6, 10, 1
assert li[6:] == make_list(start, stop, stride) == [6, 7, 8, 9]

start, stop, stride = a[:7:2].indices(10)
# start, stop, stride = 0, 7, 2
assert li[:7:2] == make_list(start, stop, stride) == [0, 2, 4, 6]

start, stop, stride = a[:].indices(10)
# start, stop, stride = 0, 10, 1
assert li[:] == make_list(start, stop, stride) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

start, stop, stride = a[15:].indices(10)
# start, stop, stride = 10, 10, 1
assert li[15:] == make_list(start, stop, stride) == []

start, stop, stride = a[-3:].indices(10)
# start, stop, stride = 7, 10, 1
assert li[-3:] == make_list(start, stop, stride) == [7, 8, 9]

start, stop, stride = a[:5:-2].indices(10)
# start, stop, stride = 9, 5, 2
assert li[:5:-2] == make_list(start, stop, stride) == [9, 7]

Conclusion of colon separated slicing

Colon separated slicing returns slice object. It has 3 properties. start, stop and step. If you want to implement the slicing as same as list object’s implementation, slice.indices method is helpful.

Both comma and colon separated slicing

In this case, it is interpreted as tuple of slice.

class Inspector:
    def __getitem__(self, key):
        return key

a = Inspector()

a[1:2,3:4] # (slice(1, 2, None), slice(3, 4, None))
a[1,2:3,4] # (1, slice(2, 3, None), 4)
a[1:(2,3):4] # slice(1, (2, 3), 4)

`index` method

__index__ method is very important to be a slicing master.

import numpy as np

i = np.int32(3)
print(i) # => '3'
print(type(i)) # => 'np.int32'

In this code, is ia integer?

Yes. It is an integer but not a Python’s builtin int type object.

It may cause some troubles in your __getitem__ implementation. You may want to convert to Python’s builtin int type.

You may think int(i) returns builtin int type. Yes, it is commonly used in Python. However, if i is floating point number, you may not want to convert to integer value. In this case, __index__ method is useful.

object.__index__(self)
Called to implement operator.index(), and whenever Python needs to losslessly convert the numeric object to an integer object (such as in slicing, or in the built-in bin(), hex() and oct() functions). Presence of this method indicates that the numeric object is an integer type. Must return an integer.

Note
In order to have a coherent integer type class, when __index__() is defined __int__() should also be defined, and both should return the same value.
(Python documentation Data model)

numpy.int{8, 16, 32, 64}, uint{8, 16, 32, 64} implements __index__ method and it returns Python’s builtin int type. float, numpy’s floating point numbers are not implements __index__ method.

When you want to convert an variable to int type for slicing, you should use this method.

You can also use operator.index function. When __index__ is not implemented foo.__index__() raises AttributeError, operator.index(foo) raises TypeError.

import operator
import numpy as np

i = np.int32(3)
i.__index__() # Returns 3: int
operator.index(i) # Returns 3: int

# builtins int type also implements __index__ method.
i = 3
i.__index__() # Returns 3: int
operator.index(i) # Returns 3: int

# floating point type doesn't implement __index__ method.
i = 3.0
i.__index__() # AttributeError: 'float' object has no attribute '__index__'
operator.index(i) # TypeError: 'float' object cannot be interpreted as an integer

`setitem` and `delitem`

__setitem__ and __delitem__ are similar method with __getitem__.

foo.__setitem__(key, value) is called when foo[key] = value is evaluated. foo.__delitem__(key) is called when del foo[key] is evaluated. You may implement these methods for your class.

Conclusion

In this article, we learned following.

foo[key] calls foo.__getitem__(key)
foo[key] = value calls foo.__setitem__(key, value)
del foo[key] calls foo.__delitem__(key)
foo[k1, k2] calls foo.__getitem__((k1, k2))
foo[k1:k2:k3] calls foo.__getitem__(slice(k1, k2, k3))
Integer type implements __index__ method

This knowledge is useful for implementation of your subscriptable class.

Understanding how to create Toffoli gate using Blueqat

Takumi Kato — Mon, 20 May 2019 03:11:09 +0000

What is Blueqat?

Blueqat is an open source library for quantum computer.
https://github.com/Blueqat/Blueqat

How to install Blueqat?

Blueqat is provided as Python (ver 3.6+) library. You can install by pip.

pip install blueqat

What is Toffoli gate?

Toffoli gate is 2-controlled NOT gate. If both 2 control qubits are |1>, Toffoli gate flip a target qubit (|0> → |1>, |1> →|0>), otherwise do nothing.

Truth table for Toffoli gate

c1	c2	t
0	0	0 → 0
0	0	1 → 1
0	1	0 → 0
0	1	1 → 1
1	0	0 → 0
1	0	1 → 1
1	1	0 → 1
1	1	1 → 0

Toffoli gate implementation of IBM OpenQASM

OpenQASM's standard library qelib1.inc defines the Toffoli gate. Here is its definition.

gate ccx a,b,c
{
  h c;
  cx b,c; tdg c;
  cx a,c; t c;
  cx b,c; tdg c;
  cx a,c; t b; t c; h c;
  cx a,b; t a; tdg b;
  cx a,b;
}

"h" is a Hadamard gate, "cx" is a CNOT gate, "t" is a T gate which rotates the Bloch sphere Z-axis by π/4 radians, and "tdg" is T† gate which rotates the Bloch spere Z-axis by -π/4 radians.

To understand this implementation, we reorder some operations. Generally, gate operations are not commutable. However, some gates can be commutable for example single qubit operation for i-th qubit and for j-th qubit, if i ≠ j, they're commutable. cx a, b and t a are also commutable because T gate rotate only Z-axis and CNOT gate don't minds control qubit's phase.

Here is reordered implementation.

gate ccx a,b,c
{
  h c;
  cx b,c; tdg c;
  cx a,c; t c;
  cx b,c; tdg c;
  cx a,c; t c;
  h c;
  t a; t b;
  cx a,b; tdg b; cx a,b;
}

This implementation can be separate to 2 parts. First part is making ccx except phase adjustment, second part is adjusting phase factors.

Create Toffoli gate

First part, some operations are sandwiched with Hadamard gates.

  h c;
  cx b,c; tdg c;
  cx a,c; t c;
  cx b,c; tdg c;
  cx a,c; t c;
  h c

To begin from conclusion, 2-controlled Z gate is sandwiched with H gates.
As we know, -H-Z-H- gate is X gate. We can confirm it with Blueqat.

from blueqat import Circuit
print(Circuit().h[0].z[0].h[0].to_unitary())
# => Matrix([[0, 1], [1, 0]]), This is X gate.
# We can see X gate definition by
print(Circuit().x[0].to_unitary())
# => Matrix([[0, 1], [1, 0]]), Yes! They're same!

If you're using Jupyter Notebook, you can get more pretty display.

Controlled Z gate sandwiched with H gates for target qubit is CNOT gate.

As same as these, 2-controlled Z gate sandwiched with H gates is Toffoli gate. However, in this part, we will get strange 2-controlled Z gate because adjustment of phase factor is not yet.

Let us implement 2-controlled Z gate using Blueqat.

cx b,c; tdg c;
cx a,c; t c;
cx b,c; tdg c;
cx a,c; t c;

We choose a = 2, b = 1, c = 0.
Implementation is very easy.

from blueqat import Circuit
c = Circuit()
c.cx[1, 0].tdg[0]
c.cx[2, 0].t[0]
c.cx[1, 0].tdg[0]
c.cx[2, 0].t[0]
c.to_unitary()

Phase factor is strange, but similar to 2-controlled Z gate.

Add H gates before first opearation and after last operation.

Is it a Toffoli gate? It seems not a Toffoli gate. But if we know, exp(-iπ/4) = i * exp(iπ/4), we can feel it is similar to Toffoli gate.

Blueqat's unitary gate is Sympy matrix and Sympy can simplify these terms automatically. Let's simplify the unitary matrix.

It is as same as Toffoli gate except phase factors.

Then, we will see second part.

 t a; t b;
 cx a,b; tdg b; cx a,b;

What is this means? Check by Blueqat.

Wow! This part multiples phase factor i if both qubit 1 and qubit 2 are |1>.

Finally, we combine first part and second part.

Is something wrong? Don't worry. First, exp(3iπ/8) = (-1)^3/8 because -1 =exp(iπ) and then, we can ignore scalar part of unitary matrix, it is "global phase".

So, divide by [0, 0]-th element and simplify the matrix, we can get Toffoli gate matrix.

Perfect!

Learn Blueqat more!

I'm a core developer of Blueqat. Blueqat has very simple and easy interface for quantum computing. I recommend to use Blueqat for learning quantum computer programming.

We prepared Blueqat tutorials and we will add more and more contents.
https://github.com/Blueqat/Blueqat-tutorials

If you have any questions or suggestions, please feel free to contact us by our Slack community. (Join from here)

Blueqat repository is here.
https://github.com/Blueqat/Blueqat