EMULATORS OF QUANTUM COMPUTERS ON QUBITS AND ON QUDITS Текст научной статьи по специальности «Компьютерные и информационные науки»

EDUCATIONAL RESOURCES AND BEST PRACTICES OF IT-EDUCATION / ОБРАЗОВАТЕЛЬНЫЕ РЕСУРСЫ И ЛУЧШАЯ ПРАКТИКА ИТ-ОБРАЗОВАНИЯ

УДК 004.27

DOI: 10.25559/SITITO.18.202202.455-467

Emulators of Quantum Computers on Qubits and on Qudits

A. S. Andreev, P. V. Khrapov*

Bauman Moscow State Technical University, Moscow, Russian Federation Address: 5, 2-nd Baumanskaya St., building 2, Moscow 105005, Russian Federation * [email protected]

Abstract

Quantum computing is still a developing, but an extremely promising area. The article lays out the main ideas behind quantum computing in simple terms. The topic of quantum computers based on qudits - multidimensional analogues of qubits, which have recently received much attention due to their efficiency, is also covered. The fundamentals of quantum mechanics, which are necessary for understanding the principles of operation of a quantum computer, such concepts as qubits and qudits, linear operators, the measurement process, etc are introduced. As an example of quantum computing, the principle of operation of the Deutsch-Jozsa algorithm, one of the first quantum algorithms to demonstrate their advantages, and its generalization to qudits, are analyzed in detail. The process of writing the simplest quantum computer emulator in the Python programming language is described step by step. The emulator operates with an arbitrary number of qubits and allows you to apply arbitrary operators to them and carry out multiple measurements of the final state of the qubit. A generalization of this emulator for working with qudits is given after that. To demonstrate the emulator we have written, we present programs that implement the Deutsch-Jozsa algorithm and its generalizations on it, and test them.

Keywords: quantum computer, qubit, qudit, quantum emulator, Deutsch-Jozsa algorithm

The authors declare no conflict of interest.

For citation: Andreev A.S., Khrapov P.V. Emulators of Quantum Computers on Qubits and on Qudits. Sovremennye informacionnye tehnologii i IT-obrazovanie = Modern Information Technologies and IT-Ed-ucation. 2022; 18(2):455-467. doi: https://doi.org/10.25559/SITITO.18.202202.455-467

(cc^(D

Контент доступен под лицензией Creative Commons Attribution 4.0 License. The content is available under Creative Commons Attribution 4.0 License.

Modern Information Technologies and IT-Education

Эмуляторы квантовых компьютеров на кубитах и на кудитах

А. С. Андреев, П. В. Храпов*

ФГБОУ ВО «Московский государственный технический университет имени Н.Э. Баумана (национальный исследовательский университет)», г. Москва, Российская Федерация Адрес: 105005, Российская Федерация, г. Москва, ул. 2-я Бауманская, д. 5, к. 1 * [email protected]

Аннотация

Квантовые вычисления - это развивающаяся и чрезвычайно перспективная область. В статье простыми словами изложены основные идеи, лежащие в основе квантовых вычислений. Также освещается тема квантовых компьютеров на основе кубитов - многомерных аналогов кубитов, которым в последнее время уделяется большое внимание благодаря их эффективности. Вводятся основы квантовой механики, которые необходимы для понимания принципов работы квантового компьютера, такие понятия, как кубиты и кудиты, линейные операторы, процесс измерения и т.д. В качестве примера квантовых вычислений подробно анализируются принцип работы алгоритма Дойча-Йожа, одного из первых квантовых алгоритмов, продемонстрировавшего свои преимущества, и его обобщение на кудиты. Пошагово описан процесс написания простейшего эмулятора квантового компьютера на языке программирования Python. Эмулятор работает с произвольным количеством кубитов и позволяет применять к ним произвольные операторы и проводить множественные измерения конечного состояния кубита. После этого дается обобщение этого эмулятора для работы с кудитами. Чтобы продемонстрировать написанный нами эмулятор, мы представляем программы, реализующие алгоритм Дойча-Йожа и его обобщения на нем, и тестируем их.

Ключевые слова: квантовый компьютер, кубит, кудит, квантовый эмулятор, алгоритм Дойча-Йожа

Авторы заявляют об отсутствии конфликта интересов.

Для цитирования: Андреев А. С., Храпов П. В. Эмуляторы квантовых компьютеров на кубитах и на кудитах // Современные информационные технологии и ИТ-образование. 2022. Т. 18, № 2. С. 455-467. doi: https://doi.org/10.25559/SITITO.18.202202.455-467

Современные информационные технологии и ИТ-образование

Том 18, № 2. 2022 ISSN 2411-1473 sitito.cs.msu.ru

Introduction

Quantum computing is still a developing, but an extremely promising area.

Computations on quantum computers are carried out by applying operations to qubits, the quantum counterparts of classical bits. The main feature of qubits is stated in the principle of superposition: a qubit can be in several states at the same time. This allows using one operation to perform calculations for all states of the system at once, in contrast to a classical computer, in which calculations would have to be performed sequentially or in parallel. However, after this operation is executed, the qubit will also be in a state of superposition, and when we try to measure the results of calculations, we will find out the result of only one calculation, randomly selected from all possible ones. Fortunately, we can get a well-defined result with the help of certain additional operations, from which we can get general information about the calculations performed.

Since quantum computers are currently quite complex in design and not available for general use, one has to resort to emulating quantum algorithms on a classical computer to study them. A large number of quantum emulators have been created by now1 [1]-[9], including the developments of such companies as Microsoft2 and IBM3, which even allow you to run algorithms on real quantum computers. However, it is useful to understand how an emulator works at a basic level for better understanding of this area.

Recently, computers based on the so-called "qudits”, that is, multidimensional qubits, have become quite promising [10]-[19]. These are quantum systems that have not two, but three (qutrits) or more states. Qudits allow much fewer quantum systems to encode the same information, and therefore are a possible solution to the main problem of modern quantum computers - their instability. In May 2022, a group of scientists from the Russian Quantum Center received a patent for the physical implementation of a quantum computer based on qudits4.

In this article, we will try to outline the main ideas of quantum computing, demonstrate them on the example of one of the first quantum algorithms, and then consolidate them using a simple emulation of a quantum computer on qubits and qudits in the Python language. The simplicity of the emulator will allow it to be used on normal personal computers, regardless of any additional software, and will make it available everywhere.

Qubits and operations on them

A qubitis a quantum system that has two possible measurable states5. Thesestates are referred as |0) and |1).The superposition principle6 states that a qubit can also bein alinear combination of states |ф) = a|0) + ft|1), where a and b are complex numbers [20]-[23]. Thus, the set of states of a qubit lies in a twodimensional complex linear space, and for their designation, we canusethematrix notation

