Shulou(Shulou.com)06/01 Report--

This article mainly explains "python uses ProjectQ to generate quantum algorithm instruction set". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "python uses ProjectQ to generate quantum algorithm instruction set".

ProjectQ is an open source quantum computing framework. Through projectQ, we can generate the instruction set of quantum algorithms, and then develop quantum algorithms. ProjectQ is compiled and run based on python.

Output algorithm operation

First of all, the most basic use is to use ProjectQ to print the quantum gate operation entered in the quantum algorithm, where the instructions used to save the operation in the back end of DummyEngine in ProjectQ are used. For example, the simplest preparation of a Bell State can be achieved by the following code, and print out the basic operations saved:

From projectq import MainEnginefrom projectq.cengines import DummyEnginefrom projectq.ops import H, CX, All, Measurebackend = DummyEngine (save_commands=True) eng = MainEngine (backend=backend) qureg = eng.allocate_qureg (2) H | qureg [0] CX | (qureg [0], qureg [1]) All (Measure) | quregeng.flush (deallocate_qubits=True) for cmd in backend.received_commands: print (cmd)

The running results are as follows:

Allocate | Qureg [0] H | Qureg [0] Allocate | Qureg [1] CX | (Qureg [0], Qureg [1]) Measure | Qureg [0] Measure | Qureg [1] Deallocate | Qureg [0] Deallocate | Qureg [1]

One thing to note here is that if it is a single operation, we can finish it at Measure. However, if the task of the same thread is not finished, you need to add a deallocate_qubits=True configuration item after the Measure to release the memory occupied by the currently allocated qubits.

Encapsulated operation

In the implementation of quantum algorithm, we can use some functions or classes to encapsulate part of the quantum algorithm operation instructions, but this may lead to a problem, that is, the operation instructions printed on ProjectQ do not output the contents of the encapsulated module, such as the following case:

From projectq import MainEnginefrom projectq.cengines import DummyEnginefrom projectq.ops import H, CX, All, Measure, TimeEvolution, QubitOperatorbackend = DummyEngine (save_commands=True) eng = MainEngine (backend=backend) qureg = eng.allocate_qureg (3) H | qureg [0] CX | (qureg [0], qureg [1]) TimeEvolution (1, QubitOperator ('X2 X1')) | quregAll (Measure) | quregeng.flush () for cmd in backend.received_commands: print (cmd)

The implementation results are as follows:

Allocate | Qureg [0] H | Qureg [0] Allocate | Qureg [1] CX | (Qureg [0], Qureg [1]) Measure | Qureg [0] Allocate | Qureg [2] exp (- 1J * (1.0 X0X1)) | Qureg [1-2] Measure | Qureg [1] Measure | Qureg [2]

We find that the operator of the time-dependent evolution here is not decomposed but printed out directly. However, if only the supported instruction operations can be recognized in the hardware system, the time-dependent evolution operation may not be implemented in the quantum hardware system, so we need to decompose the instructions before sending them to the quantum hardware.

Decomposition of time-dependent evolution operators

Here, we directly call the restrictedgateset method in the configuration of ProjectQ to decompose the operation. We expand the scope of single-bit gate operation to all operations, but the two-bit operation only allows CX operation, and configure this configuration into the MainEngine of ProjectQ as engin_list:

From projectq import MainEnginefrom projectq.cengines import DummyEnginefrom projectq.ops import H, CX, All, Measure, TimeEvolution, QubitOperatorfrom projectq.setups import restrictedgatesetengine_list = restrictedgateset.get_engine_list (one_qubit_gates= "any", two_qubit_gates= (CX,) backend= DummyEngine (save_commands=True) eng = MainEngine (backend=backend,engine_list=engine_list) qureg = eng.allocate_qureg (3) H | qureg [0] CX | (qureg [0], qureg [1]) TimeEvolution (1 QubitOperator ('X2 X1')) | quregAll (Measure) | quregeng.flush (deallocate_qubits=True) for cmd in backend.received_commands: print (cmd)

The printout results are as follows:

Allocate | Qureg [0] H | Qureg [0] Allocate | Qureg [1] CX | (Qureg [0], Qureg [1]) Measure | Qureg [0] Allocate | Qureg [2] H | Qureg [2] H | Qureg [1] CX | (Qureg [1], Qureg [2]) Rz (2.0) | Qureg [2] CX | (Qureg [1]) Qureg [2]) H | Qureg [1] Measure | Qureg [1] H | Qureg [2] Measure | Qureg [2] Deallocate | Qureg [0] Deallocate | Qureg [1] Deallocate | Qureg [2]

