Project Proposal: Designing a Quantum Computer Programming Language

This project proposal outlines a framework for a quantum computer programming language, addressing the limitations of current languages and aiming for commercial viability. The proposal begins with an abstract discussing the exponential increase in computing power promised by quantum computers, and the need for a programming language that integrates with existing software. The introduction highlights the differences between quantum and classical computers, emphasizing the unique challenges in programming quantum systems due to concepts like superposition and entanglement. The research objectives include developing usability and functional properties for a quantum computing framework, designing an object-oriented framework, and proving its effectiveness through illustrations and implementation. The proposal reviews relevant background information in quantum mechanics, including qubits and the Bloch sphere, and explores quantum algorithms like Shor's and Grover's algorithms. The literature review covers key concepts like qubits, complex numbers, and Dirac notation. The methodology involves a semi-experimental confirmatory research design, simulating the proposed language using classical computers. The proposal emphasizes the need for a quantum programming language that is user-friendly, scalable, and integrates well with existing software, ultimately contributing to the development of practical quantum computing applications.

QUANTUM COMPUTING: A GENTLE INTRODUCTION 1
Project Proposal: Quantum Computer Programming
Name
Date

QUANTUM COMPUTING: A GENTLE INTRODUCTION 2
Abstract
Quantum computing is a promising field in the future in which computing power will be increased
exponentially. While these computers are still not around, according to Moore’s Law, they should be
expected around 2023 to 2025, give or take 3 years. One aspect of quantum computing of
immediate importance is how software to run on them will be programmed. This is because of the
unique nature of quantum computers as they differ significantly in operation from the classical
computers that are based n the Turing machines of the 1930s. Quantum computing uses a principle
in quantum mechanics in which something can be in two places at the same time, and it is
characterized by lack of determinism, contrary to the Newtonian concept of predictability. Quantum
properties use the destructive and constructive wave concepts for computing. Present languages are
object oriented or imperative; their use on quantum computing is not possible yet the programming
language for quantum computing must evolve from present languages like Python and JAVA to
enable feasible commercial application. Most languages developed such as QRAM, qGCL, and
QCL have challenges making them unsuitable for commercial programming for quantum
computing. Using a semi-experimental confirmatory research design, this paper proposes a quantum
programming language that will be simulated using classical computers and based on existing
languages, but lacking the pitfalls of present quantum languages

QUANTUM COMPUTING: A GENTLE INTRODUCTION 3
Table of Contents
Introduction.........................................................................................................................................3
Research Objectives............................................................................................................................4
Background and Related Work............................................................................................................4
Literature Review................................................................................................................................6
Quantum Algorithms...........................................................................................................................9
Quantum Computer Programming....................................................................................................10
Hypothesis.........................................................................................................................................11
Research Methodology......................................................................................................................11
References..........................................................................................................................................14

QUANTUM COMPUTING: A GENTLE INTRODUCTION 4
Introduction
Though still years away from becoming a commercially applicable reality, Quantum
Computing is an interesting area that offers much promise in undertaking computations that are not
at present feasible with the current generation of computers, the ‘classical computers’ (Rieffel &
Polak, 2014). Quantum computers work in a way that is totally and radically different from classical
computers because qubits (quantum bits) can exist in a state of both one and zero, simultaneously
such that a single qubit can store, and process N qubits of information. Based on the superposition
state of having both one and zero, the information stored in N qubits can be computed as N qubits
raised to the power on N classical bits (Meglicki, 2010). Quantum computing makes use of the
quantum phenomena of mechanics such as entanglement and superposition to undertake operations
on data and so this makes quantum computers markedly different from the classical computer that is
based on transistors (Raimond, Brune & Haroche, 2001).
Classical computers require data encoding in binary form where the possible states are either
zero or one, quantum computing allows for dual state. But just like the classical computer, quantum
computers will have little value without the right software to be run on them hence the need to
develop practical ways that these computers can be programmed as their arrival is eagerly awaited
(Schlosshauer, 2010). Despite the idea of Quantum computers as pioneered by Yuri Marin and Paul
Benioff in the early 1980s, not much consideration was placed on how to program these computers
until the 1990s (Sarma, 2015). There are several proposals that have been made on programming
quantum computers; however, many suffer from various flaws that render them impractical or
highly expensive for application in typical environment for developing commercial software
(McCaskey et al., 2017). The flaws with many proposals include;
Lack of scalability: Some proposals work well for small code ‘snippets’ but becomes
difficult to understand and manage them beyond this; examples include languages that require
formal proofs and visual languages for programming.
Foreign techniques: Techniques that are proposed for use are foreign to many commercial
software developers, examples are functional languages
Proprietary languages: There are many languages that can be used in quantum computing
to date (almost 8500) yet very few can be used commercially and this poses a challenge since the
majority of programming languages commercially used today have some unique features that
enable their use commercially