= (»>

Then

|0) = (0) - |1) = (0).

Whenmeasuring a qubit in this state, the result can still be only |0) and |1), and it is impossible to predict in advance which state will be measured. The only available information is the probabilities of obtaining different results, equal to αα* = |α|2 and bb* = |ft|2 for |0) and |1) respectively (a* is a complex conjugateof a). The state of thequbit changes to correspond to the result of the measurement. Sincenothing but |0) and |1) can be measured, the condition |a|2 + |fo|2 = 1 isimposed on a and b.

Any qubit state transformations are given by a linear operator7.

 = (“11 a12)

= U21 Я22).

Let |ф) = a|0) + ft|1) and |φ) = c|0) + d|1) be two states of a qubit. We define their scalar product in the following formula

(φ|φ) = |φ)+|φ) = (a* ft*) Q) = a*c + ft*d,

where |φ)+ is the operation of vector transposition and complex conjugation of its components. For any state |φ) (φ|φ) = 1.

Let us define |Лф) = Л|ф), then |Лф)+ = (ф|Л+.

(іф|ф) = (фИ+|ф) = (ф|і+ф).

The operator Â+ is said to be conjugate to the operator  After any transformation Â, the following equality must hold:

1 = (ІФИФ) = (ф|і+і|ф),

1 Boev A.S., Lvovsky A.I., Semenov A.M., et al. PolySimCIM Quantum Computing Software Emulator. Patent RF, no. 2021619034, 2021. Available at: https://www.elibrary. ru/item.asp?ysclid=lbo3rtj71q803318987&id=46313237 (accessed 16.03.2022). (In Russ.)

2 Azure Quantum [Electronic resource]. 2022. Available at: https://azure.microsoft.com/ru-ru/sendces/quantum/#overview (accessed 16.03.2022). (In Russ.)

3 Open-Source Quantum Development. Qiskit [Electronic resource]. 2022. Available at: htt/ze/qisLt.org (a(req(ed 16.03.2022). /InEng.)

4 Patrakova A. Scientists from Russia patented a new quantum processor architecture. [Elactarnii rccouuce]. 2u.05u022. Aeaile. le at: htspz:///news.our(iqk/ n549297 (accessed 16.03.2022). (In Russ.)

5 Nielsen M.A., Chuang I.L. Quantum Computation and Quantum Information. 10th ed. Cam.ridgH Univnss(ty Pr/s/; 2011. 702 p. (In Eng.)

6 Landau L.D., Lifshitz L.M. Quantum Mechanics: Non-Relativistic Theory. 3rd ed. Butterworth-Heinemann; 1981. 689 p. (In Eng.); Griffiths D.J. Introduction to quantum mechanics. Upper Saddle River, NJ: Pearson Prentice Hall; 2005. (In Eng.)

7 Hughes C., Isaacson J., Perry A., Sun R.F., Turner, J. Quantum Computing for the Quantum Curious. Springer, Cham; 2021. 150 p. (In Eng.) doi: https://doi.

org/10.1007/978-3-030-61601-4

Modern Information Technologies and IT-Education

which is obviously true if the operator is unitary, that is Â+ = Â-1. Therefore, all operators which we will deal with are unitary.

The simplest and at the same time quite common example of such operator is

Since Z|0) = 11) and Z|1) = |0), Z is called an analogue ofthe classical negation operation (NOT gate).

The Hadamard gate is another important operator.

It converts “pure” states into a “superposition” states and vice versa:

Я|0) = J2(|0) + |1)),

Я|1) = ^=(|0>- |1)),

»4(i Λ)(ΐ ЛИ(0 0)= '■

Я-1 = Я.

Systems of several qubits

Let us havetwo qubits inthestates = (^) and |ψ2) = (^). Thegeneral state ofthe system can be specified using the Kronecker product:

Shorthand notation |ψ1) ® ^2) = = |ψ1, ψ2) is

also used. For example, the probability of finding a system in a state |0) ® |0) = |00) is equal to |ac|2 = |a|2 |c|2 (probabilities are multiplied). However, according to the principle of superposition, any linear combination of initial states is permissible, therefore, in the general case, the state vector cannot be decomposed into the product ofthe states of individual qubits. There is a correlation between measurements of individual qubits.

What do operators acting onpairs of qubits look like? Let А be the operator acting on the first qubit and В - theoperator acting on the second one. Then

Α|ψι) ® В|^2> = (А ® Я)(|И) ® |^2»,

Современные информационные технологии и ИТ-образование

/ацЬц Я11Ь12 0-12^11 Я12012\

_ i а11^21 а11&22 а12^21 а12^22 |

I а21^11 ^21^12 а22^11 <*22^12 I

'а21^21 а21^22 а22^21 а22^22'

An important example of an operator acting on two qubits is CZ, also called CNOT (Controlled NOT) gate. Asthe name suggests, it applies NOT gate depending on thestate of the qubits. Namely, if the first qubit is in the state |0) CNOT does nothing, but if the state of the first qubit is |1), the NOT operation is applied to the second one. Let us write an expression for CZ:

/1 0 0 0\

A system of two qubits can be brought into the so-called "entangled state” using the operators Я and CZ:

= ΙΨ),

= -1=(|00) +|11)).

In this state, the measurement of one qubit completely determines thestate of the other, which can lead to interesting consequences.

The Deutsch-Jozsa algorithm

Now let us consider the simplest quantum algorithm, which is also one of the first, the Deutsch-Jozsa algorithm [24]. The Deutsch-Jozsaalgorithm solves a rather artificial problem, but it clearly demonstrates the advantages of quantum computers and the basic principles of their operation.

Let a Boolean function of one variable / be given: /: {0; 1} ^ {0; 1}. The mainidea of the problem is to determine whether the function is constant or not. A classical computer has to compute both values of the function, therefore two computations are needed, but a quantum computer needs to compute it only once. It may seem that one saved computation is not much. This is true, but there is a simple generalization of this problem to the case of a function of many variables. As the number of variables increases, the number of computations required for a classical computer grows exponentially, while a quantum computer still requires only one computation.

