Algorithmic trading is the process of using computers programmed to follow a defined set of instructions for placing a trade in order to generate profits at a speed and frequency that is impossible for a human trader. This style of trading makes markets more liquid, volatile, and makes trading more systematic by ruling out emotional human impacts on trading activities. Although there are many algorithmic models based on timing, price, quantity, and mathematical modes, there has not been one general solution that guarantees maximal profit. As a result, there is space in the algorithmic trading market for novel solutions.
The customer, Dr. Travis Humble, is interested in tackling the Markowitz problem, which entails assembling a portfolio of assets such that the expected return is maximized for a given level of risk. Dr. Humble believes this problem can be reduced to a quadratic unconstrained binary optimization problem, which is solvable by D-Wave quantum computers. The Markowitz problem is still intractable for classical computers today but by utilizing the unique capabilities of these quantum computers, we may be able to find a new and efficient way to approach the Markowitz problem. Our end-goal is to create an application that can translate the Markowitz model to run on D-Wave quantum computers in a way that is approachable for the non-expert user. The bulk of the project will be based around obtaining the stock market data and then processing it so it can then be put into a kernel that will run on a quantum computer. The application can be restricted to having just a command line interface but, time given, a simple graphical user interface could be made to allow more people to use the application.
We believe that we are the right team to handle this project since Dr. Humble is looking for software engineers to build applications on top of his classical-to-quantum interface. The interface uses C++ and Python, which all team members are familiar with, meaning less time will be spent learning syntax so we can start building the application right away.
The customer, Dr. Travis Humble, leads the Quantum Computing Institute (QCI). The QCI is a collaboration fostered by Oak Ridge National Laboratory’s (ORNL) which investigates all aspects of quantum computing, from hardware design and fabrication to use cases and applications. QCI aims to use ORNL’s and their partners’ available resources to improve general understanding of quantum computing, prepare a workforce capable of leveraging quantum technology, and develop quantum infrastructure.
Through QCI research, Dr. Humble and his associates at ORNL have access to a quantum computing system. This system, made available via subscription with the quantum computing company D-Wave, is capable of generating solutions for a certain class of optimization problem. Problems must be specified to the quantum processing unit (QPU) in a particular data structure, and the quantum system’s output will be formatted in a pre-defined, uninterpreted state. So that their researchers may more easily work with D-Wave’s quantum technology, Dr. Humble and his associates are developing the necessary translational layers which will allow data to be specified in traditional programming languages, given to the QPU in the proper format, and have the quantum output returned.
Dr. Humble and QCI thus need an application which will utilize both their framework for communicating with the quantum system, and the quantum system itself. The application needs to be in a domain with available data for testing, be appropriate for the quantum computer’s computational model, and be no more complex than necessary. Ideally, the application should express a real-world problem, exemplifying a potential strength of quantum computing. Such an application will allow the customer to test and analyze their methods of translating data for the the quantum system. Further, the QCI is interested in the quantum results as well. The application will be a useful tool for testing and reaching conclusions about D-Wave’s quantum system.
The stock optimization application proposed by this team will meet these needs well. The application will take a real problem with huge amounts of commercial interest and use QCI’s and D-Wave’s technology to solve the problem in a unique manner. Moreover, the nature of this problem is well-suited for the capabilities of the quantum system.
Quantum computing is a frontier of new computing approaches based on unintuitive and complex physics interactions. While the physics is well-established and many papers on the theory of quantum computation have been published, the field is lacking applications and actual results. While there is not extensive catalogue of applications which leverage quantum computation, many researchers are actively experimenting in this area.
Starting this project, Dr. Travis Humble had provided us with a basic baseline architecture for us to utilize: algorithms to be implemented on the D-Wave quantum computer. The algorithms are from a branch of mathematics developed for portfolio optimization that utilizes mathematical expressions to balance risk and reward in order to choose the efficient set. That is the Markowitz model. This efficient set was developed to maximize the reward for any given risk. When utilizing this method, it ensures that you are never needlessly taking unnecessary or unrewarded risk. Such methods may sound too good to be true, and if something that incredible existed, certainly it would be commonplace by now, but while these calculations can be considered trivial within their own right, the difficulty arises from the sheer amount of data that must be processed. Implementing these algorithms is the core goal of this project.
There are a multitude of milestones that must be reached in order to complete this project. The first milestone consists of obtaining access to the D-Wave quantum computer for all team members. For such a simple step, there are a few pitfalls that will make accessing it difficult for some due to the security protocols of Oak Ridge. However — permission will be secured through the Hydra lab computers, ensuring access at campus regardless of personal and residential circumstances.
When access is confirmed, the next step for the project is to gain familiarity and confidence with the usage of the D-Wave quantum computing system — namely the learning the methods of the XACC architecture. Achieving this will involve Implementing small chaff programs onto the system until we become familiar with the process. We will be starting with Python because it is simpler to implement. Though this may be no small task considering the groundbreaking nature of quantum computing, but the swath of resources and consultations available from Oak Ridge should ensure success.
Once competency has been achieved, the next step is to shift to implementing C++ programs onto the computer, then programming Dr. Travis Humble’s algorithms into the D-wave computer. The next task as soon as Dr. Travis’s algorithms are functional is to secure test data. Currently, we plan to use real time stock information available from the internet. For that, an additional program to scrape the internet and parse the information will need to me implemented.
Then, with the stock data and algorithms in hand, we will run the data through the Markowitz model and collect our own data on the success, speed, and accuracy of our programs, debugging where necessary. After this penultimate step, the project will essentially be complete. The final part is where we will attempt to build a front-end for aesthetics and ease of use as well as any additional functionality, such as specifying particular parts of the stock market to examine. When all these steps are achieved, we will have a functioning stock data scraper that will apply the Markowitz model in real time in order to optimize investments.
This project will make use of the technology provided to the team by ORNL. This includes access to the D-wave quantum computer as well as usage of their open-source framework to distribute jobs to quantum systems. Additionally, this project is centered around the Markowitz model for portfolio optimization. The goal will be to interface with these technologies so that the Markowitz model can be implemented to run on a quantum computer.
The D-wave quantum computer is a specialized computational system that uses a concept called quantum annealing to solve quadratic unconstrained binary optimization (QUBO) problems. D-wave computers are specialized in the fact that they do not provide access to any individual quantum bit, or qubit. Problems can be run on the machine by first initializing the state and hardware and then relying on the physical fact that all systems trend towards their lowest energy state; like how hot tea will eventually become room-temperature. QUBO problems are then solved by setting up the data in such a way that the lowest energy state of the quantum computer is the optimal solution to the problem.
The Markowitz model is a model that assists in efficient portfolio selection. This model first determines an efficient set using the given portfolio selection. A set is efficient if it maximizes the return for a given level of risk. The optimal set is then chosen according to the person’s desired level of risk. It turns out that this problem can be implemented as a QUBO problem. Optimizing this problem on extremely large sets of portfolios is extremely difficult for a traditional computer but could potentially be done quickly using a quantum annealing computer like the D-wave.
Interacting with the D-wave computer will be handled by the XACC framework provided by ORNL. XACC provides a layer of abstraction between traditional computing and quantum computing. XACC is designed to operate similarly to CUDA. The user creates a kernel that the user has indicated to be run on a quantum computer. XACC will then take that kernel and then compile it towards the target quantum computer. The data will then be run on the Quantum computer and returned to the user. This is done by filling out certain data structures with user data and then reading them back.
XACC uses C++ as it’s main language but also provides a Python API. This project will most likely be completed using C++, but prototypes may be implemented in Python. Once the main functionality is completed and time permits, we may use another language to wrap the code in an appealing front-end GUI or implement it as an Android application. Version control and team collaboration will be done using Github. This project will be made of a series of goals split up into an even workload to be distributed between the team. This is a very novel project so the current end-goal is to make it functional as a simple CLI program.