下（应用篇）| 推荐几款较流行的量子算法

 /   
   加密后的低32位是明文的高32位   
  /    
 tempCipherLower  = plainText[];    
 tempCipherHigher = plainText[] ^ keys[i] ^    
                 ( ((plainText[]<<)|(plainText[]>>(SIMON_WORD_SIZE-))) & ((plainText[]<<)|(plainText[]>>(SIMON_WORD_SIZE-))) ) ^    
                 ((plainText[]<<)|(plainText[]>>(SIMON_WORD_SIZE-)));    
 /   
   重新将加密的结果复制到plainText中   
  /    
 plainText[]     = tempCipherHigher;    
 plainText[]     = tempCipherLower;

  / 
   Simon：计算密钥，字大小为32
   inputKey：初始的密钥 
   keys：计算后得到的每轮密钥 
  /   
 void setSimonKeys32 ( unsigned int * inputKey, unsigned int * keys ) {   
   
     / 
       算法中的常数c，大小为2^n - 4，其中n是字的长度，即SIMON_WORD_SIZE 
       转化为二进制，即最低两位为0，其它位全为1 
      /   
     unsigned int c = 0xfffffffc;   
   
     int i;   
     ; i < SIMON_KEY_WORDS; i++ )  {   
         keys[i] = inputKey[i];   
     }   
   
     /*
       求解后面轮的密钥 
       先求其它的异或，最后求Zji，如果为1则对最低位进行修改，否则不变 
      /   
      ) {   
         ; i < SIMON_ROUNDS-SIMON_KEY_WORDS; i++ ) {   
             keys[i+SIMON_KEY_WORDS] = c ^ keys[i] ^   
                             ((keys[i+]>>) | (keys[i+]<<(SIMON_WORD_SIZE-))) ^   
                             ((keys[i+]>>) | (keys[i+]<<(SIMON_WORD_SIZE-)));   
             // SIMON_WORD_SIZE为32时，无论SIMON_KEY_WORDS为3还是4，周期都是62   
             ] ==  ) {   
                 keys[i+SIMON_KEY_WORDS] ^=  0x1;   
             }   
         }   
     }  ) {   
         // int cycle = (SIMON_SEQUENCE_NUMBER == 0 || SIMON_SEQUENCE_NUMBER == 1)?31:62;   
         unsigned int temp = 0x00000000;   
         ; i < SIMON_ROUNDS-SIMON_KEY_WORDS; i++ ) {   
             temp = ((keys[i+]>>) | (keys[i+]<<(SIMON_WORD_SIZE-))) ^ keys[i+];   
             keys[i+SIMON_KEY_WORDS] = c ^ keys[i] ^ temp ^ ((temp>>) | (temp<<(SIMON_WORD_SIZE-)));   
             ] ==  ) {   
                 keys[i+SIMON_KEY_WORDS] ^=  0x00000001;   
             }   
         }   
     }   
    
 }  

 import math   
 import random   
    
 from numpy import pi   
    
 from QuTrunk.core.circuit import QCircuit, InitState   
 from QuTrunk.core.gates import H, X, C, Z   
 from QuTrunk.core.calculator import Calculator   9. from QuTrunk.core.counter import Counter  

def apply_oracle(qr, num_qubits, sol_elem)...   
   
 def apply_diffuser(qr, num_qubits)...  

def run_grover():   
 num_qubits = 15   
 num_elems = 2 ** num_qubits   
 num_reps = math.ceil(pi / 4 * math.sqrt(num_elems))   
 print("num_qubits:", num_qubits, "num_elems:", num_elems, "num_reps:", num_reps)

 Counter(quit=15)   
     qubits = 15   
     quantum_gates = 11726   
     total_time = 10.865945100784302   
     qubox_time = 10.630940914154053   
     qutrunk_time = 0.23500418663024902  

  import paddle   
 import paddle_quantum.qchem as qchem   
 from paddle_quantum.loss import ExpecVal   
 from paddle_quantum import Hamiltonian   
 from paddle_quantum.state import zero_state, State   
 from paddle_quantum.ansatz import Circuit   
 from paddle_quantum.linalg import dagger   
 from paddle_quantum import Backend   
    
 import os   
 import matplotlib.pyplot as plt   
    
 import numpy   
 from numpy import pi as PI   
 from numpy import savez, zeros   
    
 # 无视警告   
 import warnings   
 warnings.filterwarnings("ignore")  

 geo = qchem.geometry(structure=[['H', [-0., 0., 0.0]], ['H', [-0., 0., 0.74]]])   
 # geo = qchem.geometry(file='h2.xyz')   
    
 # 将分子信息存储在 molecule 里，包括单体积分（one-body integrations），双体积分（two-body integrations），分子的哈密顿量等   
 molecule = qchem.get_molecular_data(   
     geometry=geo,   
     basis='sto-3g',   
     charge=0,   
     multiplicity=1,   
     method="fci",   
     if_save=True,   
     if_print=True   
 )   
 # 提取哈密顿量   
 molecular_hamiltonian = qchem.spin_hamiltonian(molecule=molecule,   
                                                filename=None,   
                                                multiplicity=1,    
                                                mapping_method='jordan_wigner',)   
 # 打印结果   
 print("\nThe generated h2 Hamiltonian is \n", molecular_hamiltonian)  

  def U_theta(num_qubits: int, depth: int) -> Circuit:   
     """  
     Quantum Neural Network  
     """   
        
     # 按照量子比特数量/网络宽度初始化量子神经网络   
     cir = Circuit(num_qubits)   
        
     # 内置的 {R_y + CNOT} 电路模板   
     cir.real_entangled_layer(depth = depth)   
        
     # 铺上最后一列 R_y 旋转门   
     cir.ry()   
            
     return cir  

  class StateNet(paddle.nn.Layer):   
     """ 
     Construct the model net 
     """   
   
     def __init__(self, num_qubits: int, depth: int):   
         super(StateNet, self).__init__()   
           
         self.depth = depth   
         self.num_qubits = num_qubits   
         self.cir = U_theta(self.num_qubits, self.depth)   
           
     # 定义损失函数和前向传播机制   
     def forward(self):   
           
         # 运行电路   
         state = self.cir(init_state)   
         # 计算损失函数   
         loss = loss_func(state)        
    
         return loss, self.cir

 ITR = 80  # 设置训练的总迭代次数   
 LR = 0.4   # 设置学习速率   
 D = 2      # 设置量子神经网络中重复计算模块的深度 Depth   
 N = molecular_hamiltonian.n_qubits # 设置参与计算的量子比特数

 # 确定网络的参数维度   
 net = StateNet(N, D)   
   
 # 一般来说，利用Adam优化器来获得相对好的收敛，   
 opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())   
   
 # 定义初始态   
 init_state = zero_state(N)   
   
 # 定义损失函数   
 loss_func = ExpecVal(molecular_hamiltonian)   
   
 # 记录优化结果   
 summary_iter, summary_loss = [], []   
   
 # 优化循环   
 for itr in range(1, ITR + 1):   
   
     # 前向传播计算损失函数   
     loss, cir = net()   
   
     # 在动态图机制下，反向传播极小化损失函数   
     loss.backward()   
     opt.minimize(loss)   
     opt.clear_grad()   
   
     # 更新优化结果   
     summary_loss.append(loss.numpy())   
     summary_iter.append(itr)   
   
     # 打印结果   
     if itr % 20 == 0:   
         print("iter:", itr, "loss:", "%.4f" % loss.numpy())   
         print("iter:", itr, "Ground state energy:", "%.4f Ha"   
                                             % loss.numpy())   
     if itr == ITR:   
         print("\n训练后的电路：")   
         print(cir)   
   
 # 储存训练结果到 output 文件夹   
 os.makedirs("output", exist_ok=True)   
 savez("./output/summary_data", iter = summary_iter,   
                                energy=summary_loss)

result = numpy.load('./output/summary_data.npz')  
   
 eig_val, eig_state = numpy.linalg.eig(   
                      molecular_hamiltonian.construct_h_matrix())   
 min_eig_H = numpy.min(eig_val.real)   
 min_loss = numpy.ones([len(result['iter'])]) * min_eig_H   
   
 plt.figure(1)   
 func1, = plt.plot(result['iter'], result['energy'],   
                   alpha=0.7, marker='', linestyle="-", color='r')   
 func_min, = plt.plot(result['iter'], min_loss,   
                   alpha=0.7, marker='', linestyle=":", color='b')   
 plt.xlabel('Number of iteration')   
 plt.ylabel('Energy (Ha)')   
   
 plt.legend(handles=[   
     func1,   
     func_min   
 ],   
     labels=[   
         r'$\left\langle {\psi \left( {\theta } \right)} '   
         r'\right|H\left| {\psi \left( {\theta } \right)} \right\rangle $',   
         'Ground-state energy',   
     ], loc='best')   
 plt.text(-15.5, -1.145, f'{min_eig_H:.5f}', fontsize=10, color='b')   
 #plt.savefig("vqe.png", bbox_inches='tight', dpi=300)   
 plt.show()  

pip install tensorflow==2.7.0

pip install tensorflow-quantum

 import tensorflow as tf   
 import tensorflow_quantum as tfq   
   
 import cirq   
 import sympy   
 import numpy as np   
   
 # visualization tools   
 %matplotlib inline   
 import matplotlib.pyplot as plt   
 from cirq.contrib.svg 
 import SVGCircuit

 # Parameters that the classical NN will feed values into.   
 control_params = sympy.symbols('theta_1 theta_2 theta_3')   
   
 # Create the parameterized circuit.   
 qubit = cirq.GridQubit(0, 0)   
 model_circuit = cirq.Circuit(   
     cirq.rz(control_params[0])(qubit),   
     cirq.ry(control_params[1])(qubit),   
     cirq.rx(control_params[2])(qubit))   
   
 SVGCircuit(model_circuit)  

 # The classical neural network layers.   
 controller = tf.keras.Sequential([   
     tf.keras.layers.Dense(10, activation='elu'),   
     tf.keras.layers.Dense(3)   
 ])  

controller(tf.constant([[0.0],[1.0]])).numpy()

 # This input is the simulated miscalibration that the model will learn to correct.   
 circuits_input = tf.keras.Input(shape=(),   
                                 # The circuit-tensor has dtype `tf.string`   
                                 dtype=tf.string,   
                                 name='circuits_input')   
   
 # Commands will be either `0` or `1`, specifying the state to set the qubit to.   
 commands_input = tf.keras.Input(shape=(1,),   
                                 dtype=tf.dtypes.float32,   
                                 name='commands_input')

 dense_2 = controller(commands_input)   
   
 # TFQ layer for classically controlled circuits.   
 expectation_layer = tfq.layers.ControlledPQC(model_circuit,   
                                              # Observe Z   
                                              operators = cirq.Z(qubit))   
 expectation = expectation_layer([circuits_input, dense_2])

 # The full Keras model is built from our layers.   
 model = tf.keras.Model(inputs=[circuits_input, commands_input],   
                        outputs=expectation)  

tf.keras.utils.plot_model(model, show_shapes=True, dpi=70)

 # The command input values to the classical NN.   
 commands = np.array([[0], [1]], dtype=np.float32)   
   
 # The desired Z expectation value at output of quantum circuit.   
 expected_outputs = np.array([[1], [-1]], dtype=np.float32)  

random_rotations = np.random.uniform(0, 2 * np.pi, 3)   
 noisy_preparation = cirq.Circuit(   
   cirq.rx(random_rotations[0])(qubit),   
   cirq.ry(random_rotations[1])(qubit),   
   cirq.rz(random_rotations[2])(qubit)   
 )   
 datapoint_circuits = tfq.convert_to_tensor([   
   noisy_preparation   
 ] * 2)  # Make two copied of this circuit  

model([datapoint_circuits, commands]).numpy()

optimizer = tf.keras.optimizers.Adam(learning_rate=0.05)   
 loss = tf.keras.losses.MeanSquaredError()   
 model.compile(optimizer=optimizer, loss=loss)   4. history = model.fit(x=[datapoint_circuits, commands],   
                     y=expected_outputs,   
                     epochs=30,   
                     verbose=0)  

 plt.plot(history.history['loss'])   
 plt.title("Learning to Control a Qubit")   
 plt.xlabel("Iterations")   
 plt.ylabel("Error in Control")   
 plt.show()  

def check_error(command_values, desired_values):   
 """Based on the value in `command_value` see how well you could prepare 
 the full circuit to have `desired_value` when taking expectation w.r.t. Z."""   
   params_to_prepare_output = controller(command_values).numpy()   
   full_circuit = noisy_preparation + model_circuit  
    
   # Test how well you can prepare a state to get expectation the expectation   
   # value in `desired_values`   
   for index in [0, 1]:   
     state = cirq_simulator.simulate(   
         full_circuit,   
         {s:v for (s,v) in zip(control_params, params_to_prepare_output[index])}   
     ).final_state_vector   
     expt = cirq.Z(qubit).expectation_from_state_vector(state, {qubit: 0}).real   
     print(f'For a desired output (expectation) of {desired_values[index]} with'   
           f' noisy preparation, the controller\nnetwork found the following '   
           f'values for theta: {params_to_prepare_output[index]}\nWhich gives an'   
           f' actual expectation of: {expt}\n')   
    
    
 check_error(commands, expected_outputs)