Том 18, № 2. 2022 ISSN 2411-1473 sitito.cs.msu.ru

Now let us consider only the simple case with one variable.

It can be shown that for any function / there exists a unitary operator Uf, that takes the system from a pure state |х)|у) to the state \x)\y ®/(a0), which is comparable in complexity to one computation of f(x) on a classical computer. Here the operation ® denotes addition modulo 2.

Let us prepare our system in the state |0)|1), then apply the Hadamard gate to each qubit.

Я®Я|0>|1> =1(|0) + |1))(|0) - |1)).

Now we apply the operator Of

Of^W + |1))(|0) - |1))j =

= 2 P/(|0)(|0)- |1))+ |1)(|0) - |1))) =

= 2(|0)(|0 0/(0))- |1 0/(0)))) +

+ 2(|1)(|0 0/(1))- |1 0/(1)))).

It can be noticed that

|0 0/(0))- |1 0/(0)) = (-1)/(0)(|0)- |1)).

If /(0) = 0, the state does not change, otherwise it just changes its sign. A similar transformation is also valid for /(1). Thus, we get:

1 ((-1)/(°)|0)(|0) - |1)) + (-1)/(1)|1)(|0) - |1))) =

= 1 ((-1)/(0)|0) + (-1)/(1)|1))(|0) - |1)) =

= 1 (-1)/(0)(|0) + (-1)/(0)+/(1)|1))(|0)- |1))

/(0) + /(1) is even if /(0) = /(1), and is odd if /(0) ψ /(1). With a constant function / the first qubit is in the state (|0) + |1)) and, when the Hadamard gate is applied, goes into the state |0).

For /(0) ψ /(1) the first qubit is in the state -1 (|0) - |1)) and

V2

goes into the state |1). Thus, if we apply the Я 0 ! operator to our system, and then measure the state of the first qubit, we are guaranteed to know whether the function is constant.

Emulation of a quantum computer

Of course, the point of creating a quantum computer is to implement algorithms that a classical computer is not able to efficiently perform. However, an emulator is still a useful tool in the study of quantum algorithms. An emulator makes it possible to test small algorithms using commonly available tools - ordinary computers.

We use the Python programming language because of its simplicity, clarity, as well as a large number of libraries that can simplify our work. Python is one of the most widely used languages at the moment, including the field of quantum computing.

F i g. 1. Computation scheme

First, let us import the required libraries.

import numpy as np import matplotlib.pyplot as jolt import itertools as it

The numpy library allows us to effectively handle vectors and matrices, itertools increases the efficiency of working with loops, and with the help of matplotlib we can display the results of measurements .

All information about our algorithm wül be stored in the object of QuantumCircuit class

class QuantumCircrnt: def__init_(self, nq, nb): self.nq = nq self.nb = nb zero = np.array[[1, 0]) self.imtial_state = np.tile(zero, (nq, l)) self.qbhs = np.array[]]) self.final_state = np.array[]]) self.bits = 0

self.measurements = ]] self.results = np.zeros(2 ** self.nb)

Modern Information Technologies and IT-Education

The parameters nq and nb determine the number of qubits and classical bits in which the results of measurements of qubits are stored. The initial state of the system is stored in the variable initial_state as separate qubits so that they can beeasily changed individually. By default, each qubit is inthe state |0). The general state of the system after applying operators is stored in the final_state vector, a copy of the final state, over which measurements are made, is stored in the qubits vector, and the measurement results are stored in bits. The measuremets list contains information about all the measurements that will be taken after operators have been applied. Since, in general, the result of a quantum algorithm is probabilistic, it is useful to measurethe final state of the qubits multiple times to find out the distribution of possible outcomes. Thefrequency of occurrence of each result is stored in a results vector.

Now let us describe the class methods required for computations.

set_initial_state(qbit, state) allows you to set an initial state for each qubit, which is then applied using the reset_state() function.

def set_initial_state(self, qudit, state): if (abs(state) ** 2).sum() == 1: self.initial_state[qudit] = state else:

print("Incorrect state")

def reset_state(self): state = 1

for s in self.initial_state: state = np.kron(state, s) self.final_state = state self.bits = 0

set_initial_state also checks the entered vector, the sum of the probabilities must always be equal to one. The function np.kron(state, s) denotes theKronecker product | state) ® |s).

The apply_operator method multiplies the matrix of operator  and the state vector.

def apply_operator(self, A):

self.final_state = A @ self.final_state

An operator is often applied to one qubit, while the rest remain unchanged. Let n be the number of the qubit wewant to change (numbering starts from zero). Then the completeoperator looks like this

C = Î ® ® ■■■ ® A fâî ■■■ ® 1= ΐη®Α® ίηψ

n nq — n — 1

where Ik is identity matrix of size 2k x 2k.

For this purpose, we create a method apply1(A, qbit). The variable qbit here denotes the number of the qubit to which the operator is applied.

def apply1(self, A, qbit):

11 = np.identity(2**qbit)

12 = np.identity(2 ** (self.nq - qbit -1))

B = np.kron(l1, A)

Современные информационные технологии и ИТ-образование

B = np.kron(B, 12) self.apply_operator(B)

Let's move on to the implementation of the measurement operation. The measurement function makes the measurement, and measure adds information about the desired measurement (the number of themeasured qubit and the bit inwhich the result is written) to the list of measurements that will be carried out after thealgorithm is executed.

def measurement(self, qbit, bit): all = np.arange(2 ** self.nq)

indices1 = np.array([i for i in all if i & (2**qbit)], dtype=int) indices0 = np.delete(all, np.isin(all, indices1)) # indices0 = all \ indices1

probability1 = (abs(self.qbits[indices1]) ** 2).sum()

if np.random.rand() < probability1: self.qbits[indices1] /= np.sqrt(probability1) self.qbits[indices0] = np.zeros(2 ** (self.nq - 1)) self.bits = self.bits | 2**bit else:

self.qbits[indices0] /= np.sqrt(1 - probability1) self.qbits[indices1] = np.zeros(2 ** (self.nq - 1))

def measure(self, qbit, bit): self.measurements.append([qbit, bit])