QUANTUM COMPUTING: A GENTLE INTRODUCTION 5
Languages that are a challenge to integrate with existing software: Any methods for
programming quantum computers must properly integrate with existing software
Unconventional design framework: Proposed libraries and languages have APIs that are
difficult to use and do not subscribe to established conventions; they are likely prone to incorrect
use
Can run on quantum computers only: The likely scenario is that quantum computers will
be used by classical computers, much like the cloud configuration where the quantum computers
are used as a computing power resource; as such techniques for programming must integrate and
work well with classical computers (McCaskey et al., 2017)
As such, these challenges and flaws in existing programming languages for quantum
computing are far from being a trivial undertaking as the working of quantum computers raises
interesting challenges in designing languages for creating software to run on them. In this paper, a
research is proposed on a quantum computing framework without the flaws discussed afore.
Research Objectives
The objectives of this research (also the expected deliverables) are the following;
 To develop a list of usability and functional properties that must be present in a framework
for quantum computing
 To put forth a design for a framework that is object oriented
 To prove, using illustrations, that the usability and functional properties for a quantum
computing framework are satisfied
 Propose a framework for its implementation, to prove the concept
The target audience for this proposal is commercial programmers
Background and Related Work
A framework for practical computer programming for quantum computing has several
foundations in physics and computer science. Quantum computing fulfills Moor’s law of
technology marching on (Al-Rabadi, 2012), with estimation around the year 2023, give or take 3
years, quantum computers will appear ('Quantum Computing Report', 2017). Quantum computers
are fundamentally different in their operation compared to the 1930s Turing machines that formed
the basis of all modern computers. It is therefore important to fully understand quantum
computation as a background to understanding the challenges of programming such computers
(Bonsor & Strickland, 2016). Understanding quantum computing requires an understanding of

QUANTUM COMPUTING: A GENTLE INTRODUCTION 6
quantum mechanics; at the quantum level, there is randomness in nature. If there is an arbitrary
state, it is not possible to determine with an appreciable degree of accuracy, how the state will
evolve in exact terms. This significantly departs from the Newtonian perspective that the forces
acting on a system will determine the evolution of that system. Quantum thinking lacks
deterministic properties such that the future position of something like the planets can be
determined using available formula and algorithms. A photon, for instance, based on the quantum
phenomenon, can be in two places at any one time. The only thing that is certain about the quantum
level is uncertainty, but they have been proven experimentally (Blumel, 2010). The qubit is well
represented by the Bloch sphere shown below;
Source: (Bonsor & Strickland, 2017)
The qubit is the basic unit that can be applied in quantum computing. The principle of
quantum mechanics that can be applied in computing is illustrated below with a quantum source
going through a plane having two slits with a photon detector at the other end as depicted below.
When observed on the photon detector, there will be 12 particles, even if only one particle is
emitted; further, the observed pattern if of smaller waves canceling (destructive interference) and
reinforcing (constructive interference) each other. What is observed are no longer waves, but only
where the photons hit. It is the destructive and constructive interference that enables computing
using the quantum principle. The photons are detected when passing through one slit or the other,
but not both. The photons are considered to have traveled two paths and when split (the photon
stream) they will behave like waves (Blumel, 2010), (Greenstein & Zajonc, 2006). The quantum
mechanics will be expressed using the Dirac notation in this proposal.

QUANTUM COMPUTING: A GENTLE INTRODUCTION 7
Source: (Author)
Source: (Author)
Literature Review
The smallest quantum information unit is the Qubit while in classical system, the smallest
unit of information is the bit. Qubits differ from bits since qubit expression is complex within the
matrix. Complex numbers take the form of a + bi where b and a are real numbers and I is an
imaginary part where i2 equals -1. Using the Argand plane, complex numbers can be drawn as well
with the imaginary part (bi) in the Y axis and (a), the real part in the X axis

QUANTUM COMPUTING: A GENTLE INTRODUCTION 8
Source: Author
The squares of the absolute complex number values for qubits must sum up to 1; a complex
number absolute value is defined by the relation for the complex number ; using the
Dirac notation, the qubit can be expressed with the complex numbers α1 and α1 are termed the
probability amplitudes as;
;
and
This state can also be expanded to n qubits in which a complex number precedes every
possibility is restricted to have all complex number absolute squared values adding up to 1. the
complex numbers, however, cannot be extracted as this will collapse to either of the two possible
values, with reference to the probabilities. Expressing qubits becomes complex when expressed in
matrices when there are multiple qubits because the number of entries will be n2 entries that must be
made in the matrix. Without all entries, the matrix is incomplete, so using the Dirac model in which
the zeros can be left out making a concise notation possible (Chester, 2012).

QUANTUM COMPUTING: A GENTLE INTRODUCTION 9
The figure below shows why the Dirac notation is simple and less cumbersome
Based on how nature at the quantum level behaves, the principle can be used for computing
because the qubit can have a value of 1, 0, or 0 and 1 combined. A qubit with a combination state of
either 1 or 0, it can have a 10% chance, when observed, of being in zero state meaning in 9 out of
10 times, it will be in the 1 state but be 0 in the next observation. As such, a quantum program can
generate different results in different executions (Chester, 2012). In quantum computing, there will
be multiple results generated although only a single one is selected and becomes the output, unlike
in a classical computer program as illustrated below;

