# ProjectQ **Repository Path**: Nneil_admin/ProjectQ ## Basic Information - **Project Name**: ProjectQ - **Description**: No description available - **Primary Language**: Unknown - **License**: Apache-2.0 - **Default Branch**: develop - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 2 - **Created**: 2021-01-28 - **Last Updated**: 2021-01-28 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README ProjectQ - An open source software framework for quantum computing ================================================================== .. image:: https://travis-ci.org/ProjectQ-Framework/ProjectQ.svg?branch=master :target: https://travis-ci.org/ProjectQ-Framework/ProjectQ .. image:: https://coveralls.io/repos/github/ProjectQ-Framework/ProjectQ/badge.svg :target: https://coveralls.io/github/ProjectQ-Framework/ProjectQ .. image:: https://readthedocs.org/projects/projectq/badge/?version=latest :target: http://projectq.readthedocs.io/en/latest/?badge=latest :alt: Documentation Status .. image:: https://badge.fury.io/py/projectq.svg :target: https://badge.fury.io/py/projectq .. image:: https://img.shields.io/badge/python-2.7%2C%203.4%2C%203.5%2C%203.6-brightgreen.svg ProjectQ is an open source effort for quantum computing. It features a compilation framework capable of targeting various types of hardware, a high-performance quantum computer simulator with emulation capabilities, and various compiler plug-ins. This allows users to - run quantum programs on the IBM Quantum Experience chip - simulate quantum programs on classical computers - emulate quantum programs at a higher level of abstraction (e.g., mimicking the action of large oracles instead of compiling them to low-level gates) - export quantum programs as circuits (using TikZ) - get resource estimates Examples -------- **First quantum program** .. code-block:: python from projectq import MainEngine # import the main compiler engine from projectq.ops import H, Measure # import the operations we want to perform (Hadamard and measurement) eng = MainEngine() # create a default compiler (the back-end is a simulator) qubit = eng.allocate_qubit() # allocate a quantum register with 1 qubit H | qubit # apply a Hadamard gate Measure | qubit # measure the qubit eng.flush() # flush all gates (and execute measurements) print("Measured {}".format(int(qubit))) # converting a qubit to int or bool gives access to the measurement result ProjectQ features a lean syntax which is close to the mathematical notation used in quantum physics. For example, a rotation of a qubit around the x-axis is usually specified as: .. image:: docs/images/braket_notation.svg :alt: Rx(theta)|qubit> :width: 100px The same statement in ProjectQ's syntax is: .. code-block:: python Rx(theta) | qubit The **|**-operator separates the specification of the gate operation (left-hand side) from the quantum bits to which the operation is applied (right-hand side). **Changing the compiler and using a resource counter as a back-end** Instead of simulating a quantum program, one can use our resource counter (as a back-end) to determine how many operations it would take on a future quantum computer with a given architecture. Suppose the qubits are arranged on a linear chain and the architecture supports any single-qubit gate as well as the two-qubit CNOT and Swap operations: .. code-block:: python from projectq import MainEngine from projectq.backends import ResourceCounter from projectq.ops import QFT from projectq.setups import linear compiler_engines = linear.get_engine_list(num_qubits=16, one_qubit_gates='any', two_qubit_gates=(CNOT, Swap)) resource_counter = ResourceCounter() eng = MainEngine(backend=resource_counter, engine_list=compiler_engines) qureg = eng.allocate_qureg(16) QFT | qureg eng.flush() print(resource_counter) # This will output, among other information, # how many operations are needed to perform # this quantum fourier transform (QFT), i.e., # Gate class counts: # AllocateQubitGate : 16 # CXGate : 240 # HGate : 16 # R : 120 # Rz : 240 # SwapGate : 262 **Running a quantum program on IBM's QE chips** To run a program on the IBM Quantum Experience chips, all one has to do is choose the `IBMBackend` and the corresponding setup: .. code-block:: python import projectq.setups.ibm from projectq.backends import IBMBackend token='MY_TOKEN' device='ibmq_16_melbourne' compiler_engines = projectq.setups.ibm.get_engine_list(token=token,device=device) eng = MainEngine(IBMBackend(token=token, use_hardware=True, num_runs=1024, verbose=False, device=device), engine_list=compiler_engines) **Running a quantum program on AQT devices** To run a program on the AQT trapped ion quantum computer, choose the `AQTBackend` and the corresponding setup: .. code-block:: python import projectq.setups.aqt from projectq.backends import AQTBackend token='MY_TOKEN' device='aqt_device' compiler_engines = projectq.setups.aqt.get_engine_list(token=token,device=device) eng = MainEngine(AQTBackend(token=token,use_hardware=True, num_runs=1024, verbose=False, device=device), engine_list=compiler_engines) **Classically simulate a quantum program** ProjectQ has a high-performance simulator which allows simulating up to about 30 qubits on a regular laptop. See the `simulator tutorial `__ for more information. Using the emulation features of our simulator (fast classical shortcuts), one can easily emulate Shor's algorithm for problem sizes for which a quantum computer would require above 50 qubits, see our `example codes `__. The advanced features of the simulator are also particularly useful to investigate algorithms for the simulation of quantum systems. For example, the simulator can evolve a quantum system in time (without Trotter errors) and it gives direct access to expectation values of Hamiltonians leading to extremely fast simulations of VQE type algorithms: .. code-block:: python from projectq import MainEngine from projectq.ops import All, Measure, QubitOperator, TimeEvolution eng = MainEngine() wavefunction = eng.allocate_qureg(2) # Specify a Hamiltonian in terms of Pauli operators: hamiltonian = QubitOperator("X0 X1") + 0.5 * QubitOperator("Y0 Y1") # Apply exp(-i * Hamiltonian * time) (without Trotter error) TimeEvolution(time=1, hamiltonian=hamiltonian) | wavefunction # Measure the expection value using the simulator shortcut: eng.flush() value = eng.backend.get_expectation_value(hamiltonian, wavefunction) # Last operation in any program should be measuring all qubits All(Measure) | qureg eng.flush() Getting started --------------- To start using ProjectQ, simply follow the installation instructions in the `tutorials `__. There, you will also find OS-specific hints, a small introduction to the ProjectQ syntax, and a few `code examples `__. More example codes and tutorials can be found in the examples folder `here `__ on GitHub. Also, make sure to check out the `ProjectQ website `__ and the detailed `code documentation `__. How to contribute ----------------- For information on how to contribute, please visit the `ProjectQ website `__ or send an e-mail to info@projectq.ch. Please cite ----------- When using ProjectQ for research projects, please cite - Damian S. Steiger, Thomas Häner, and Matthias Troyer "ProjectQ: An Open Source Software Framework for Quantum Computing" `Quantum 2, 49 (2018) `__ (published on `arXiv `__ on 23 Dec 2016) - Thomas Häner, Damian S. Steiger, Krysta M. Svore, and Matthias Troyer "A Software Methodology for Compiling Quantum Programs" `Quantum Sci. Technol. 3 (2018) 020501 `__ (published on `arXiv `__ on 5 Apr 2016) Authors ------- The first release of ProjectQ (v0.1) was developed by `Thomas Häner `__ and `Damian S. Steiger `__ in the group of `Prof. Dr. Matthias Troyer `__ at ETH Zurich. ProjectQ is constantly growing and `many other people `__ have already contributed to it in the meantime. License ------- ProjectQ is released under the Apache 2 license.