First, indices of coordinates of the state vector, in which the desired qubit is inthestate |1) (indices1) or |0) (indices0) are selected, and the probability of finding the qubit inthe state |1) is calculated. For example, if the system is inthe state |ψ) = α|00) + b|01) + c| 10) + d|11) and we need to measure the second qubit, then probability 1 = + ^2. Next, the np.random.rand()

functiongenerates a random number in the interval [0; 1], and depending on its output, the system collapses into one of two states, and the measurement result is written to the self.bits variable.

The run() method performs all measurements once and returns their results.

def run(self): self.qbits = self.final_state for m in self.measurements: self.measurement(m[0], m[1]) returnself.bits

The simulate(num_of_iterations) method runs the algorithm a given number of times and returns the frequency of occurrence of each possible outcome.

def simulate(self, num_of_iterations): self.results = np.zeros(2 ** self.nb) for _ inrange(num_of_iterations): self.results[self.run()] += 1 self.results /= num_of_iterations return self.results

The barplot() method plots the distribution of results.

Том 18, № 2. 2022 ISSN 2411-1473 sitito.cs.msu.ru

def barplot(self): labels = [] # column names for x in range(2 ** nb): b = bin(x)[2:] # trims Ob' at the beginning b = '0'* (nb - len(b)) + b # length alignment labels += [b]

plt.bar(labels, self.results) plt.show()

Now let us create functions which apply the most common operators. This is quite simple for operators acting on a single qubit.

def h(self, qbit): # the Hadamard operator H = np.array([[1, 1], [1, -1]]) / np.sqrt(2) self.apply1(H, qbit)

def x(self, qbit): # the X operator X= np.array([[0, 1], [1, 0]]) self.apply1(X, qbit)

The case with the operator CX is more interesting. Let the number of the controlling qubit q1 be less than the number q2 of the qubit we want to transform. Then

^ = !Чг ® (J 0) ® ‘nq-qi+q2-1 ® î ® înq-q2-1 +

+ lh ® (0 0) ® >nq-qi+q2-1 ®* ® ‘η,-,2-1 = ΐη®(1 °0)®!nq-qi-1 +

+ rqi ® (0 0) ® Їпч-й1 + й2-1 ® X® Їпч-й2-1-

In the case of q2 < q1, the calculations aresimilar

def cx(self, q1, q2):

X = np.array([[0,1], [1, 0]]) outer00 = np.diag([1, 0]) outer11 = np.diag([0, 1])

B1 = np.kron(np.identity(2 ** q1), outer00)

B1 = np.kron(B1, np.identity(2 ** (self.nq - q1 -1))) if q1 < q2:

B2 = np.kron(np.identity(2**q1), outer11)

B2 = np.kron(B2, np.identity(2**(self.nq-q1+q2-1)))

B2 = np.kron(B2, X)

B2 = np.kron(B2, np.identity(2**(self.nq-q2-1))) else:

B2 = np.kron(np.identity(2 ** q2), X)

B2 = np.kron(B2, np.identity(2 ** (self.nq - q2 + q1 -1)))

B2 = np.kron(B2, outer11)

B2 = np.kron(B2, np.identity(2 ** (self.nq - q1 - 1)))

B=B1+B2 self.apply_operator(B)

Now our compiler has all the basic features of a quantum computer. If needed, more operators can be added later.

Implementation of the Deutsch-Jozsa algorithm

Let us begin implementing the Deutsch-Jozsa algorithm. First, for each function /: {0; 1} ^ {0; 1} we need to define operators F, transforming |x)|y) into \x)\y@f(x)) x, у Є {0; 1}.

Using create_operator(f) we can create the desired operator from the vector f that corresponds to function f (f[x] = /(%)).

def create_op erato r(f):

Uf = np.zeros((4, 4))

for i, j in it.product(range(2), repeat=2):

Uf[i*2 + (j + f[i]) % 2, i*2+j] = 1 return Uf

Now let us create a function that implements the Deutsch-Jozsa algorithm.

def deutsch_algorithm(f): nq = 2 nb = 1

qc = QuantumCircuit(nq, nb)

Uf = create_operator(f)

qc.set_initial_state(0, np.array([1, 0]))

qc.set_initial_state(1, np.array([0, 1]))

qc.reset_state()

qc.h(0)

qc.h(1)

qc.apply_operator(Uf)

qc.h(0)

qc.measure(0, 0) qc.simulate(100) qc.barplot()

First, an object of the QuantumCircuit class is created, in which our algorithm will be stored. We only need two qubits and one bit for that. Then the system is initialized in the state |0)|1) and the operators are applied, after which one hundred iterations (theoretically, one is enough, but it’s better to be sure) are performed and the results are displayed.

Let us run the program:

f = [0, 1]

deutsch_algorithm(f)

F i g. 2. Result of the Deutsch-Jozsa algorithm for a non-constant function

Modern Information Technologies and IT-Education

In 100% of cases, the first qubit is in the state, which is expected for a non-constant function. If instead of the operator we use the operator , we will see the opposite result.

g = [0, 0]

deutsch_algorithm(g)

1.0 0.8 0.6 0. R 0.2 OLD

F i g. 3. Result of the Deutsch-Jozsa algorithm for a constant function

2πι

where ωη = e~. It is more convenient to represent this operator as a sum of outer products of the form \j){k\, which are linear operators. The action of such a linear operator on the vector \ψ) is quite intuitive: the vector \j) is multiplied by the inner product {k\ip).

\j){k\ \ψ) = \І){к\гр) = {k\^j) · \j)

Then

d-1 d-1

Let us apply Hd to the state \0) and to the state \ 1)

^ΣΣω^\0) = 7Й^'){0\0) = ТиЪ»

Vd

Vd*

ν^ΣΣω^lj){kli) ν^Σω^ \,"){1\1) ■

j=0 k 0

Що

1=0

As in the original algorithm, we need two qudits in the state \ψ0) = \0)\1). Applying the operator Hd to each of them, we get

Generalization of the Deutsch-Jozsa algorithm to qudits

\Ψι) = Hd I

a- 1 a-1

πα\ψο)=ν=Σ^Λ®

ми .=0 v“k = 0

The Deutsch-Jozsa algorithm can be rathersimply generalized to quantum computers using qudits. Qudits are d-dimensional analogues of qubits, instead of two states |0) and 11) they have d different states |0), |1), |2), ..., |d — 1).The state of onequdit is described by a d-dimensional normalized complex vector.