QUANTUM COMPUTING: A GENTLE INTRODUCTION 10
Source: Author
The probabilities in quantum computer destructively and constructively interfere with each
other. A computing device should operate on the principles of quantum mechanics in order to
efficiently simulate a quantum system. This computer can be programmed efficiently only when
prepared in the physical state. If an attempt is made to simulate a quantum system on a classical
computer, the result would be an exponential system slow down (Chester, 2012).
Quantum Algorithms
Shor proposed an algorithm for quantum computing that enable factor and also make it
possible to solve discrete logarithmic problems a polynomial number of steps, basing on the size of
the input. Another algorithm is the Grover algorithm, introduced by Lov Grover for fast searches in
databases. These two algorithms are the most important and relevant algorithms for quantum
computing. Grover algorithm enables fast task execution; for example, to search through an
unordered objects lists requires O ( ) time, while in a classical computer the time required would
be O9n) time. The Deutsch’s algorithm allows the determination of F(0) xor f(1) with just a single
query to f(x) using the interference concept (Chen, Kauffman & Lomonaco, 2008).

QUANTUM COMPUTING: A GENTLE INTRODUCTION 11
Quantum Computer Programming
Most languages used for commercial use are written in object oriented and imperative
languages, such as C#, Java, Visual Basic, Python, and Cobol, among others (Hiscott, 2014). To
commercially use a programming language in quantum computing, it must be easy for users to learn
and use. This can be achieved through piggy backing on languages such as Python they are already
familiar with. The quantum programming languages structure is different from the existing
languages used in classical computers. Quantum languages generally include statements to initialize
the system’s quantum state, manipulate the system through unary operations, and then measurement
being the final task (Castor & Liu, 2016). Pseudo code conventions have been introduced by Knill
based on imperative programming techniques utilizing flow control statements and variables; the
method uses the QRAM (quantum random access machine) model. However, the use of pseudo
code has little relevance for practical writing of quantum applications (Wang, Knill, Glick & Défago,
2000). Another approach is the qGCL language developed by Zuliani and Sanders for correctness of
proof, program deviation, and teaching. In this language, computation is controlled by classical
computers making use of quantum sub systems with actions being initialization, evolution, and then
finalization. This language also provides implementation for many quantum algorithms, including
the Gover’s and Shor algorithms. However, qGCL is too dated and limited for present and future
use in quantum programming (Gay & Mackie, 2010).
A quantum programming language that is an extension of for the classical computing C++
language has been developed by Bettelli as a library with many classes. The classes enable the
library workings to be encapsulated and hiding them from users; the method allows for better
enforcing of rules while valid states will also be maintained using classes. The Bettelli
implementation generates quantum operations with byte codes that be piped into real quantum
subsystems or simulators. Bettelli’s method most important feature is that a language for quantum
programming should be an extension of the classical programming languages (Gay & Mackie,
2010). The QCL (Quantum Computer Language) developed by Omer is the most complete language
for quantum programming. Its structure is similar to C which many programmers can easily learn;
however, its limitation is an extension of the C language limitation which is used for low level
programming and not cutting edge software used in the commercial sector because it lacks modern
libraries and power.
It is also proprietary, meaning its adoption will be difficult and slow, as opposed to modern
programs that are open source (Gay & Mackie, 2010). A method that simulates quantum computing

QUANTUM COMPUTING: A GENTLE INTRODUCTION 12
through the use of Fortran has been proposed by Markus and shows how such libraries can work in
quantum computing through simulation; however, it’s not a framework or language in itself. Qubits
can be simulated using the Ruby programming language, as proposed by Carini; this is also not a
language by itself by has an implementation technique entailing qubits state simulation on separate
threads. This model has problems with scheduling but is a pointer to future quantum computing
languages that can take advantage of multiple processor cores. Most proposed languages have
limitations or would not be practical in quantum computing as programming languages. The main
challenge for developing a an effective quantum computer programming language revolves around
quantum computer programming, general quantum computing, and designing the framework (Gay
& Mackie, 2010).
Hypothesis
A practical quantum computing framework can be developed for existing present classical
object oriented languages that can be proven to fulfill a myriad of usability and functional
properties for quantum programming. The framework will be proven to be practical is it lacks flaws
including foreign techniques, lack of scalability, be a proprietary language, difficult to integrate
with software currently in use, has unconventional design and can only run on quantum computer.
Research Methodology
The overriding research approach for this proposed research is a semi-experimental design
in which an empirical approach is used where the treatment condition will be controlled by the
researcher without random assignment, using confirmatory research where the priori hypothesis will
be tested through a controlled experiment and the concept proved (Shadish, Cook & Campbell,
2011). This research proposes to use an iterative approach to undertaking research and will
commence with the gathering of examples, followed by developing usability and functional
properties, and interface design that satisfies the properties. The interfaces will then be implemented
to test and utilize the proposal using classical simulation; the testing will be done with cognizance
of time constraints. The research will then prove that the interfaces that have been proposed and
tested satisfy the properties for a practical quantum programming language, before the iteration is
analyzed.
The nature of the research is unique, hence justifying the use of the semi experimental
confirmatory design because quantum computers still do not actually exist. As such, this research
will continuously search for literature as the research proceeds to get alternate ideas and evaluate