You can see that the time-dependent evolution operator has been decomposed and output. Since it is known that a single-bit quantum gate plus a CX is a complete set of quantum gates, we can generally use this set to restrict the instruction set of quantum gate operations.

Decomposition of QFT

QFT is a quantum gate operation encapsulation of quantum Fourier transform supported by ProjectQ. Similar to the time-dependent evolution operator introduced in the previous chapter, we can use restrictedgateset to specifically decompose the QFT operator:

From projectq import MainEnginefrom projectq.cengines import DummyEnginefrom projectq.ops import H, CX, All, Measure, TimeEvolution, QubitOperator, QFTfrom projectq.setups import restrictedgatesetengine_list = restrictedgateset.get_engine_list (one_qubit_gates= "any", two_qubit_gates= (CX,)) backend= DummyEngine (save_commands=True) eng = MainEngine (backend=backend,engine_list=engine_list) qureg = eng.allocate_qureg (3) H | qureg [0] CX | (qureg [0] Qureg [1]) QFT | quregAll (Measure) | quregeng.flush (deallocate_qubits=True) for cmd in backend.received_commands: print (cmd)

The output is as follows:

Allocate | Qureg [2] Allocate | Qureg [1] H | Qureg [2] Rz (0.785398163398) | Qureg [2] Allocate | Qureg [0] H | Qureg [0] CX | (Qureg [0], Qureg [1]) R (0.785398163398) | Qureg [1] CX | (Qureg [1], Qureg [2]) Rz (11.780972450962) | Qureg [2] CX | (Qureg [1]) Qureg [2]) R (0.392699081698) | Qureg [0] Rz (0.392699081698) | Qureg [2] CX | (Qureg [0], Qureg [2]) H | Qureg [1] Rz (12.173671532661) | Qureg [2] CX | (Qureg [0], Qureg [2]) R (0.785398163398) | Qureg [0] Rz (0.785398163398) | Qureg [1] CX | (Qureg [0], Qureg [1]) Rz (11.78092450962) | Qureg [1] CX | (Qureg [0]) Qureg [1]) H | Qureg [0] Measure | Qureg [0] Measure | Qureg [1] Measure | Qureg [2] Deallocate | Qureg [1] Deallocate | Qureg [2] Deallocate | Qureg [0]

If the 2-bit gate operation is not restricted, the easiest form of decomposition will be automatically selected in ProjectQ:

From projectq import MainEnginefrom projectq.cengines import DummyEnginefrom projectq.ops import H, CX, All, Measure, TimeEvolution, QubitOperator, QFTfrom projectq.setups import restrictedgatesetengine_list = restrictedgateset.get_engine_list (one_qubit_gates= "any", two_qubit_gates= "any") backend= DummyEngine (save_commands=True) eng = MainEngine (backend=backend,engine_list=engine_list) qureg = eng.allocate_qureg (3) H | qureg [0] CX | (qureg [0] Qureg [1]) QFT | quregAll (Measure) | quregeng.flush (deallocate_qubits=True) for cmd in backend.received_commands: print (cmd)

The output is as follows:

Allocate | Qureg [0] Allocate | Qureg [1] H | Qureg [0] CX | (Qureg [0], Qureg [1]) Allocate | Qureg [2] H | Qureg [2] CR (1.570796326795) | (Qureg [1], Qureg [2]) CR (0.785398163397) | (Qureg [0], Qureg [2]) H | Qureg [1] CR (1.570796326795) | (Qureg [0]) Qureg [1]) H | Qureg [0] Measure | Qureg [0] Measure | Qureg [1] Measure | Qureg [2] Deallocate | Qureg [1] Deallocate | Qureg [2] Deallocate | Qureg [0]

You can find that when CR is used instead of CX, the broken down lines will be shorter.

Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.