The problem for the generalized algorithm is formulated as follows: a function /: {0,1,d — 1} ^ {0,1,..., d — 1}, can be either constant or balanced, that is, each of the d values of the function appears thesame number of times, and weare required to determine what type f belongs to [05]. We consider the simplest case with a function of one variable, so the condition of it being balanced is equivalent to being bijection, but this algorithm can also be generalized to the case of functions of multiple variables.

This generalization has practically no differences from the original Deutsch-Jozsa algorithm in its structure. More complex operations for qudits, which are analogous to operations for qubits, are the only difference. We also need the operator Uf, corresponding to the function f and taking thesystem from the purestate |x)|y) to the state © /(x)), where © now stands

for addition modulo d.

First, let us consider a generalization of the Hadamard operator. It has the following form for a d-dimensional qudit:

Now we apply the operator Uf

Addition of f(J) in \k ©/(/)) is equivalent to a shift of coordinates by aconstant (for agiven j) number. Since Md+d = ω%, we can rewrite \ψ2) as

d-1 d-1

Now, if f(J) = f = const, we can take the factor ш- out of the summation sign

d-1 d-1

/ 1 1 1 1 · 1 \

/ ..d-1

1 ωά ω2ά ωά · ωά

n 2 2(d-1)

1 1 ωά ωά ω2Λ "· ωά

1 . ,3 ,.6 , .2 ,.3(d-i)

ωά ωά ωά ·" ωά

. »d-1 2(d-1) 3(d-1) ,Μ-Ι)2)

V1 ωά ωά ωά ■■■ ωά /

Applying the operator Hd to the first qudit once again, we obtain

Современные информационные технологии и ИТ-образование

Том 18, № 2. 2022

ISSN 2411-1473 sitito.cs.msu.ru

ωψη№){η\ωατ -= ^\j) =

v"m=0n=0 ^ 7=0

d-1 d-1

=ω-/ΐ1Σ Σ =

m=0 7=0

=·*'!

m=0 (7=0 /

For m = 0, we have

d-1

Σ ω°°}=d·

j = 0

For m ψ 0, we have

Thus, for a constant function f, wehave

d-1

Thefactor ω~- is called the global phase, its presence does not changethe properties of the state in any way. When measuring the first qudit, we will get \0) with one hundred percent probability.

If f is balanced, then after applying Hd to the first qudit, we will get

d-1 d-1 d-1

For m = 0, we have

d-1 d-1 d-1

ΣωΓ-/ϋ)=Σ ω-/ϋ) = Σω*=0

j = 0 j = 0 ! = 0

since f(j) runs through all values in {0,1,, d — 1}. Therefore, when measuring the first qudit, the probability of getting the state \0) is zero. We have proved that the output values of the algorithm on constant and balanced functions do not intersect, and therefore we can always determine the type of the function with one computation of it.

The result of the algorithm for a balanced function is generally not defined, sincethe coefficients for different\m) (m ψ 0) arenot necessarily equal to zero, but this does not affect the work of the algorithm.

Emulationof qudits

Now it’s easy to generalize the emulator for qudits.

class QuantumCircuit: def_init_(self, d, nq, nd): self.dimension = d self.nq = nq self.nd = nd

zero = np.array([1] + (d-1) * [0]) self.initial_state = np.tile(zero, (nq, 1)) self.qudits = np.array([]) self.final_state = np.array([]) self.digits = 0 self.measurements = [] self.results = np.zeros(d ** nd)

For themost part, the changes arerather cosmetic: renaming qubits to qudits, bits to digits, and so on. An important change is the additional self.dimension parameter, which defines the dimension of our qudits. So, wherever the number 2 was used as the dimension of qubits, it must be replaced by self.dimension. For this reason, the definition of the vector zero has also changed.

Functions such as set_initial_state, reset_state, apply_operator, measure, run remain completely unchanged (except for renaming). In the following two functions only the dimensionality of thequdits has been corrected:

def apply1(self, A, qudit):

11 = np.identity(self.dimension ** qudit)

12 = np.identity(self.dimension ** (self.nq - qudit - 1))

B = np.kron(I1, A)

B = np.kron(B, I2) self.apply_operator(B)

def simulate(self, num_of_iterations): self.results = np.zeros(self.dimension ** self.nd) for _ in range(num_of_iterations): self.results[self.run()] += 1 self.results /= num_of_iterations return self.results

The measurement function requires the biggest changes:

def measurement(self, qudit, bit): indices0 = np.array([], dtype=int)

bunch = np.arange(self.dimension ** (self.nq - qudit - 1)) shift = self.dimension ** (self.nq - qudit) for i in range(self.dimension ** qudit): indices0 = np.concatenate((indices0, bunch)) bunch = bunch + shift

indices = [indices0 + k * self.dimension ** (self.nq - qudit -1) for k in range(self.dimension)]

probabilities = [(abs(self.qudits[i]) ** 2).sum() for i in indices]

rand_value = np.random.rand() for i, p in enumerate(probabilities): if rand_value < p:

self.qudits[indices[i]] /= np.sqrt(probabilities[i])

Modern Information Technologies and IT-Education

for k in range(self.dimension): if k != i:

self.qudits[indices[k]] = np.zeros(self.dimension ** (self.nq - 1))

self.digits += i * self.dimension ** bit break else:

rand_value -= p

To begin with, the indices of the components corresponding to the states in which the measured qudit is equal to zero are selected into the indices0 vector. Such indices are arranged in evenly distributed bunches, the size of which depends on the qudit number. These bunches are appended to the vector indices0 with a shift by a constant number shift.

Then a list of all vectors with indices corresponding to the state number is created, and for all states the probability of its measurement is calculated (probabilities vector). After that, we create a random value rand_value and determine which interval it fell into in a loop. Further operations are similar to the case with qubits.

Changes in the barplot function are related to the labels and the increased number of states that need to be displayed. To create captions, it is convenient to write an additional function convert_base, which converts a number from the decimal number system to a representation with a dimension equal to the dimension of the qudit.

def convert_base(self, number): base = self.dimension string = ''

for i in range(self.nd): string += str(number % base) + ' ' number = number / / base return string

def barplot(self):

labels = [self.convert_base(n) for n in range(self.dimension ** self.nd)]

plt.bar(labels, self.results) plt.show()

Creation of functions which apply operators to qudits is somewhat more complicated than for qubits, since the form of an operator depends on the dimension of the qudit, and working with qudits in general is not so common. We restrict ourselves to the Hadamard operator, which is sufficient for our purposes.

The operator is created by the function create_h, and then applied "manually" using the function apply1.

def create_h(self): d = self.dimension w = np.exp(2j * np.pi / d)

H = np.zeros((d, d), dtype=np.csingle) for i, j in it.product(range(d), repeat=2):

H[i, j] = w ** (i*j) / np.sqrt(d) return H

Современные информационные технологии и ИТ-образование

Thus, the creation of the general framework for the emulator is completed. Let us start implementing the generalized Deutsch-Jozsa algorithm.

The changes are not very significant again, we just need to replace the number 2 with the dimension of the qudit in certain places:

def create_operator(f): d = len(f)

Uf = np.zeros((d**2, d**2))

for i, j in it.product(range(d), repeat=2):

Uf[i*d + (j + f[i]) % d, i*d+j] = 1 return Uf

def deutsch_algorithm(f): d = len(f) nq = 2 nd = 1

qc = QuantumCircuit(d, nq, nd)

Uf = create_operator(f)

H = qc.create_h()

qc.set_initial_state(0, np.array([1] + (d-1)*[0]))

qc.set_initial_state(1, np.array((d-1)*[0] + [1]))

qc.reset_state()

qc.apply1(H, 0)

qc.apply1(H, 1)

qc.apply_operator(Uf)

qc.apply1(H, 0)

qc.measure(0, 0)

qc.simulate(100)

qc.barplot()

Let us test the algorithm on three functions:

1. Constant

f = [0, 0, 0, 0, 0] deutsch_algorithm(f)

F i g. 4. Result of the Deutsch-Jozsa algorithm for a constant function

Том 18, № 2. 2022 ISSN 2411-1473 sitito.cs.msu.ru

2. Balanced (determined measurement result)

f = [0, 1, 2, 3, 4] deutsch_algorithm(f)

F i g. 5. Result of the Deutsch-Jozsa algorithm for a balanced function

As you can see, the algorithm returns zero when the function is constant, and not zero when the function is balanced.

Conclusion

The authors tried to present the basics of quantum computing and their emulation using classical computers in an accessible form, as well as highlight current developments in the field such as the use of qudits.

References

3. Balanced (undetermined measurement result)

f = [0, 2, 1, 3, 4] deutsch_algorithm(f)

F i g. 6. Result of the Deutsch-Jozsa algorithm for a balanced function with undetermined measurement result

A basic quantum computer emulator was developed and tested in the Python programming language. Thus, the authors showed the availability of quantum computing for any person with no access to a quantum computer

The Deutsch-Jozsa algorithm and its generalization to qudits are analyzed in detail, and then implemented using the emulator to give a clear demonstration of the capabilities of quantum algorithms.

[1] Tretiak M.A., Shchekaturin A.E., Pilipenko I.A., Kravchenko V.O., Cherkesova L.V. Analysis of the advantages and disadvantages of quantum emulators on the example of interaction with the user. Scientific Review. Technical science. 2020; (5):27-37. Available at: https://www.elibrary.ru/item.asp?id=44149778 (accessed 16.03.2022). (In Russ., abstract in Eng.)

[2] Baskakov P.E., Khabovets Y.Yu., Pilipenko I.A., Kravchenko V.O., Cherkesova L.V. Tools for Performing and Emulating Quantum Computing. Vestnik Novosibirskogo gosudarstvennogo universiteta. Seriâ: informacionnye tehnologii v obrazovanii = Vestnik NSU. Series: Information Technologies. 2020; 18(2):43-53. (In Russ., abstract in Eng.) https://doi.org/10.25205/1818-7900-2020-18-2-43-53

[3] Kiktenko E.O., Nikolaeva A.S., Fedorov A.K. Quantum computing using multilevel quantum systems. Nanoindustry. 2020; 13(S4):649-651. (In Russ., abstract in Eng.) doi: https://doi.org/10.22184/1993-8578.2020.13.4s.649.651

[4] Smirnova T.S., Shvetskiy M.V. A visual emulator of the Bloch vector and sphere as a means of teaching quantum computing. The Scientific Opinion. 2021; (9):76-82. (In Russ., abstract in Eng.) doi: https://doi.org/10.25807/22224378_2021_9_76

[5] Grigoryeva G.M., Khodchenkov V.Yu. On the possibility of building a quantum computer emulator using XMM registers. Sistemy komp'yuternoj matematiki i ih prilozheniya = Computer Mathematics Systems and Their Applications. 2021; (22):113-116. Available at: https://www.elibrary.ru/item.asp?id=46649884 (accessed 16.03.2022). (In Russ., abstract in Eng.)

[6] Arute F., Arya K., Babbush R., et al. Quantum supremacy using a programmable superconducting processor. Nature. 2019; 574:505510. (In Eng.) doi: https://doi.org/10.1038/s41586-019-1666-5

[7] Guzik V.P., Gushanskiy S.M. Development of emulator for quantum computers. Izvestiya SFedU. Engineering Sciences. 2010; (2):73-79. Available at: https://www.elibrary.ru/item.asp?id=13617268 (accessed 16.03.2022). (In Russ., abstract in Eng.)

[8] Solovyev V.M. Quantum Computers and Quantum Algorithms. Part 1. Quantum Computers. Izvestiya of Saratov University. New Series. Series: Mathematics. Mechanics. Informatics. 2015; 15(4):462-477. (In Russ., abstract in Eng.) doi: https://doi.org/10.18500/1816-9791-2015-15-4-462-477

[9] Solovyev V.M. Quantum Computers and Quantum Algorithms. Part 2. Quantum Algorithms. Izvestiya of Saratov University. New Series. Series: Mathematics. Mechanics. Informatics. 2016; 16(1):104-112. (In Russ., abstract in Eng.) doi: https://doi.org/10.18500/1816-9791-2016-16-1-104-112

Modern Information Technologies and IT-Education

[10] Ladd T, Jelezko F., Laflamme R., et al. Quantum computers. Nature. 2010; 464:45-53. (In Eng.) doi: https://doi.org/10.1038/na-ture08812

[11] Kiktenko E.O., Fedorov A.K., Man'ko O.V., Man'ko V.I. Multilevel superconducting circuits as two-qubit systems: Operations, state preparation, and entropic inequalities. Physical Review A. 2015; 91(4):042312. (In Eng.) doi: https://doi.org/10.1103/PhysRe-vA.91.042312

[12] Imany P., Jaramillo-Villegas J.A., Alshaykh M.S., et al. High-dimensional optical quantum logic in large operational spaces. npj Quantum Information. 2019; 5:59. (In Eng.) doi: https://doi.org/10.1038/s41534-019-0173-8

[13] Wang Y., Hu Z., Sanders B.C., Kais S. Qudits and High-Dimensional Quantum Computing. Frontiers in Physics. 2020; 8:589504. (In Eng.) doi: https://doi.org/10.3389/fphy.2020.589504

[14] Kiktenko E.O., Nikolaeva A.S., Xu P., Shlyapnikov G.V., Fedorov A.K. Scalable quantum computing with qudits on a graph. Physical Review A. 2020; 101(2):022304. (In Eng.) doi: https://doi.org/10.1103/PhysRevA.101.022304

[15] Moreno-Pineda E., Godfrin C., Balestro F., Wernsdorfer W., Ruben M. Molecular spin qudits for quantum algorithms. Chemical Society Reviews. 2018; 47(2), 501-513. (In Eng.) doi: https://doi.org/10.1039/C5CS00933B

[16] Ringbauer M., Meth M., Postler L., Stricker R., Blatt R., Schindler P., Monz T. A universal qudit quantum processor with trapped ions. Nature Physics. 2022; 18:1053-1057. (In Eng.) doi: https://doi.org/10.1038/s41567-022-01658-0

[17] Tacchino F., Chiesa A., Sessoli R., Tavernelli I., Carretta S. A proposal for using molecular spin qudits as quantum simulators of light-matter interactions. Journal of Materials Chemistry C. 2021; 9(32):10266-10275. (In Eng.) doi: https://doi.org/10.1039/D1TC00851J

[18] Lu H.H., Hu Z., Alshaykh M.S., Moore A.J., Wang Y., Imany P., Weiner A.M., Kais S. Quantum Phase Estimation with Time-Frequency Qudits in a Single Photon. Advanced Quantum Technologies. 2020; 3(2):1900074. (In Eng.) doi: https://doi.org/10.1002/ qute.201900074

[19] Fischer L.E., Chiesa A., Tacchino F., Egger D.J., Carretta S., Tavernelli I. Towards universal gate synthesis and error correction in transmon qudits. arXiv:2212.04496. 2022. (In Eng.) doi: https://doi.org/10.48550/arXiv.2212.04496

[20] Chi Y., Huang J., Zhang Z., et al. A programmable qudit-based quantum processor. Nature Communications. 2022; 13:1166. (In Eng.) doi: https://doi.org/10.1038/s41467-022-28767-x

[21] Brennen G.K., O'Leary D.P., Bullock S.S. Criteria for exact qudit universality. Physical Review A. 2005; 71(5):052318. (In Eng.) doi: https://doi.org/10.1103/PhysRevA.71.052318

[22] Biamonte J., Wittek P., Pancotti N., et al. Quantum machine learning. Nature. 2017; 549:195-202. (In Eng.) doi: https://doi. org/10.1038/nature23474

[23] Aryte F., Arya K., Babbush R., et al. Quantum supremacy using a programmable supercon-ducting processor. Nature. 2019; 574:505510. (In Eng.) doi: https://doi.org/10.1038/s41586-019-1666-5

[24] Deutsch D., Jozsa R. Rapid Solution of Problems by Quantum Computation. Proceedings of the Royal Society A: Mathematical, Physical and Engineering Sciences. 1992; 439(1907):553-558. (In Eng.) doi: https://doi.org/10.1098/rspa.1992.0167

[25] Fan Y. A Generalization of the Deutsch-Jozsa Algorithm to Multi-Valued Quantum Logic. 37th International Symposium on Multiple-Valued Logic (ISMVLO7). IEEE Computer Society, Oslo, Norway; 2007. p. 1-5. (In Eng.) doi: https://doi.org/10.1109/ISMVL.2007.3

Submitted 28.05.2022; approved after reviewing 30.06.2022; accepted for publication 09.07.2022.

About the authors:

Andrey S. Andreev, Student of the Department of Higher Mathematics, Faculty of Fundamental Sciences, Bauman Moscow State Technical University (5, 2-nd Baumanskaya St., building 2, Moscow 105005, Russian Federation), ORCID: https://orcid.org/0000-0002-4124-4146, [email protected]

Pavel V. Khrapov, Associate Professor of the Department of Higher Mathematics, Faculty of Fundamental Sciences, (5, 2-nd Baumanskaya St., building 2, Moscow 105005, Russian Federation), Cand.Sci. (Phys.-Math.), ORCID: https://orcid.org/0000-0002-6269-0727, [email protected]

All authors have read and approved the final manuscript.

Список использованных источников

[1] Анализ достоинств и недостатков квантовых эмуляторов на примере взаимодействия с пользователем / М. А. Третьяк, А. Е. Щекатурин, И. А. Пилипенко [и др.] // Научное обозрение. Технические науки. 2020. № 5. С. 27-37. URL: https://www. elibrary.ru/item.asp?id=44149778 (дата обращения: 16.03.2022).

[2] Инструменты для выполнения и эмуляции квантовых вычислений / П. Е. Баскаков, Ю. Ю. Хабовец, И. А. Пилипенко [и др.] // Вестник НГУ Серия: Информационные технологии. 2020. Т. 18, № 2. С. 43-53. doi: https://doi.org/10.25205/1818-7900-2020-18-2-43-53

[3] Киктенко Е. О., Николаева А. С., Федоров А. К. Квантовые вычисления с использованием многоуровневых квантовых систем // Наноиндустрия. 2020. Т. 13, № S4(99). С. 649-651. doi: https://doi.org/10.22184/1993-8578.2020.13.4s.649.651

[4] Смирнова Т. С., Швецкий М. В. Визуальный эмулятор вектора и сферы Блоха как средство обучения квантовым вычислениям // Научное мнение. 2021. № 9. С. 76-82. doi: https://doi.org/10.25807/22224378_2021_9_76

Современные информационные технологии и ИТ-образование

Том 18, № 2. 2022 ISSN 2411-1473 sitito.cs.msu.ru

[5] Григорьева Г. М., Ходченков В. Ю. О возможности построения эмулятора квантового компьютера с использованием XMM регистров // Системы компьютерной математики и их приложения. 2021. № 22. С. 113-116. URL: https://www.elibrary.ru/ item.asp?id=46649884 (дата обращения: 16.03.2022).

[6] Quantum supremacy using a programmable superconducting processor / F. Arute, K. Arya, R. Babbush [и др.] // Nature. 2019. Vol. 574. P. 505-510. doi: https://doi.org/10.1038/s41586-019-1666-5

[7] Гузик В. Ф., Гушанский С. М. Разработка эмуляторов для квантовых вычислителей // Известия ЮФУ Технические науки. 2010. № 2(103). С. 73-79. URL: https://www.elibrary.ru/item.asp?id=13617268 (дата обращения: 16.03.2022).

[8] Соловьев В. М. Квантовые компьютеры и квантовые алгоритмы. Часть 1. квантовые компьютеры // Известия Саратовского университета. Новая серия. Серия: Математика. Механика. Информатика. 2015. Т. 15, № 4. С. 462-477. doi: https://doi.org/10.18500/1816-9791-2015-15-4-462-477

[9] Соловьев В. М. Квантовые компьютеры и квантовые алгоритмы часть 2. Квантовые алгоритмы // Известия Саратовского университета. Новая серия. Серия: Математика. Механика. Информатика. 2016. Т. 16, № 1. С. 104-112. doi: https://doi. org/10.18500/1816-9791-2016-16-1-104-112

[10] Quantum computers / T. Ladd, F. Jelezko, R. Laflamme [и др.] // Nature. 2010. Vol. 464. P. 45-53. doi: https://doi.org/10.1038/ nature08812

[11] Multilevel superconducting circuits as two-qubit systems: Operations, state preparation, and entropic inequalities / E. O. Kiktenko [и др.] // Physical Review A. 2015. Vol. 91, issue 4. Article number: 042312. doi: https://doi.org/10.1103/PhysRevA.91.042312

[12] High-dimensional optical quantum logic in large operational spaces / P. Imany, J. A. Jaramillo-Villegas, M. S. Alshaykh [и др.] // npj Quantum Information. 2019. Vol. 5. Article number: 59. doi: https://doi.org/10.1038/s41534-019-0173-8

[13] Qudits and High-Dimensional Quantum Computing / Y. Wang [и др.] // Frontiers in Physics. 2020. Vol. 8. Article number: 589504. doi: https://doi.org/10.3389/fphy.2020.589504

[14] Scalable quantum computing with qudits on a graph / E. O. Kiktenko [и др.] // Physical Review A. 2020. Vol. 101, issue 2. Article number: 022304. doi: https://doi.org/10.1103/PhysRevA.101.022304

[15] Molecular spin qudits for quantum algorithms / E. Moreno-Pineda [и др.] // Chemical Society Reviews. 2018. Vol. 47, issue 2. P. 501-513. doi: https://doi.org/10.1039/C5CS00933B

[16] A universal qudit quantum processor with trapped ions / M. Ringbauer [и др.] // Nature Physics. 2022. Vol. 18. P. 1053-1057. doi: https://doi.org/10.1038/s41567-022-01658-0

[17] A proposal for using molecular spin qudits as quantum simulators of light-matter interactions / F. Tacchino [и др.] // Journal of Materials Chemistry C. 2021. Vol. 9, issue 32. P. 10266-10275. doi: https://doi.org/10.1039/D1TC00851J

[18] Quantum Phase Estimation with Time-Frequency Qudits in a Single Photon / H. H. Lu [и др.] // Advanced Quantum Technologies. 2020. Vol. 3, issue 2. Article number: 1900074. doi: https://doi.org/10.1002/qute.201900074

[19] Towards universal gate synthesis and error correction in transmon qudits // L. E. Fischer [и др.] // arXiv:2212.04496. 2022. doi: https://doi.org/10.48550/arXiv.2212.04496

[20] A programmable qudit-based quantum processor / Y. Chi, J. Huang, Z. Zhang [и др.] // Nature Communications. 2022. Vol. 13. Article number: 1166. doi: https://doi.org/10.1038/s41467-022-28767-x

[21] Brennen G. K., O'Leary D. P., Bullock S. S. Criteria for exact qudit universality // Physical Review A. 2005. Vol. 71, issue 5. Article number: 052318. doi: https://doi.org/10.1103/PhysRevA.71.052318

[22] Quantum machine learning / J. Biamonte, P. Wittek, N. Pancotti [и др.] // Nature. 2017. Vol. 549. P. 195-202. doi: https://doi. org/10.1038/nature23474

[23] Quantum supremacy using a programmable supercon-ducting processor / F. Aryte, K. Arya, R. Babbush [и др.] // Nature. 2019. Vol. 574. P. 505-510. doi: https://doi.org/10.1038/s41586-019-1666-5

[24] Deutsch D., Jozsa R. Rapid Solution of Problems by Quantum Computation // Proceedings of the Royal Society A: Mathematical, Physical and Engineering Sciences. 1992. Vol. 439, issue 1907. P. 553-558. doi: https://doi.org/10.1098/rspa.1992.0167

[25] Fan Y. A Generalization of the Deutsch-Jozsa Algorithm to Multi-Valued Quantum Logic // 37th International Symposium on Multiple-Valued Logic (ISMVL'07). Oslo, Norway: IEEE Computer Society, 2007. P. 1-5. doi: https://doi.org/10.1109/ISMVL.2007.3

Поступила 28.05.2022; одобрена после рецензирования 30.06.2022; принята к публикации 09.07.2022.

|0б авторах:|

Андреев Андрей Сергеевич, студент кафедры высшей математики, факультет фундаментальных наук, ФГБОУ ВО «Московский государственный технический университет имени Н.Э. Баумана (национальный исследовательский университет)» (105005, Российская Федерация, г. Москва, ул. 2-я Бауманская, д. 5, к. 1), ORCID: https://orcid.org/0000-0002-4124-4146, [email protected] Храпов Павел Васильевич, доцент кафедры высшей математики, факультет фундаментальных наук, ФГБОУ ВО «Московский государственный технический университет имени Н.Э. Баумана (национальный исследовательский университет)» (105005, Российская Федерация, г. Москва, ул. 2-я Бауманская, д. 5, к. 1), кандидат физико-математических наук, ORCID: https://orcid. org/0000-0002-6269-0727, [email protected]

Все авторы прочитали и одобрили окончательный вариант рукописи.

Modern Information Technologies and IT-Education