first commit

first commit

readme update

.gitignore

+.idea
+__pycache__/
+
+output
+*.egg-info
+.ipynb_checkpoints
\ No newline at end of file

.pre-commit-config.yaml

+-   repo: https://github.com/PaddlePaddle/mirrors-yapf.git
+    sha: 0d79c0c469bab64f7229c9aca2b1186ef47f0e37
+    hooks:
+    -   id: yapf
+        files: \.py$
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    sha: a11d9314b22d8f8c7556443875b731ef05965464
+    hooks:
+    -   id: check-merge-conflict
+    -   id: check-symlinks
+    -   id: detect-private-key
+        files: (?!.*paddle)^.*$
+    -   id: end-of-file-fixer
+        files: \.md$
+    -   id: trailing-whitespace
+        files: \.md$
+-   repo: https://github.com/Lucas-C/pre-commit-hooks
+    sha: v1.0.1
+    hooks:
+    -   id: forbid-crlf
+        files: \.md$
+    -   id: remove-crlf
+        files: \.md$
+    -   id: forbid-tabs
+        files: \.md$
+    -   id: remove-tabs
+        files: \.md$
+-   repo: local
+    hooks:
+    -   id: copyright_checker
+        name: copyright_checker
+        entry: python ./tools/copyright.hook
+        language: system
+        files: \.(c|cc|cxx|cpp|cu|h|hpp|hxx|proto|py)$
+        exclude: (?!.*third_party)^.*$ | (?!.*book)^.*$
\ No newline at end of file

LICENSE

+   Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserve.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
\ No newline at end of file

README.md

-# Quantum
\ No newline at end of file
+# Paddle Quantum （量桨）
+
+Paddle Quantum（量桨）是基于百度飞桨开发的量子机器学习工具集，支持量子神经网络的搭建与训练，提供易用的量子机器学习开发套件与量子优化、量子化学等前沿量子应用工具集，使得百度飞桨也因此成为国内首个目前也是唯一一个支持量子机器学习的深度学习框架。
+
+![](https://release-data.cdn.bcebos.com/Paddle%20Quantum.png)
+
+量桨建立起了人工智能与量子计算的桥梁，不但可以快速实现量子神经网络的搭建与训练，还提供易用的量子机器学习开发套件与量子优化、量子化学等前沿量子应用工具集，并提供多项自研量子机器学习应用。通过百度飞桨深度学习平台赋能量子计算，量桨为领域内的科研人员以及开发者便捷地开发量子人工智能的应用提供了强有力的支撑，同时也为广大量子计算爱好者提供了一条可行的学习途径。
+
+
+
+## 特色
+
+- 易用性：提供简洁的神经网络搭建与丰富的量子机器学习案例。
+- 通用性与拓展性：支持常用量子电路模型，提供多项优化工具。
+- 特色工具集：提供量子优化、量子化学等前沿量子应用工具集，自研多项量子机器学习应用。
+
+
+
+## 安装步骤
+
+### Install PaddlePaddle
+请参考 [PaddlePaddle](https://www.paddlepaddle.org.cn/documentation/docs/zh/beginners_guide/index_cn.html) 安装配置页面。此项目需求 PaddlePaddle 1.8.0 或更高版本。
+
+
+
+### 下载 Paddle Quantum 并安装
+
+```bash
+git clone http://github.com/PaddlePaddle/quantum
+```
+
+```bash
+cd quantum
+pip install -e .
+```
+
+
+
+### 或使用 requirements.txt 安装依赖包
+
+```bash
+python -m pip install --upgrade -r requirements.txt
+```
+
+### 使用 openfermion 读取xyz 描述文件 （仅可在linux下安装使用）
+VQE中调用 openfermion 读取分子xyz文件并计算，因此需要安装 openfermion 和 openfermionpyscf。
+```bash
+pip install openfermion
+pip install openfermionpyscf
+```
+
+
+### 运行
+
+```bash
+cd paddle_quantum/QAOA/example
+python main.py
+```
+
+
+
+## 入门与开发
+
+### 教程入门
+
+量子计算是由量子力学与计算理论交叉而成的全新计算模型，具有强大的信息处理优势和广阔的应用前景，被视作未来计算技术的心脏。量子计算的相关介绍与入门知识可以参考 [1-3]。
+
+量子机器学习是一门结合量子计算与机器学习的交叉学科，一方面利用量子计算的信息处理优势促进人工智能的发展，另一方面也利用现有的人工智能的技术突破量子计算的研发瓶颈。关于量子机器学习的入门资料可以参考 [4-6]。Paddle Quantum（量桨）建立起了人工智能与量子计算的桥梁，为量子机器学习领域的研发提供强有力的支撑，也提供了丰富的案例供开发者学习。
+
+
+
+### 案例入门
+
+特别的，我们提供了涵盖量子优化、量子化学、量子机器学习等多个领域的案例供大家学习。比如：
+
+- 量子组合优化（QAOA），完成安装步骤后打开 tutorial\QAOA.ipynb 即可进行研究学习。
+
+```bash
+cd tutorial
+jupyter notebook  QAOA.ipynb
+```
+
+- 量子特征求解器（VQE），完成安装步骤后打开 tutorial\VQE.ipynb 即可进行研究学习。
+
+```
+cd tutorial
+jupyter notebook  VQE.ipynb
+```
+
+
+
+### 开发
+
+Paddle Quantum 使用 setuptools的develop 模式进行安装，相关代码修改可以直接进入`paddle_quantum` 文件夹进行修改。python 文件携带了自说明注释。
+
+
+
+## 交流与反馈
+
+- 我们非常欢迎您欢迎您通过[Github Issues](https://github.com/PaddlePaddle/Quantum/issues)来提交问题、报告与建议。
+
+- QQ技术交流群: 1076223166
+
+## 使用Paddle Quantum的工作
+
+我们非常欢迎开发者使用Paddle Quantum进行量子机器学习的研发，如果您的工作有使用Paddle Quantum，也非常欢迎联系我们。目前使用 Paddle Quantum 的代表性工作关于 Gibbs 态制备如下：
+
+[1] Y. Wang, G. Li, and X. Wang, “Variational quantum Gibbs state preparation with a truncated Taylor series,” arXiv:2005.08797, May 2020. [[pdf](https://arxiv.org/pdf/2005.08797.pdf)]
+
+
+## Copyright and License
+
+Paddle Quantum 使用 [Apache-2.0 license](LICENSE)许可证。
+
+
+
+## References
+
+[1] [量子计算 - 百度百科](https://baike.baidu.com/item/量子计算/11035661?fr=aladdin)
+
+[2] M. A. Nielsen and I. L. Chuang, Quantum computation and quantum information. Cambridge university press, 2010.
+
+[3] Phillip Kaye, R. Laflamme, and M. Mosca, An Introduction to Quantum Computing. 2007.
+
+[4] J. Biamonte, P. Wittek, N. Pancotti, P. Rebentrost, N. Wiebe, and S. Lloyd, “Quantum machine learning,” Nature, vol. 549, no. 7671, pp. 195–202, Sep. 2017. [[pdf](https://arxiv.org/pdf/1611.09347)]
+
+[5] M. Schuld, I. Sinayskiy, and F. Petruccione, “An introduction to quantum machine learning,” Contemp. Phys., vol. 56, no. 2, pp. 172–185, 2015. [[pdf](https://arxiv.org/pdf/1409.3097)]
+
+[6] M. Benedetti, E. Lloyd, S. Sack, and M. Fiorentini, “Parameterized quantum circuits as machine learning models,” Quantum Sci. Technol., vol. 4, no. 4, p. 043001, Nov. 2019. [[pdf](https://arxiv.org/pdf/1906.07682)]

paddle_quantum/GIBBS/HGenerator.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+HGenerator
+"""
+
+from numpy import array, kron, trace
+import scipy
+
+__all__ = ["H_generator", ]
+
+
+def H_generator():
+    """
+    Generate a Hamiltonian with trivial descriptions
+    Returns: A Hamiltonian
+    """
+
+    beta = 1
+    sigma_I = array([[1, 0], [0, 1]])
+    sigma_Z = array([[1, 0], [0, -1]])
+
+    H = (-kron(kron(sigma_Z, sigma_Z), sigma_I) - kron(
+        kron(sigma_I, sigma_Z), sigma_Z) - kron(
+            kron(sigma_Z, sigma_I), sigma_Z))
+
+    rho = scipy.linalg.expm(-1 * beta *
+                            H) / trace(scipy.linalg.expm(-1 * beta * H))
+
+    return H.astype("complex64"), rho.astype("complex64")

paddle_quantum/GIBBS/Paddle_GIBBS.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Paddle_GIBBS
+"""
+
+from numpy import concatenate, zeros
+from numpy import pi as PI
+
+from paddle import fluid
+from paddle.complex import matmul, transpose, trace
+from paddle_quantum.circuit import UAnsatz
+from paddle_quantum.utils import compute_fid, partial_trace
+
+from paddle_quantum.GIBBS.HGenerator import H_generator
+
+SEED = 1
+
+__all__ = [
+    "U_theta",
+    "Net",
+    "Paddle_GIBBS",
+]
+
+
+def U_theta(theta, input_state, N, D):  # definition of U_theta
+    """
+    :param theta:
+    :param input_state:
+    :return:
+    """
+
+    cir = UAnsatz(N, input_state=input_state)
+    for i in range(N):
+        cir.rx(theta=theta[0][0][i], which_qubit=i + 1)
+        cir.ry(theta=theta[0][1][i], which_qubit=i + 1)
+        cir.rx(theta=theta[0][2][i], which_qubit=i + 1)
+
+    for repeat in range(D):
+        for i in range(1, N):
+            cir.cnot(control=[i, i + 1])
+
+        for i in range(N):
+            cir.ry(theta=theta[repeat][0][i], which_qubit=i + 1)
+            # cir.ry(theta=theta[repeat][1][i], which_qubit=i + 1)
+            # cir.ry(theta=theta[repeat][2][i], which_qubit=i + 1)
+
+    return cir.state
+
+
+class Net(fluid.dygraph.Layer):
+    """
+    Construct the model net
+    """
+
+    def __init__(self,
+                 shape,
+                 param_attr=fluid.initializer.Uniform(
+                     low=0.0, high=PI, seed=SEED),
+                 dtype='float32'):
+        super(Net, self).__init__()
+
+        self.theta = self.create_parameter(
+            shape=shape, attr=param_attr, dtype=dtype, is_bias=False)
+
+    def forward(self, input_state, H, N, N_SYS_B, D):
+        """
+        Args:
+            input_state: The initial state with default |0..>
+            H: The target Hamiltonian
+        Returns:
+            The loss.
+        """
+
+        out_state = U_theta(self.theta, input_state, N, D)
+
+        # rho_AB = utils.matmul(utils.matrix_conjugate_transpose(out_state), out_state)
+        rho_AB = matmul(
+            transpose(
+                fluid.framework.ComplexVariable(out_state.real,
+                                                -out_state.imag),
+                perm=[1, 0]),
+            out_state)
+
+        # compute the partial trace and three losses
+        rho_B = partial_trace(rho_AB, 2**(N - N_SYS_B), 2**(N_SYS_B), 1)
+        rho_B_squre = matmul(rho_B, rho_B)
+        loss1 = (trace(matmul(rho_B, H))).real
+        loss2 = (trace(rho_B_squre)).real * 2
+        loss3 = -(trace(matmul(rho_B_squre, rho_B))).real / 2
+
+        loss = loss1 + loss2 + loss3  # 损失函数
+
+        # option: if you want to check whether the imaginary part is 0, uncomment the following
+        # print('loss_iminary_part: ', loss.numpy()[1])
+        return loss - 3 / 2, rho_B
+
+
+def Paddle_GIBBS(hamiltonian, rho=None, N=5, N_SYS_B=3, D=1, ITR=100, LR=0.5):
+    """
+    Paddle_GIBBS
+    """
+
+    with fluid.dygraph.guard():
+        # initial state preparing
+        _initial_state_np = concatenate(
+            ([[1.]], zeros([1, 2**N - 1])), axis=1).astype('complex64')
+        initial_state = fluid.dygraph.to_variable(_initial_state_np)
+
+        # gibbs Hamiltonian preparing
+        H = fluid.dygraph.to_variable(hamiltonian)
+
+        # net
+        net = Net(shape=[D + 1, 3, N])
+
+        # optimizer
+        opt = fluid.optimizer.AdamOptimizer(
+            learning_rate=LR, parameter_list=net.parameters())
+
+        # gradient descent loop
+        for itr in range(1, ITR + 1):
+            loss, rho_B = net(initial_state, H, N, N_SYS_B, D)
+
+            loss.backward()
+            opt.minimize(loss)
+            net.clear_gradients()
+
+            rho_B = rho_B.numpy()
+
+            if rho is not None:
+                fid = compute_fid(rho_B, rho)
+                print('iter:', itr, 'loss:', '%.4f' % loss.numpy(), 'fid:',
+                      '%.4f' % fid)
+
+    return rho_B
+
+
+def main():
+    """
+    main
+    """
+
+    # gibbs Hamiltonian preparing
+    hamiltonian, rho = H_generator()
+    rho_B = Paddle_GIBBS(hamiltonian, rho)
+    print(rho_B)
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/GIBBS/example/main.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+main
+"""
+
+from paddle_quantum.GIBBS.HGenerator import H_generator
+from paddle_quantum.GIBBS.Paddle_GIBBS import Paddle_GIBBS
+
+
+def main():
+    hamiltonian, rho = H_generator()
+    rho_B = Paddle_GIBBS(hamiltonian, rho)
+    print(rho_B)
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/GIBBS/main.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+main
+"""
+
+from paddle_quantum.GIBBS.HGenerator import H_generator
+from paddle_quantum.GIBBS.Paddle_GIBBS import Paddle_GIBBS
+
+
+def main():
+    # gibbs Hamiltonian preparing
+    hamiltonian, rho = H_generator()
+    rho_B = Paddle_GIBBS(hamiltonian, rho)
+    print(rho_B)
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/QAOA/Paddle_QAOA.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Paddle_QAOA: To learn more about the functions and properties of this application,
+you could check the corresponding Jupyter notebook under the Tutorial folder.
+"""
+
+import os
+from paddle import fluid
+from paddle.complex import matmul as pp_matmul
+from paddle.complex import transpose
+from paddle_quantum.circuit import UAnsatz
+from paddle_quantum.QAOA.QAOA_Prefunc import generate_graph, H_generator
+
+from numpy import ones, abs, conjugate, real, savez, sqrt, zeros
+from numpy import matmul as np_matmul
+from numpy import pi as PI
+
+# Random seed for optimizer
+SEED = 1
+
+__all__ = [
+    "circuit_QAOA",
+    "circuit_extend_QAOA",
+    "Net",
+    "Paddle_QAOA",
+]
+
+
+def circuit_QAOA(theta, input_state, adjacency_matrix, N, P):
+    """
+    This function constructs the parameterized QAOA circuit which is composed of P layers of two blocks:
+    one block is U_theta[layer][0] based on the problem Hamiltonian H which encodes the classical problem,
+    and the other is U_theta[layer][1] constructed from the driving Hamiltonian describing the rotation around Pauli X
+    acting on each qubit. It finally outputs the final state of the QAOA circuit.
+
+    Args:
+         theta: parameters to be optimized in the QAOA circuit
+         input_state: initial state of the QAOA circuit which usually is the uniform superposition of 2^N bit-strings
+                    in the computational basis $|0\rangle, |1\rangle$
+         adjacency_matrix:  the adjacency matrix of the graph encoding the classical problem
+         N: number of qubits, or equivalently, the number of nodes in the given graph
+         P: number of layers of two blocks in the QAOA circuit
+    Returns:
+        the final state of the QAOA circuit: cir.state
+
+    """
+
+    cir = UAnsatz(N, input_state=input_state)
+    # The first loop defines the QAOA circuit with P layers of two blocks
+    for layer in range(P):
+        # The second and third loops aim to construct the first block U_theta[layer][0] which involves
+        # two-qubit operation e^{-i\beta Z_iZ_j} acting on a pair of qubits or nodes i and j in the circuit.
+        for row in range(N):
+            for col in range(N):
+                if abs(adjacency_matrix[row, col]) and row < col:
+                    cir.cnot([row + 1, col + 1])
+                    cir.rz(
+                        theta=theta[layer][0] * adjacency_matrix[row, col],
+                        which_qubit=col + 1, )
+                    cir.cnot([row + 1, col + 1])
+        # This loops constructs the second block U_theta only involving the single-qubit operation e^{-i\beta X}.
+        for i in range(1, N + 1):
+            cir.rx(theta=theta[layer][1], which_qubit=i)
+
+    return cir.state
+
+
+def circuit_extend_QAOA(theta, input_state, adjacency_matrix, N, P):
+    """
+    This is an extended version of the QAOA circuit, and the main difference is U_theta[layer]([1]-[3]) constructed
+    from the driving Hamiltonian describing the rotation around an arbitrary direction on each qubit.
+
+    Args:
+        theta: parameters to be optimized in the QAOA circuit
+        input_state: input state of the QAOA circuit which usually is the uniform superposition of 2^N bit-strings
+                     in the computational basis
+        adjacency_matrix:  the adjacency matrix of the problem graph encoding the original problem
+        N: number of qubits, or equivalently, the number of parameters in the original classical problem
+        P: number of layers of two blocks in the QAOA circuit
+    Returns:
+        final state of the QAOA circuit: cir.state
+
+    Note: If this U_extend_theta function is used to construct QAOA circuit, then we need to change the parameter layer
+           in the Net function defined below from the Net(shape=[D, 2]) for U_theta function to Net(shape=[D, 4])
+           because the number of parameters doubles in each layer in this QAOA circuit.
+    """
+
+    cir = UAnsatz(N, input_state=input_state)
+
+    # The first loop defines the QAOA circuit with P layers of two blocks
+    for layer in range(P):
+        # The second and third loops aim to construct the first block U_theta[layer][0] which involves
+        # two-qubit operation e^{-i\beta Z_iZ_j} acting on a pair of qubits or nodes i and j in the circuit.
+        for row in range(N):
+            for col in range(N):
+                if abs(adjacency_matrix[row, col]) and row < col:
+                    cir.cnot([row + 1, col + 1])
+                    cir.rz(
+                        theta=theta[layer][0] * adjacency_matrix[row, col],
+                        which_qubit=col + 1, )
+                    cir.cnot([row + 1, col + 1])
+        # This loops constructs the second block U_theta[layer][1]-[3] composed of three single-qubit operation
+        #  e^{-i\beta[1] Z}e^{-i\beta[2] X}e^{-i\beta[3] X} sequentially acting on single qubits.
+        for i in range(1, N + 1):
+            cir.rz(theta=theta[layer][1], which_qubit=i)
+            cir.rx(theta=theta[layer][2], which_qubit=i)
+            cir.rz(theta=theta[layer][3], which_qubit=i)
+
+    return cir.state
+
+
+class Net(fluid.dygraph.Layer):
+    """
+    It constructs the net for QAOA which combines the  QAOA circuit with the classical optimizer which sets rules
+    to update parameters described by theta introduced in the QAOA circuit.
+
+    """
+
+    def __init__(
+            self,
+            shape,
+            param_attr=fluid.initializer.Uniform(
+                low=0.0, high=PI, seed=SEED),
+            dtype="float32", ):
+        super(Net, self).__init__()
+
+        self.theta = self.create_parameter(
+            shape=shape, attr=param_attr, dtype=dtype, is_bias=False)
+
+    def forward(self, input_state, adjacency_matrix, out_state_store, N, P,
+                METHOD):
+        """
+        This function constructs the loss function for the QAOA circuit.
+
+        Args:
+            self: the free parameters to be optimized in the QAOA circuit and defined in the above function
+            input_state: initial state of the QAOA circuit which usually is the uniform superposition of 2^N bit-strings
+                         in the computational basis $|0\rangle, |1\rangle$
+            adjacency_matrix: the adjacency matrix generated from the graph encoding the classical problem
+            out_state_store: the output state of the QAOA circuit
+            N: number of qubits
+            P: number of layers
+            METHOD: which version of QAOA is chosen to solve the problem, i.e., standard version labeled by 1 or
+            extended version by 2.
+        Returns:
+            The loss function for the parameterized QAOA circuit.
+        """
+
+        # Generate the problem_based quantum Hamiltonian H_problem based on the classical problem in paddle
+        H, _ = H_generator(N, adjacency_matrix)
+        H_problem = fluid.dygraph.to_variable(H)
+
+        # The standard QAOA circuit: the function circuit_QAOA is used to construct the circuit, indexed by METHOD 1.
+        if METHOD == 1:
+            out_state = circuit_QAOA(self.theta, input_state, adjacency_matrix,
+                                     N, P)
+        # The extended QAOA circuit: the function circuit_extend_QAOA is used to construct the net, indexed by METHOD 2.
+        elif METHOD == 2:
+            out_state = circuit_extend_QAOA(self.theta, input_state,
+                                            adjacency_matrix, N, P)
+        else:
+            raise ValueError("Wrong method called!")
+
+        out_state_store.append(out_state.numpy())
+        loss = pp_matmul(
+            pp_matmul(out_state, H_problem),
+            transpose(
+                fluid.framework.ComplexVariable(out_state.real,
+                                                -out_state.imag),
+                perm=[1, 0], ), )
+
+        return loss.real
+
+
+def main(N=4):
+    """
+    This is the main function which maps the classical problem to the quantum version solved by QAOA and outputs
+    the quantum solution and its corresponding classical ones. Here, N=4 is a 4-qubit example to show how QAOA works.
+
+    """
+    # Generate the adjacency matrix from the description of the problem-based graph
+    _, classical_graph_adjacency = generate_graph(N, 1)
+    Paddle_QAOA(classical_graph_adjacency)
+
+
+def Paddle_QAOA(classical_graph_adjacency, N=4, P=4, METHOD=1, ITR=120,
+                LR=0.1):
+    """
+    This is the core function to run QAOA.
+
+     Args:
+         classical_graph_adjacency: adjacency matrix to describe the graph which encodes the classical problem
+         N: number of qubits (default value N=4)
+         P: number of layers of blocks in the QAOA circuit (default value P=4)
+         METHOD: which version of the QAOA circuit is used: 1, standard circuit (default); 2, extended circuit
+         ITR: number of iteration steps for QAOA (default value ITR=120)
+         LR: learning rate for the gradient-based optimization method (default value LR=0.1)
+     Returns:
+         optimized parameters theta and the bitstrings sampled from the output state with maximal probability
+    """
+
+    out_state_store = []
+    with fluid.dygraph.guard():
+        # Preparing the initial state
+        _initial_state = ones([1, 2**N]).astype("complex64") / sqrt(2**N)
+        initial_state = fluid.dygraph.to_variable(_initial_state)
+
+        # Construct the net or QAOA circuits based on the standard modules
+        if METHOD == 1:
+            net = Net(shape=[P, 2])
+        # Construct the net or QAOA circuits based on the extended modules
+        elif METHOD == 2:
+            net = Net(shape=[P, 4])
+        else:
+            raise ValueError("Wrong method called!")
+
+        # Classical optimizer
+        opt = fluid.optimizer.AdamOptimizer(
+            learning_rate=LR, parameter_list=net.parameters())
+
+        # Gradient descent loop
+        summary_iter, summary_loss = [], []
+        for itr in range(1, ITR + 1):
+            loss = net(initial_state, classical_graph_adjacency,
+                       out_state_store, N, P, METHOD)
+            loss.backward()
+            opt.minimize(loss)
+            net.clear_gradients()
+
+            print("iter:", itr, "  loss:", "%.4f" % loss.numpy())
+            summary_loss.append(loss[0][0].numpy())
+            summary_iter.append(itr)
+
+        theta_opt = net.parameters()[0].numpy()
+        print(theta_opt)
+
+        os.makedirs("output", exist_ok=True)
+        savez("./output/summary_data", iter=summary_iter, energy=summary_loss)
+
+    # Output the measurement probability distribution sampled from the output state of optimized QAOA circuit.
+    prob_measure = zeros([1, 2**N]).astype("complex")
+
+    rho_out = out_state_store[-1]
+    rho_out = np_matmul(conjugate(rho_out).T, rho_out).astype("complex")
+
+    for index in range(0, 2**N):
+        comput_basis = zeros([1, 2**N])
+        comput_basis[0][index] = 1
+        prob_measure[0][index] = real(
+            np_matmul(np_matmul(comput_basis, rho_out), comput_basis.T))
+
+    return prob_measure
+
+
+if __name__ == "__main__":
+    main()

paddle_quantum/QAOA/QAOA_Prefunc.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Aid func
+"""
+from matplotlib import pyplot
+from numpy import abs, array, binary_repr, diag, kron, max, ones, real, where, zeros
+import networkx
+
+__all__ = [
+    "plot_graph",
+    "generate_graph",
+    "H_generator",
+]
+
+
+def plot_graph(measure_prob_distribution, graph, N):
+    """
+    This function plots the graph encoding the combinatorial problem such as Max-Cut and the final graph encoding the
+    approximate solution obtained from QAOA
+
+    Args:
+        measure_prob_distribution: the measurement probability distribution which is sampled from the output state
+                                   of optimized QAOA circuit.
+        graph: graph encoding the topology of the classical combinatorial problem, such as Max-Cut problem
+        N: number of qubits, or number of nodes in the graph
+    Return:
+        three graphs: the first displays the graph topology of the classical problem;
+                      the second is the bar graph for the measurement distribution for each bitstring in the output state
+                      the third plots the graph corresponding to the bitstring with maximal measurement probability
+    """
+
+    # Find the position of max value in the measure_prob_distribution
+    max_prob_pos_list = where(
+        measure_prob_distribution == max(measure_prob_distribution))
+    # Store the max value from ndarray to list
+    max_prob_list = max_prob_pos_list[0].tolist()
+    # Store it in the  binary format
+    solution_list = [binary_repr(index, width=N) for index in max_prob_list]
+    print("The output bitstring:", solution_list)
+
+    # Draw the graph representing the first bitstring in the solution_list to the MaxCut-like problem
+    head_bitstring = solution_list[0]
+
+    node_cut = [
+        "blue" if head_bitstring[node] == "1" else "red" for node in graph
+    ]
+
+    edge_cut = [
+        "solid"
+        if head_bitstring[node_row] == head_bitstring[node_col] else "dashed"
+        for node_row, node_col in graph.edges()
+    ]
+
+    pos = networkx.circular_layout(graph)
+
+    pyplot.figure(0)
+    networkx.draw(graph, pos, width=4, with_labels=True, font_weight="bold")
+
+    # when N is large, it is not suggested to plot this figure
+    pyplot.figure(1)
+    name_list = [binary_repr(index, width=N) for index in range(0, 2**N)]
+    pyplot.bar(
+        range(len(real(measure_prob_distribution))),
+        real(measure_prob_distribution),
+        width=0.7,
+        tick_label=name_list, )
+    pyplot.xticks(rotation=90)
+
+    pyplot.figure(2)
+    networkx.draw(
+        graph,
+        pos,
+        node_color=node_cut,
+        style=edge_cut,
+        width=4,
+        with_labels=True,
+        font_weight="bold", )
+    pyplot.show()
+
+
+def generate_graph(N, GRAPHMETHOD):
+    """
+    This function offers two methods to generate a graph.
+
+    Args:
+        N: number of nodes (vertices) in the graph, which is also the number of qubits
+        GRAPHMETHOD: which method to generate a graph
+    Return:
+        graph description and its adjacency matrix
+    """
+    # Method 1 generates a graph by self-definition. Note that the node label starts from 0 to N-1, while the edges
+    # could be attributed to weights additionally. If no specific rules are given, then all weights are set to 1.
+    if GRAPHMETHOD == 1:
+        print(
+            "Method 1 generates the graph from self-definition using EDGE description"
+        )
+        graph = networkx.Graph()
+        graph_nodelist = range(N)
+        graph.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0)])
+        graph_adjacency = networkx.to_numpy_matrix(
+            graph, nodelist=graph_nodelist)
+    # Method 2 generates a graph by using its adjacency matrix directly
+    elif GRAPHMETHOD == 2:
+        print(
+            "Method 2 generates the graph from networks using adjacency matrix")
+        graph_adjacency = array(
+            [[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0]])
+        graph = networkx.Graph(graph_adjacency)
+    else:
+        print("Method doesn't exist ")
+
+    output_graph = graph
+    output_graph_adjacency = graph_adjacency
+
+    return output_graph, output_graph_adjacency
+
+
+def H_generator(N, adjacency_matrix):
+    """
+    This function generates the problem-based Hamiltonian, given the graph with its adjacency matrix description.
+
+    Args:
+        N: number of qubits, or number of nodes in the graph, or number of parameters in the classical problem
+        adjacency_matrix:  the adjacency matrix generated from the graph encoding the classical problem
+    Return:
+        H_graph: the problem-based Hamiltonian H generated from the graph_adjacency matrix for the given graph
+        H_graph_diag: the real part of the problem-based Hamiltonian H_graph
+    """
+
+    sigma_Z = array([[1, 0], [0, -1]])
+    H = zeros([2**N, 2**N])
+
+    for row in range(N):
+        for col in range(N):
+            if abs(adjacency_matrix[N - row - 1, N - col - 1]) and row < col:
+                identity_1 = diag(ones([2**row]))
+                identity_2 = diag(ones([2**(col - row - 1)]))
+                identity_3 = diag(ones([2**(N - col - 1)]))
+                H += adjacency_matrix[N - row - 1, N - col - 1] * kron(
+                    kron(
+                        kron(kron(identity_1, sigma_Z), identity_2), sigma_Z),
+                    identity_3, )
+
+    H_graph = H.astype("complex64")
+    H_graph_diag = diag(H_graph).real
+
+    return H_graph, H_graph_diag

paddle_quantum/QAOA/benchmark.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Benchmark
+"""
+from matplotlib import pyplot
+from numpy import max, min, load, ones
+from paddle_quantum.QAOA.QAOA_Prefunc import generate_graph, H_generator
+
+
+def benchmark_QAOA(classical_graph_adjacency=None, N=None):
+    """
+     This function benchmarks the performance of QAOA. Indeed, it compares its approximate solution obtained
+     from QAOA with predetermined parameters, such as iteration step = 120 and learning rate = 0.1, to the exact solution
+     to the classical problem.
+
+    """
+    # Generate the graph and its adjacency matrix from the classical problem, such as the Max-Cut problem
+    if all(var is None for var in (classical_graph_adjacency, N)):
+        N = 4
+        _, classical_graph_adjacency = generate_graph(N, 1)
+
+    # Compute the exact solution of the original problem to benchmark the performance of QAOA
+    _, H_problem_diag = H_generator(N, classical_graph_adjacency)
+
+    H_graph_max = max(H_problem_diag)
+    H_graph_min = min(H_problem_diag)
+    print('H_max:', H_graph_max, '  H_min:', H_graph_min)
+
+    # Load the data of QAOA
+    x1 = load('./output/summary_data.npz')
+
+    H_min = ones([len(x1['iter'])]) * H_graph_min
+
+    # Plot it
+    pyplot.figure(1)
+    loss_QAOA, = pyplot.plot(x1['iter'], x1['energy'], \
+                                        alpha=0.7, marker='', linestyle="--", linewidth=2, color='m')
+    benchmark, = pyplot.plot(
+        x1['iter'],
+        H_min,
+        alpha=0.7,
+        marker='',
+        linestyle=":",
+        linewidth=2,
+        color='b')
+    pyplot.xlabel('Number of iteration')
+    pyplot.ylabel('Performance of the loss function for QAOA')
+
+    pyplot.legend(
+        handles=[loss_QAOA, benchmark],
+        labels=[
+            r'Loss function $\left\langle {\psi \left( {\bf{\theta }} \right)} '
+            r'\right|H\left| {\psi \left( {\bf{\theta }} \right)} \right\rangle $',
+            'The benchmark result',
+        ],
+        loc='best')
+
+    # Show the picture
+    pyplot.show()
+
+
+def main():
+    """
+    main
+    """
+
+    benchmark_QAOA()
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/QAOA/example/main.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+main
+"""
+
+from paddle_quantum.QAOA.Paddle_QAOA import Paddle_QAOA
+from paddle_quantum.QAOA.QAOA_Prefunc import plot_graph, generate_graph
+
+# Random seed for optimizer
+SEED = 1
+
+
+def main(N=4):
+    """
+    QAOA Main
+    """
+
+    classical_graph, classical_graph_adjacency = generate_graph(N, 1)
+    print(classical_graph_adjacency)
+    prob_measure = Paddle_QAOA(classical_graph_adjacency)
+
+    # Flatten array[[]] to []
+    prob_measure = prob_measure.flatten()
+    # Plot it!
+    plot_graph(prob_measure, classical_graph, N)
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/QAOA/main.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+main
+"""
+
+from paddle_quantum.QAOA.Paddle_QAOA import Paddle_QAOA
+from paddle_quantum.QAOA.QAOA_Prefunc import plot_graph, generate_graph
+
+# Random seed for optimizer
+SEED = 1
+
+
+def main(N=4):
+    """
+    QAOA Main
+    """
+
+    classical_graph, classical_graph_adjacency = generate_graph(N, 1)
+    print(classical_graph_adjacency)
+    prob_measure = Paddle_QAOA(classical_graph_adjacency)
+
+    # Flatten array[[]] to []
+    prob_measure = prob_measure.flatten()
+    # Plot it!
+    plot_graph(prob_measure, classical_graph, N)
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/SSVQE/HGenerator.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+HGenerator
+"""
+
+from numpy import array, kron
+
+__all__ = ["H_generator"]
+
+
+def H_generator():
+    """
+    Generate a Hamiltonian with trivial descriptions
+    Returns: A Hamiltonian
+
+    """
+    sigma_I = array([[1, 0], [0, 1]])
+    sigma_X = array([[0, 1], [1, 0]])
+    sigma_Y = array([[0, -1j], [1j, 0]])
+    sigma_Z = array([[1, 0], [0, -1]])
+    H = 0.4 * kron(sigma_Z, sigma_I) + 0.4 * kron(
+        sigma_I, sigma_Z) + 0.2 * kron(sigma_X, sigma_X)
+    # H = numpy.diag([0.1, 0.2, 0.3, 0.4])
+    return H.astype('complex64')

paddle_quantum/SSVQE/Paddle_SSVQE.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Paddle_SSVQE: To learn more about the functions and properties of this application,
+you could check the corresponding Jupyter notebook under the Tutorial folder.
+"""
+import numpy
+from paddle.complex import matmul, transpose
+from paddle import fluid
+from paddle_quantum.circuit import UAnsatz
+
+SEED = 1
+
+__all__ = [
+    "U_theta",
+    "Net",
+    "Paddle_SSVQE",
+]
+
+
+# definition of U_theta
+def U_theta(theta, N):
+    """
+    U_theta
+    """
+
+    cir = UAnsatz(N)
+    # ============== D1=2 ==============
+    cir.ry(theta[0], 2)
+    cir.rz(theta[1], 2)
+    cir.cnot([2, 1])
+    cir.ry(theta[2], 2)
+    cir.rz(theta[3], 2)
+    cir.cnot([2, 1])
+
+    # ============== D2=2 ==============
+    cir.ry(theta[4], 1)
+    cir.ry(theta[5], 2)
+    cir.rz(theta[6], 1)
+    cir.rz(theta[7], 2)
+    cir.cnot([1, 2])
+
+    cir.ry(theta[8], 1)
+    cir.ry(theta[9], 2)
+    cir.rz(theta[10], 1)
+    cir.rz(theta[11], 2)
+    cir.cnot([1, 2])
+
+    return cir.state
+
+
+class Net(fluid.dygraph.Layer):
+    """
+    Construct the model net
+    """
+
+    def __init__(self,
+                 shape,
+                 param_attr=fluid.initializer.Uniform(
+                     low=0.0, high=2 * numpy.pi, seed=SEED),
+                 dtype='float32'):
+        super(Net, self).__init__()
+
+        self.theta = self.create_parameter(
+            shape=shape, attr=param_attr, dtype=dtype, is_bias=False)
+
+    def forward(self, H, N):
+        """
+        Args:
+            input_state: The initial state with default |0..>
+            H: The target Hamiltonian
+        Returns:
+            The loss.
+        """
+        out_state = U_theta(self.theta, N)
+
+        loss_struct = matmul(
+            matmul(
+                transpose(
+                    fluid.framework.ComplexVariable(out_state.real,
+                                                    -out_state.imag),
+                    perm=[1, 0]),
+                H),
+            out_state).real
+
+        loss_components = [
+            loss_struct[0][0], loss_struct[1][1], loss_struct[2][2],
+            loss_struct[3][3]
+        ]
+
+        loss = 4 * loss_components[0] + 3 * loss_components[
+            1] + 2 * loss_components[2] + 1 * loss_components[3]
+        return loss, loss_components
+
+
+def Paddle_SSVQE(H, N=2, THETA_SIZE=12, ITR=60, LR=0.2):
+    """
+       main
+       """
+    with fluid.dygraph.guard():
+        # Harmiltonian preparing
+        H = fluid.dygraph.to_variable(H)
+
+        # net
+        net = Net(shape=[THETA_SIZE])
+
+        # optimizer
+        opt = fluid.optimizer.AdagradOptimizer(
+            learning_rate=LR, parameter_list=net.parameters())
+
+        # gradient descent loop
+        for itr in range(1, ITR + 1):
+            loss, loss_components = net(H, N)
+
+            loss.backward()
+            opt.minimize(loss)
+            net.clear_gradients()
+
+            print('iter:', itr, 'loss:', '%.4f' % loss.numpy()[0])
+
+        return loss_components

paddle_quantum/SSVQE/example/main.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+main
+"""
+
+import numpy
+from paddle_quantum.SSVQE.HGenerator import H_generator
+from paddle_quantum.SSVQE.Paddle_SSVQE import Paddle_SSVQE
+
+
+def main():
+    """
+    main
+    """
+    hamiltonian = H_generator()
+    loss_components = Paddle_SSVQE(hamiltonian)
+
+    print('The estimated ground state energy is: ', loss_components[0].numpy())
+    print('The estimated 1st excited state energy is: ',
+          loss_components[1].numpy())
+    print('The estimated 2nd excited state energy is: ',
+          loss_components[2].numpy())
+    print('The estimated 3rd excited state energy is: ',
+          loss_components[3].numpy())
+    print('The theoretical ground state energy: ',
+          numpy.linalg.eigh(hamiltonian)[0][0])
+    print('The theoretical 1st excited state energy: ',
+          numpy.linalg.eigh(hamiltonian)[0][1])
+    print('The theoretical 2nd excited state energy: ',
+          numpy.linalg.eigh(hamiltonian)[0][2])
+    print('The theoretical 3rd excited state energy: ',
+          numpy.linalg.eigh(hamiltonian)[0][3])
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/SSVQE/main.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+main
+"""
+
+import numpy
+from paddle_quantum.SSVQE.HGenerator import H_generator
+from paddle_quantum.SSVQE.Paddle_SSVQE import Paddle_SSVQE
+
+
+def main():
+    """
+    main
+    """
+
+    hamiltonian = H_generator()
+    loss_components = Paddle_SSVQE(hamiltonian)
+
+    print('The estimated ground state energy is: ', loss_components[0].numpy())
+    print('The estimated 1st excited state energy is: ',
+          loss_components[1].numpy())
+    print('The estimated 2nd excited state energy is: ',
+          loss_components[2].numpy())
+    print('The estimated 3rd excited state energy is: ',
+          loss_components[3].numpy())
+    print('The theoretical ground state energy: ',
+          numpy.linalg.eigh(hamiltonian)[0][0])
+    print('The theoretical 1st excited state energy: ',
+          numpy.linalg.eigh(hamiltonian)[0][1])
+    print('The theoretical 2nd excited state energy: ',
+          numpy.linalg.eigh(hamiltonian)[0][2])
+    print('The theoretical 3rd excited state energy: ',
+          numpy.linalg.eigh(hamiltonian)[0][3])
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/VQE/Paddle_VQE.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+VQE: To learn more about the functions and properties of this application,
+you could check the corresponding Jupyter notebook under the Tutorial folder.
+"""
+
+import os
+
+from numpy import concatenate
+from numpy import pi as PI
+from numpy import savez, zeros
+from paddle import fluid
+from paddle.complex import matmul, transpose
+
+from paddle_quantum.circuit import UAnsatz
+
+__all__ = [
+    "U_theta",
+    "StateNet",
+    "Paddle_VQE",
+]
+
+
+def U_theta(theta, input_state, N, D):
+    """
+    Circuit
+    """
+
+    cir = UAnsatz(N, input_state=input_state)
+    for i in range(N):
+        cir.rz(theta=theta[0][0][i], which_qubit=i + 1)
+        cir.ry(theta=theta[0][1][i], which_qubit=i + 1)
+        cir.rz(theta=theta[0][2][i], which_qubit=i + 1)
+
+    for repeat in range(D):
+        for i in range(1, N):
+            cir.cnot(control=[i, i + 1])
+
+        for i in range(N):
+            cir.ry(theta=theta[repeat][0][i], which_qubit=i + 1)
+            cir.ry(theta=theta[repeat][1][i], which_qubit=i + 1)
+            cir.rz(theta=theta[repeat][2][i], which_qubit=i + 1)
+
+    return cir.state
+
+
+class StateNet(fluid.dygraph.Layer):
+    """
+    Construct the model net
+    """
+
+    def __init__(
+            self,
+            shape,
+            param_attr=fluid.initializer.Uniform(
+                low=0.0, high=2 * PI),
+            dtype="float32", ):
+        super(StateNet, self).__init__()
+        self.theta = self.create_parameter(
+            shape=shape, attr=param_attr, dtype=dtype, is_bias=False)
+
+    def forward(self, input_state, H, N, D):
+        """
+        :param input_state: The initial state with default |0..>, 'mat'
+        :param H: The target Hamiltonian, 'mat'
+        :return: The loss, 'float'
+        """
+
+        out_state = U_theta(self.theta, input_state, N, D)
+        loss = matmul(
+            matmul(out_state, H),
+            transpose(
+                fluid.framework.ComplexVariable(out_state.real,
+                                                -out_state.imag),
+                perm=[1, 0], ), )
+
+        return loss.real
+
+
+def Paddle_VQE(Hamiltonian, N, D=1, ITR=120, LR=0.15):
+    """
+        Main Learning network using dynamic graph
+        :return: Plot or No return
+    """
+    with fluid.dygraph.guard():
+        # initial state preparing
+        _initial_state_np = concatenate(
+            ([[1.0]], zeros([1, 2**N - 1])), axis=1).astype("complex64")
+        initial_state = fluid.dygraph.to_variable(_initial_state_np)
+
+        # Store H
+        H = fluid.dygraph.to_variable(Hamiltonian)
+
+        # net
+        net = StateNet(shape=[D + 1, 3, N])
+
+        # optimizer
+        opt = fluid.optimizer.AdamOptimizer(
+            learning_rate=LR, parameter_list=net.parameters())
+
+        # gradient descent loop
+        summary_iter, summary_loss = [], []
+        for itr in range(1, ITR + 1):
+            # forward calc, loss
+            loss = net(initial_state, H, N, D)
+
+            # backward calculation for gradient value
+            loss.backward()
+            # using gradients to update the variable theta
+            opt.minimize(loss)
+            # clear gradients
+            net.clear_gradients()
+
+            summary_loss.append(loss[0][0].numpy())
+            summary_iter.append(itr)
+
+            print("iter:", itr, "loss:", "%.4f" % loss.numpy())
+            print("iter:", itr, "Ground state energy:",
+                  "%.4f Ha" % loss.numpy())
+            # print('theta:', net.parameters()[0].numpy())
+
+        os.makedirs("output", exist_ok=True)
+        savez("./output/summary_data", iter=summary_iter, energy=summary_loss)
+
+
+def main():
+    """
+    :return:
+    """
+
+
+if __name__ == "__main__":
+    main()

paddle_quantum/VQE/benchmark.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+benchmark the result
+"""
+
+import platform
+
+import matplotlib.pyplot as plt
+import numpy
+from paddle_quantum.VQE.chemistrysub import H2_generator
+
+
+def benchmark_result():
+    """
+    benchmark using numpy
+    """
+
+    # Read H and calc using numpy
+    sysStr = platform.system()
+    if sysStr == 'Windows':
+        #  Windows does not support SCF, using H2_generator instead
+        print('Molecule data will be read from built-in function')
+        _H, _, _ = H2_generator()
+        print('Read Process Finished')
+    elif sysStr == 'Linux' or sysStr == 'Darwin':
+        # for linux only
+        from paddle_quantum.VQE.chemistrygen import read_calc_H
+        # Harmiltonian and cnot module preparing, must be executed under Linux
+        # Read the H2 molecule data
+        print('Molecule data will be read from h2.xyz')
+        _H, _, _ = read_calc_H(geo_fn='h2.xyz')
+        print('Read Process Finished')
+    else:
+        print("Don't support this os.")
+
+    # plot
+    x1 = numpy.load('./output/summary_data.npz')
+
+    eig_val, eig_state = numpy.linalg.eig(_H)
+    min_eig_H = numpy.min(eig_val)
+    min_loss = numpy.ones([len(x1['iter'])]) * min_eig_H
+
+    plt.figure(1)
+    func1, = plt.plot(
+        x1['iter'],
+        x1['energy'],
+        alpha=0.7,
+        marker='',
+        linestyle="--",
+        color='m')
+    func_min, = plt.plot(
+        x1['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( {\bf{\theta }} \right)} '
+            r'\right|H\left| {\psi \left( {\bf{\theta }} \right)} \right\rangle $',
+            'Minimum energy',
+        ],
+        loc='best')
+
+    # output the picture
+    plt.show()
+
+
+def main():
+    """
+    Call the real benchmark function
+    """
+
+    benchmark_result()
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/VQE/chemistrygen.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+chemistry
+"""
+
+from numpy import array, kron, trace
+import openfermion
+import openfermionpyscf
+import scipy
+import scipy.linalg
+
+__all__ = [
+    "calc_H_rho_from_qubit_operator",
+    "read_calc_H",
+]
+
+
+def calc_H_rho_from_qubit_operator(qubit_op, n_qubits):
+    """
+    Generate a Hamiltonian from QubitOperator
+    Returns: H, rho
+    """
+
+    # const
+    beta = 1
+
+    sigma_table = {
+        'I': array([[1, 0], [0, 1]]),
+        'Z': array([[1, 0], [0, -1]]),
+        'X': array([[0, 1], [1, 0]]),
+        'Y': array([[0, -1j], [1j, 0]])
+    }
+
+    # calc Hamiltonian
+    H = 0
+    for terms, h in qubit_op.terms.items():
+        basis_list = ['I'] * n_qubits
+        for index, action in terms:
+            basis_list[index] = action
+
+        for sigma_symbol in basis_list:
+            b = sigma_table.get(sigma_symbol, None)
+            if b is None:
+                raise Exception('unrecognized basis')
+            h = kron(h, b)
+
+        H = H + h
+
+    # calc rho
+    rho = scipy.linalg.expm(-1 * beta *
+                            H) / trace(scipy.linalg.expm(-1 * beta * H))
+
+    return H.astype('complex64'), rho.astype(
+        'complex64')  # the returned dic will have 2 ** n value
+
+
+def read_calc_H(geo_fn, multiplicity=1, charge=0):
+    """
+    Read and calc the H and rho
+    return: H,rho matrix
+    """
+
+    if not isinstance(geo_fn, str):  # geo_fn = 'h2.xyz'
+        raise Exception('filename is a string')
+
+    geo = []
+
+    with open(geo_fn) as f:
+        f.readline()
+        f.readline()
+
+        for line in f:
+            species, x, y, z = line.split()
+            geo.append([species, (float(x), float(y), float(z))])
+
+    # meanfield data
+    mol = openfermion.hamiltonians.MolecularData(geo, 'sto-3g', multiplicity,
+                                                 charge)
+    openfermionpyscf.run_pyscf(mol)
+
+    
+    terms_molecular_hamiltonian = mol.get_molecular_hamiltonian(
+    )
+    fermionic_hamiltonian = openfermion.transforms.get_fermion_operator(
+        terms_molecular_hamiltonian)
+    qubit_op = openfermion.transforms.jordan_wigner(
+        fermionic_hamiltonian)
+
+
+    # calc H, rho
+    H, rho = calc_H_rho_from_qubit_operator(qubit_op, mol.n_qubits)
+    return H, rho, mol.n_qubits
+
+
+def main():
+    """
+    The main function
+    Returns:
+    """
+
+    filename = 'h2.xyz'
+    H, rho, N = read_calc_H(geo_fn=filename)
+    print('H', H)
+    print("--------------------------  ")
+    print('rho', rho)
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/VQE/chemistrysub.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Using a H generator to define the H under WINDOWS
+"""
+
+from numpy import array, kron, trace
+import scipy
+
+__all__ = [
+    "H_generator",
+    "H2_generator",
+]
+
+
+def H_generator():
+    """
+    Generate a Hamiltonian with trivial descriptions
+    :return: a Hamiltonian, 'mat'
+    """
+
+    beta = 1
+    sigma_I = array([[1, 0], [0, 1]])
+    sigma_Z = array([[1, 0], [0, -1]])
+    sigma_X = array([[0, 1], [1, 0]])
+    sigma_Y = array([[0, -1j], [1j, 0]])
+    # H = kron(kron(sigma_X, sigma_I), sigma_X) + 0.9 * kron(kron(sigma_Z, sigma_I), sigma_I) \
+    #     - 0.3 * kron(kron(sigma_I, sigma_I), sigma_Y)
+    H = 0.4 * kron(sigma_Z, sigma_I) + 0.4 * kron(
+        sigma_I, sigma_Z) + 0.2 * kron(sigma_X, sigma_X)
+    rho = scipy.linalg.expm(-1 * beta *
+                            H) / trace(scipy.linalg.expm(-1 * beta * H))
+    return H.astype('complex64'), rho.astype('complex64')
+
+
+def H2_generator():
+    """
+    Generate a Hamiltonian with trivial descriptions
+    Returns: A Hamiltonian, 'mat'
+    """
+
+    beta = 1
+    sigma_I = array([[1, 0], [0, 1]])
+    sigma_Z = array([[1, 0], [0, -1]])
+    sigma_X = array([[0, 1], [1, 0]])
+    sigma_Y = array([[0, -1j], [1j, 0]])
+    H = (-0.04207897647782276) * kron(kron(kron(sigma_I, sigma_I), sigma_I), sigma_I) \
+        + (0.17771287465139946) * kron(kron(kron(sigma_Z, sigma_I), sigma_I), sigma_I) \
+        + (0.1777128746513994) * kron(kron(kron(sigma_I, sigma_Z), sigma_I), sigma_I) \
+        + (-0.24274280513140462) * kron(kron(kron(sigma_I, sigma_I), sigma_Z), sigma_I) \
+        + (-0.24274280513140462) * kron(kron(kron(sigma_I, sigma_I), sigma_I), sigma_Z) \
+        + (0.17059738328801052) * kron(kron(kron(sigma_Z, sigma_Z), sigma_I), sigma_I) \
+        + (0.04475014401535161) * kron(kron(kron(sigma_Y, sigma_X), sigma_X), sigma_Y) \
+        + (-0.04475014401535161) * kron(kron(kron(sigma_Y, sigma_Y), sigma_X), sigma_X) \
+        + (-0.04475014401535161) * kron(kron(kron(sigma_X, sigma_X), sigma_Y), sigma_Y) \
+        + (0.04475014401535161) * kron(kron(kron(sigma_X, sigma_Y), sigma_Y), sigma_X) \
+        + (0.12293305056183798) * kron(kron(kron(sigma_Z, sigma_I), sigma_Z), sigma_I) \
+        + (0.1676831945771896) * kron(kron(kron(sigma_Z, sigma_I), sigma_I), sigma_Z) \
+        + (0.1676831945771896) * kron(kron(kron(sigma_I, sigma_Z), sigma_Z), sigma_I) \
+        + (0.12293305056183798) * kron(kron(kron(sigma_I, sigma_Z), sigma_I), sigma_Z) \
+        + (0.17627640804319591) * kron(kron(kron(sigma_I, sigma_I), sigma_Z), sigma_Z)
+    rho = scipy.linalg.expm(-1 * beta *
+                            H) / trace(scipy.linalg.expm(-1 * beta * H))
+    N = 4
+    return H.astype('complex64'), rho.astype('complex64'), N

paddle_quantum/VQE/example/h2.xyz

+2
+in Angstrom
+H          0.00000        0.00000       -0.35000
+H          0.00000        0.00000        0.35000

paddle_quantum/VQE/example/main.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+main
+"""
+
+import platform
+
+from paddle_quantum.VQE.Paddle_VQE import Paddle_VQE
+from paddle_quantum.VQE.benchmark import benchmark_result
+from paddle_quantum.VQE.chemistrysub import H2_generator
+
+
+def main():
+    """
+    Main Learning network using dynamic graph
+    :return: Plot or No return
+    """
+
+    # Read data from built-in function or xyz file depending on OS
+    sysStr = platform.system()
+    if sysStr == 'Windows':
+        #  Windows does not support SCF, using H2_generator instead
+        print('Molecule data will be read from built-in function')
+        _H, _, N = H2_generator()
+        print('Read Process Finished')
+
+    elif sysStr in ('Linux', 'Darwin'):
+        # for linux only
+        from paddle_quantum.VQE.chemistrygen import read_calc_H
+        # Harmiltonian and cnot module preparing, must be executed under Linux
+        # Read the H2 molecule data
+        print('Molecule data will be read from h2.xyz')
+        _H, _, N = read_calc_H(geo_fn='h2.xyz')
+        print('Read Process Finished')
+
+    else:
+        print("Don't support this OS.")
+
+    Paddle_VQE(_H, N)
+    benchmark_result()
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/VQE/h2.xyz

+2
+in Angstrom
+H          0.00000        0.00000       -0.35000
+H          0.00000        0.00000        0.35000

paddle_quantum/VQE/main.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+main
+"""
+
+import platform
+
+from paddle_quantum.VQE.Paddle_VQE import Paddle_VQE
+from paddle_quantum.VQE.benchmark import benchmark_result
+from paddle_quantum.VQE.chemistrysub import H2_generator
+
+
+def main():
+    """
+    Main Learning network using dynamic graph
+    :return: Plot or No return
+    """
+    # Read data from built-in function or xyz file depending on OS
+    sysStr = platform.system()
+
+    if sysStr == 'Windows':
+        #  Windows does not support SCF, using H2_generator instead
+        print('Molecule data will be read from built-in function')
+        hamiltonian, _, N = H2_generator()
+        print('Read Process Finished')
+
+    elif sysStr in ('Linux', 'Darwin'):
+        # for linux only
+        from paddle_quantum.VQE.chemistrygen import read_calc_H
+        # Hamiltonian and cnot module preparing, must be executed under Linux
+        # Read the H2 molecule data
+        print('Molecule data will be read from h2.xyz')
+        hamiltonian, _, N = read_calc_H(geo_fn='h2.xyz')
+        print('Read Process Finished')
+
+    else:
+        print("Don't support this OS.")
+
+    Paddle_VQE(hamiltonian, N, D=2, LR=0.1)
+    benchmark_result()
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/VQSD/HGenerator.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+HGenerator
+"""
+
+from numpy import diag
+import scipy
+
+SEED = 1
+
+__all__ = ["generate_rho_sigma", ]
+
+
+def generate_rho_sigma():
+    # V is a 4x4 random Unitary
+    scipy.random.seed(SEED)
+    V = scipy.stats.unitary_group.rvs(4)
+    # generate rho
+    D = diag([0.1, 0.2, 0.3, 0.4])
+    sigma = diag([0.4, 0.3, 0.2, 0.1])
+    V_H = V.conj().T
+    rho = V @D @V_H
+
+    return rho.astype('complex64'), sigma.astype('complex64')

paddle_quantum/VQSD/Paddle_VQSD.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Paddle_VQSD: To learn more about the functions and properties of this application,
+you could check the corresponding Jupyter notebook under the Tutorial folder.
+"""
+
+import numpy
+
+from paddle import fluid
+from paddle_quantum.circuit import UAnsatz
+from paddle.complex import matmul, trace, transpose
+
+SEED = 1
+
+__all__ = [
+    "U_theta",
+    "Net",
+    "Paddle_VQSD",
+]
+
+
+# definition of U_theta
+def U_theta(theta, N):
+    """
+    U_theta
+    """
+
+    cir = UAnsatz(N)
+    cir.rz(theta[0], 1)
+    cir.ry(theta[1], 1)
+    cir.rz(theta[2], 1)
+
+    cir.rz(theta[3], 2)
+    cir.ry(theta[4], 2)
+    cir.rz(theta[5], 2)
+
+    cir.cnot([2, 1])
+
+    cir.rz(theta[6], 1)
+    cir.ry(theta[7], 2)
+
+    cir.cnot([1, 2])
+
+    cir.rz(theta[8], 1)
+    cir.ry(theta[9], 1)
+    cir.rz(theta[10], 1)
+
+    cir.rz(theta[11], 2)
+    cir.ry(theta[12], 2)
+    cir.rz(theta[13], 2)
+
+    return cir.state
+
+
+class Net(fluid.dygraph.Layer):
+    """
+    Construct the model net
+    """
+
+    def __init__(self,
+                 shape,
+                 rho,
+                 sigma,
+                 param_attr=fluid.initializer.Uniform(
+                     low=0.0, high=2 * numpy.pi, seed=SEED),
+                 dtype='float32'):
+        super(Net, self).__init__()
+
+        self.rho = fluid.dygraph.to_variable(rho)
+        self.sigma = fluid.dygraph.to_variable(sigma)
+
+        self.theta = self.create_parameter(
+            shape=shape, attr=param_attr, dtype=dtype, is_bias=False)
+
+    def forward(self, N):
+        """
+        Args:
+        Returns:
+            The loss.
+        """
+
+        out_state = U_theta(self.theta, N)
+
+        # rho_tilde is what you get after you put self.rho through the circuit
+        rho_tilde = matmul(
+            matmul(out_state, self.rho),
+            transpose(
+                fluid.framework.ComplexVariable(out_state.real,
+                                                -out_state.imag),
+                perm=[1, 0]))
+
+        # record the new loss
+        loss = trace(matmul(self.sigma, rho_tilde))
+
+        return loss.real, rho_tilde
+
+
+def Paddle_VQSD(rho, sigma, N=2, THETA_SIZE=14, ITR=50, LR=0.1):
+    """
+    Paddle_VQSD
+    """
+
+    with fluid.dygraph.guard():
+        # net
+        net = Net(shape=[THETA_SIZE], rho=rho, sigma=sigma)
+
+        # optimizer
+        opt = fluid.optimizer.AdagradOptimizer(
+            learning_rate=LR, parameter_list=net.parameters())
+        # gradient descent loop
+        for itr in range(ITR):
+            loss, rho_tilde = net(N)
+
+            rho_tilde_np = rho_tilde.numpy()
+            loss.backward()
+            opt.minimize(loss)
+            net.clear_gradients()
+
+            print('iter:', itr, 'loss:', '%.4f' % loss.numpy()[0])
+
+    return rho_tilde_np

paddle_quantum/VQSD/example/main.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Main
+"""
+
+import numpy
+from paddle_quantum.VQSD.HGenerator import generate_rho_sigma
+from paddle_quantum.VQSD.Paddle_VQSD import Paddle_VQSD
+
+
+def main():
+    """
+    Main
+    :return:
+    """
+
+    rho, sigma = generate_rho_sigma()
+    rho_tilde_np = Paddle_VQSD(rho, sigma)
+    print('spectrum:', numpy.real(numpy.diag(rho_tilde_np)))
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/VQSD/main.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+main
+"""
+
+import numpy
+from paddle_quantum.VQSD.HGenerator import generate_rho_sigma
+from paddle_quantum.VQSD.Paddle_VQSD import Paddle_VQSD
+
+
+def main():
+    rho, sigma = generate_rho_sigma()
+    rho_tilde_np = Paddle_VQSD(rho, sigma)
+    print('spectrum:', numpy.real(numpy.diag(rho_tilde_np)))
+
+
+if __name__ == '__main__':
+    main()

paddle_quantum/__init__.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Paddle Quantum Library
+"""

paddle_quantum/circuit.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+circuit
+"""
+
+from numpy import binary_repr, eye, identity
+
+from paddle.complex import kron as pp_kron
+from paddle.complex import matmul
+
+from paddle.fluid import dygraph
+
+from paddle_quantum.utils import rotation_x, rotation_y, rotation_z
+
+__all__ = [
+    "dic_between2and10",
+    "base_2_change",
+    "cnot_construct",
+    "identity_generator",
+    "single_gate_construct",
+    "UAnsatz",
+]
+
+
+def dic_between2and10(n):
+    """
+    :param n: number of qubits
+    :return: dictionary between binary and decimal
+
+    for example: if n=3, the dictionary is
+    dic2to10: {'000': 0, '011': 3, '010': 2, '111': 7, '100': 4, '101': 5, '110': 6, '001': 1}
+    dic10to2: ['000', '001', '010', '011', '100', '101', '110', '111']
+    """
+
+    dic2to10 = {}
+    dic10to2 = [None] * 2**n
+
+    for i in range(2**n):
+        binary_text = binary_repr(i, width=n)
+        dic2to10[binary_text] = i
+        dic10to2[i] = binary_text
+
+    return dic2to10, dic10to2  # the returned dic will have 2 ** n value
+
+
+def base_2_change(string_n, i_ctrl, j_target):
+    """
+    :param string_n: an n-bit string
+    :param i_ctrl: i-th bit is control, 'int'
+    :param j_target: j-th bit is target, 'int'
+    :return: if i-th bit is 1, j-th bit takes inverse
+    """
+
+    string_n_list = list(string_n)
+    if string_n_list[i_ctrl] == "1":
+        string_n_list[j_target] = str((int(string_n_list[j_target]) + 1) % 2)
+    return "".join(string_n_list)
+
+
+def cnot_construct(n, ctrl):
+    """
+    cnot_construct: The controlled-NOT gate
+    :param n: number of qubits
+    :param ctrl: a shape [2] vector, in 'int' type. ctrl[0]-th qubit controls the ctrl[1]-qubit
+    :return: cnot module
+    """
+
+    mat = eye(2**n)
+    dummy_mat = eye(2**n)
+    dic2to10, dic10to2 = dic_between2and10(n)
+    """ for example: if n=3, the dictionary is
+    dic2to10: {'000': 0, '011': 3, '010': 2, '111': 7, '100': 4, '101': 5, '110': 6, '001': 1}
+    dic10to2: ['000', '001', '010', '011', '100', '101', '110', '111']
+    """
+
+    for row in range(2**n):
+        """ for each decimal index 'row', transform it into binary,
+            and use 'base_2_change()' function to compute the new binary index 'row'.
+            Lastly, use 'dic2to10' to transform this new 'row' into decimal.
+
+            For instance, n=3, ctrl=[1,3]. if row = 5,
+            its process is 5 -> '101' -> '100' -> 4
+        """
+        new_string_base_2 = base_2_change(dic10to2[row], ctrl[0] - 1,
+                                          ctrl[1] - 1)
+        new_int_base_10 = dic2to10[new_string_base_2]
+        mat[row] = dummy_mat[new_int_base_10]
+
+    return mat.astype("complex64")
+
+
+def identity_generator(n):
+    """
+    identity_generator
+    """
+
+    idty_np = identity(2**n, dtype="float32")
+    idty = dygraph.to_variable(idty_np)
+
+    return idty
+
+
+def single_gate_construct(mat, n, which_qubit):
+    """
+    :param mat: the input matrix
+    :param n: number of qubits
+    :param which_qubit: indicate which qubit the matrix is placed on
+    :return: the kronecker product of the matrix and identity
+    """
+
+    idty = identity_generator(n - 1)
+
+    if which_qubit == 1:
+        mat = pp_kron(mat, idty)
+
+    elif which_qubit == n:
+        mat = pp_kron(idty, mat)
+
+    else:
+        I_top = identity_generator(which_qubit - 1)
+        I_bot = identity_generator(n - which_qubit)
+        mat = pp_kron(pp_kron(I_top, mat), I_bot)
+
+    return mat
+
+
+class UAnsatz:
+    """
+    UAnsatz: ansatz for the parameterized quantum circuit or quantum neural network.
+    """
+
+    def __init__(self, n, input_state=None):
+        """
+        :param input_state: if the input_state is 'None', the self.mat is a matrix,
+                            if the input_state is a row complex vector, the self.mat is a row vector
+        """
+
+        self.n = n
+        self.state = input_state if input_state is not None else identity_generator(
+            self.n)
+
+    def rx(self, theta, which_qubit):
+        """
+        Rx: the single qubit X rotation
+        """
+
+        transform = single_gate_construct(
+            rotation_x(theta), self.n, which_qubit)
+        self.state = matmul(self.state, transform)
+
+    def ry(self, theta, which_qubit):
+        """
+        Ry: the single qubit Y rotation
+        """
+
+        transform = single_gate_construct(
+            rotation_y(theta), self.n, which_qubit)
+        self.state = matmul(self.state, transform)
+
+    def rz(self, theta, which_qubit):
+        """
+        Rz: the single qubit Z rotation
+        """
+
+        transform = single_gate_construct(
+            rotation_z(theta), self.n, which_qubit)
+        self.state = matmul(self.state, transform)
+
+    def cnot(self, control):
+        """
+        :param control: [1,3], the 1st qubit controls 3rd qubit
+        :return: cnot module
+        """
+
+        cnot = dygraph.to_variable(cnot_construct(self.n, control))
+        self.state = matmul(self.state, cnot)

paddle_quantum/utils.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+function
+"""
+
+from functools import reduce
+
+from numpy import diag, dot, identity
+from numpy import kron as np_kron
+from numpy import linalg, sqrt
+from numpy import sum as np_sum
+from numpy import transpose as np_transpose
+from numpy import zeros as np_zeros
+
+from paddle.complex import elementwise_add
+from paddle.complex import kron as pp_kron
+from paddle.complex import matmul
+from paddle.complex import transpose as pp_transpose
+
+from paddle.fluid.dygraph import to_variable
+from paddle.fluid.framework import ComplexVariable
+from paddle.fluid.layers import concat, cos, ones, reshape, sin
+from paddle.fluid.layers import zeros as pp_zeros
+
+__all__ = [
+    "rotation_x",
+    "rotation_y",
+    "rotation_z",
+    "partial_trace",
+    "compute_fid",
+    "NKron",
+]
+
+
+def rotation_x(theta):
+    """
+    :param theta: must be a scale, shape [1], 'float32'
+    :return:
+    """
+
+    cos_value = cos(theta/2)
+    sin_value = sin(theta/2)
+    zero_pd = pp_zeros([1], "float32")
+    rx_re = concat([cos_value, zero_pd, zero_pd, cos_value], axis=0)
+    rx_im = concat([zero_pd, -sin_value, -sin_value, zero_pd], axis=0)
+
+    return ComplexVariable(reshape(rx_re, [2, 2]), reshape(rx_im, [2, 2]))
+
+
+def rotation_y(theta):
+    """
+    :param theta: must be a scale, shape [1], 'float32'
+    :return:
+    """
+
+    cos_value = cos(theta/2)
+    sin_value = sin(theta/2)
+    ry_re = concat([cos_value, -sin_value, sin_value, cos_value], axis=0)
+    ry_im = pp_zeros([2, 2], "float32")
+    return ComplexVariable(reshape(ry_re, [2, 2]), ry_im)
+
+
+def rotation_z(theta):
+    """
+    :param theta: must be a scale, shape [1], 'float32'
+    :return:
+    """
+
+    cos_value = cos(theta/2)
+    sin_value = sin(theta/2)
+    zero_pd = pp_zeros([1], "float32")
+    rz_re = concat([cos_value, zero_pd, zero_pd, cos_value], axis=0)
+    rz_im = concat([-sin_value, zero_pd, zero_pd, sin_value], axis=0)
+
+    return ComplexVariable(reshape(rz_re, [2, 2]), reshape(rz_im, [2, 2]))
+
+
+def partial_trace(rho_AB, dim1, dim2, A_or_B):
+    """
+    :param rho_AB: the input density matrix
+    :param dim1: dimension for system A
+    :param dim2: dimension for system B
+    :param A_or_B: 1 or 2, choose the system that you want trace out.
+    :return: partial trace
+    """
+
+    # dim_total = dim1 * dim2
+    if A_or_B == 2:
+        dim1, dim2 = dim2, dim1
+
+    idty_np = identity(dim2).astype("complex64")
+    idty_B = to_variable(idty_np)
+
+    zero_np = np_zeros([dim2, dim2], "complex64")
+    res = to_variable(zero_np)
+
+    for dim_j in range(dim1):
+        row_top = pp_zeros([1, dim_j], dtype="float32")
+        row_mid = ones([1, 1], dtype="float32")
+        row_bot = pp_zeros([1, dim1 - dim_j - 1], dtype="float32")
+        bra_j_re = concat([row_top, row_mid, row_bot], axis=1)
+        bra_j_im = pp_zeros([1, dim1], dtype="float32")
+        bra_j = ComplexVariable(bra_j_re, bra_j_im)
+
+        if A_or_B == 1:
+            row_tmp = pp_kron(bra_j, idty_B)
+            res = elementwise_add(
+                res,
+                matmul(
+                    matmul(row_tmp, rho_AB),
+                    pp_transpose(
+                        ComplexVariable(row_tmp.real, -row_tmp.imag),
+                        perm=[1, 0]), ), )
+
+        if A_or_B == 2:
+            row_tmp = pp_kron(idty_B, bra_j)
+            res += matmul(
+                matmul(row_tmp, rho_AB),
+                pp_transpose(
+                    ComplexVariable(row_tmp.real, -row_tmp.imag), perm=[1, 0]),
+            )
+    return res
+
+
+def compute_fid(rho, sigma):
+    """
+    compute_fid: compute the fidelity between two density operators
+    :param rho:
+    :param sigma:
+    :return:
+    """
+
+    rho_eigenval, rho_eigenmatrix = linalg.eig(rho)
+    sr_rho = dot(
+        dot(rho_eigenmatrix, diag(sqrt(rho_eigenval.real + 1e-7))),
+        np_transpose(rho_eigenmatrix).conjugate(), )
+    rho_sigma_rho = dot(dot(sr_rho, sigma), sr_rho)
+
+    return np_sum(sqrt(linalg.eigvals(rho_sigma_rho).real + 1e-7))
+
+
+def NKron(AMatrix, BMatrix, *args):
+    """
+    Recursively execute kron n times. This function at least has two matrices.
+    :param AMatrix: First matrix
+    :param BMatrix: Second matrix
+    :param args: If have more matrix, they are delivered by this matrix
+    :return: The result of tensor product.
+    """
+
+    return reduce(
+        lambda result, index: np_kron(result, index),
+        args,
+        np_kron(AMatrix, BMatrix), )

requirements.txt

+paddlepaddle>=1.8.0
+networkx
+matplotlib
\ No newline at end of file

setup.py

+# Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Install library to site-packages
+"""
+
+from setuptools import setup
+
+setup(
+    name='paddle_quantum',
+    version='1.0.0',
+    description='Paddle Quantum circuit and function',
+    author='Institute for Quantum Computing, Baidu INC.',
+    author_email='quantum@baidu.com',
+    url='http://quantum-hub.baidu.com',
+    packages=['paddle_quantum'],
+    install_requires=['paddlepaddle>=1.8.0', 'networkx', 'matplotlib'])

tools/copyright.hook

+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import argparse
+import io, re
+import sys, os
+import subprocess
+import platform
+
+COPYRIGHT = '''
+Copyright (c) 2020 Paddle Quantum Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+'''
+
+LANG_COMMENT_MARK = None
+
+NEW_LINE_MARK = None
+
+COPYRIGHT_HEADER = None
+
+if platform.system() == "Windows":
+    NEW_LINE_MARK = '\r\n'
+else:
+    NEW_LINE_MARK = '\n'
+    COPYRIGHT_HEADER = COPYRIGHT.split(NEW_LINE_MARK)[1]
+    p = re.search('(\d{4})', COPYRIGHT_HEADER).group(0)
+    process = subprocess.Popen(["date", "+%Y"], stdout=subprocess.PIPE)
+    date, err = process.communicate()
+    date = date.decode("utf-8").rstrip("\n")
+    COPYRIGHT_HEADER = COPYRIGHT_HEADER.replace(p, date)
+
+
+def generate_copyright(template, lang='C'):
+    if lang == 'Python':
+        LANG_COMMENT_MARK = "#"
+    else:
+        LANG_COMMENT_MARK = "//"
+
+    lines = template.split(NEW_LINE_MARK)
+    BLANK = " "
+    ans = LANG_COMMENT_MARK + BLANK + COPYRIGHT_HEADER + NEW_LINE_MARK
+    for lino, line in enumerate(lines):
+        if lino == 0 or lino == 1 or lino == len(lines) - 1: continue
+        if len(line)  == 0:
+            BLANK = ""
+        else:
+            BLANK = " "
+        ans += LANG_COMMENT_MARK + BLANK + line + NEW_LINE_MARK
+
+    return ans + "\n"
+
+
+def lang_type(filename):
+    if filename.endswith(".py"):
+        return "Python"
+    elif filename.endswith(".h"):
+        return "C"
+    elif filename.endswith(".c"):
+        return "C"
+    elif filename.endswith(".hpp"):
+        return "C"
+    elif filename.endswith(".cc"):
+        return "C"
+    elif filename.endswith(".cpp"):
+        return "C"
+    elif filename.endswith(".cu"):
+        return "C"
+    elif filename.endswith(".cuh"):
+        return "C"
+    elif filename.endswith(".go"):
+        return "C"
+    elif filename.endswith(".proto"):
+        return "C"
+    else:
+        print("Unsupported filetype %s", filename)
+        exit(0)
+
+
+PYTHON_ENCODE = re.compile("^[ \t\v]*#.*?coding[:=][ \t]*([-_.a-zA-Z0-9]+)")
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        description='Checker for copyright declaration.')
+    parser.add_argument('filenames', nargs='*', help='Filenames to check')
+    args = parser.parse_args(argv)
+
+    retv = 0
+    for filename in args.filenames:
+        fd = io.open(filename, encoding="utf-8")
+        first_line = fd.readline()
+        second_line = fd.readline()
+        if "COPYRIGHT (C)" in first_line.upper(): continue
+        if first_line.startswith("#!") or PYTHON_ENCODE.match(
+                second_line) != None or PYTHON_ENCODE.match(first_line) != None:
+            continue
+        original_contents = io.open(filename, encoding="utf-8").read()
+        new_contents = generate_copyright(
+            COPYRIGHT, lang_type(filename)) + original_contents
+        print('Auto Insert Copyright Header {}'.format(filename))
+        retv = 1
+        with io.open(filename, 'w') as output_file:
+            output_file.write(new_contents)
+
+    return retv
+
+
+if __name__ == '__main__':
+    exit(main())
\ No newline at end of file

tutorial/GIBBS.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 概览\n",
+    "- 在这个案例中，我们将展示如何通过Paddle Quantum训练量子神经网络来制备量子吉布斯态。\n",
+    "\n",
+    "- 首先，让我们通过下面几行代码引入必要的library和package。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from numpy import array, kron, concatenate, zeros\n",
+    "from numpy import pi as PI\n",
+    "from numpy import trace as nptrace\n",
+    "from paddle import fluid\n",
+    "from paddle.complex import matmul, transpose, trace\n",
+    "from paddle_quantum.circuit import UAnsatz\n",
+    "from paddle_quantum.utils import compute_fid, partial_trace\n",
+    "import scipy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## 背景\n",
+    "量子计算中的前沿方向是量子机器学习和量子优化，在这两个方向，特定量子态的制备是及其重要的问题。特别的，尤其是吉布斯态（Gibbs state）的制备是实现诸多量子算法所必须的一个步骤。\n",
+    "- 给定一个n量子位的哈密顿量H（一般来说这是一个$2^n\\times2^n$的厄米矩阵），其在温度$T$下的吉布斯态为$\\rho_G {\\rm{ = }}\\frac{{{e^{ - \\beta H}}}}{{tr({e^{ - \\beta H}})}}$\n",
+    "- 其中${e^{ - \\beta H}}$是矩阵$ - \\beta H$的矩阵指数，$\\beta  = \\frac{1}{{kT}}$是系统的逆温度参数，以及$T$是温度参数，$k$是玻尔兹曼常数(这个例子中我们取为$1$)。\n",
+    "\n",
+    "量子计算的诸多应用所需要调用的步骤都依赖于特定哈密顿量的吉布斯态，所以制备出目标哈密顿量的吉布斯态在量子计算和量子机器学习等方向都至关重要，尤其是有着广泛的应用，比如可以用于如下应用中：\n",
+    "- 量子机器学习中受限波尔兹曼机的学习 [1]\n",
+    "- 解决凸优化和半正定规划等优化问题 [2]\n",
+    "- 组合优化问题 [3]\n",
+    "\n",
+    "作为一个上手的例子，这里我们首先考虑一个简单的哈密顿量及其吉布斯态。\n",
+    "- 首先我们考虑的是3量子位的哈密顿量，\n",
+    "$H = Z \\otimes Z \\otimes I + I \\otimes Z \\otimes Z + Z \\otimes I \\otimes Z$,  \n",
+    "其中\n",
+    "$$\n",
+    "I=\\left [\n",
+    "\\begin{matrix}\n",
+    "1 & 0  \\\\\n",
+    "0 & 1  \\\\\n",
+    "\\end{matrix} \n",
+    "\\right ], \\quad \n",
+    "Z=\\left [\n",
+    "\\begin{matrix}\n",
+    "1 & 0  \\\\\n",
+    "0 & -1  \\\\\n",
+    "\\end{matrix} \n",
+    "\\right ].\n",
+    "$$\n",
+    "\n",
+    "- 这个例子中，我们将逆温度参数设置为$\\beta = 1.5$。\n",
+    "\n",
+    "- 此外，为了方便测试结果，我们利用定义提前生成好了理想情况的吉布斯态。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "beta = 1.5\n",
+    "\n",
+    "sigma_I = array([[1, 0], [0, 1]])\n",
+    "sigma_Z = array([[1, 0], [0, -1]])\n",
+    "hamiltonian = (-kron(kron(sigma_Z, sigma_Z), sigma_I) - kron(kron(sigma_I, sigma_Z), sigma_Z) - kron(kron(sigma_Z, sigma_I), sigma_Z))\n",
+    "rho = scipy.linalg.expm(-1 * beta * hamiltonian) / nptrace(scipy.linalg.expm(-1 * beta * hamiltonian))\n",
+    "hamiltonian = hamiltonian.astype(\"complex64\")\n",
+    "rho = rho.astype(\"complex64\")"
+   ]
+  },
+  {
+   "attachments": {
+    "Ugibbs.jpg": {
+     "image/jpeg": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 搭建量子神经网络\n",
+    "- 在这个案例中，我们将通过训练量子神经网络QNN（也可以理解为参数化量子电路）来训练吉布斯态。这里，我们提供一个简单的4量子位的量子电路如下：\n",
+    "![Ugibbs.jpg](attachment:Ugibbs.jpg)\n",
+    "\n",
+    "- 我们预设一些该参数化电路的参数，比如宽度为4量子位，其中第1个量子位是辅助系统，第2-4个量子位是最后产生吉布斯态的系统。\n",
+    "\n",
+    "- 初始化其中的变量参数，${\\bf{\\theta }}$代表我们量子神经网络中的参数组成的向量。\n",
+    "         "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%% \n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "N = 4 #量子神经网络的宽度\n",
+    "N_SYS_B = 3 #生成吉布斯态的系统B的量子位数   \n",
+    "D = 1 #量子神经网络中重复模块的深度，这里只用1层\n",
+    "SEED = 1 #种子"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "- 接下来我们根据上图中的电路设计，具体通过PaddleQuantum的UAnsatz函数来搭建量子神经网络。      "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def U_theta(theta, input_state, N, D):\n",
+    "    \"\"\"\n",
+    "    Circuit\n",
+    "    \"\"\"\n",
+    "\n",
+    "    cir = UAnsatz(N, input_state=input_state)\n",
+    "    for i in range(N):\n",
+    "        cir.ry(theta=theta[0][1][i], which_qubit=i + 1)\n",
+    "        \n",
+    "    for repeat in range(D):\n",
+    "        for i in range(1, N):\n",
+    "            cir.cnot(control=[i, i + 1])\n",
+    "         \n",
+    "        for i in range(N):\n",
+    "            cir.ry(theta=theta[repeat][0][i], which_qubit=i + 1)\n",
+    "    return cir.state\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## 配置训练模型 - 损失函数\n",
+    "- 现在我们已经有了数据和量子神经网络的架构，我们将进一步定义合适的训练参数、模型和损失函数来达到我们的目标。\n",
+    "- 具体的我们参考的是[4]中的方法（核心思想是利用吉布斯态达到了最小自由能的性质）。\n",
+    "- 通过作用量子神经网络$U(\\theta)$在初始态上，我们可以得到输出态$\\left| {\\psi \\left( {\\bf{\\theta }} \\right)} \\right\\rangle $, 其在第2-4个量子位的态记为$\\rho_B(\\theta)$.\n",
+    "- 设置训练模型中的的损失函数，在吉布斯态学习中，我们利用冯诺依曼熵函数的截断来进行自由能的估计，相应的损失函数参考[4]可以设为 \n",
+    "$loss= {L_1} + {L_2} + {L_3}$，其中${L_1} = tr(H\\rho_B)$, ${L_2} = 2{\\beta ^{ - 1}}{\\mathop{\\rm Tr}\\nolimits} \\left( \\rho_B^2 \\right)$, $- {\\beta ^{ - 1}}\\frac{{Tr(\\rho_B^3) + 3}}{2}$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class Net(fluid.dygraph.Layer):\n",
+    "    \"\"\"\n",
+    "    Construct the model net\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, shape, param_attr=fluid.initializer.Uniform(low=0.0, high=PI, seed=SEED),\n",
+    "                 dtype='float32'):\n",
+    "        super(Net, self).__init__()\n",
+    "\n",
+    "        self.theta = self.create_parameter(shape=shape, attr=param_attr, dtype=dtype, is_bias=False)\n",
+    "\n",
+    "    def forward(self, input_state, H, N, N_SYS_B, D):\n",
+    "        \"\"\"\n",
+    "        Args:\n",
+    "            input_state: The initial state with default |0..>\n",
+    "            H: The target Hamiltonian\n",
+    "        Returns:\n",
+    "            The loss.\n",
+    "        \"\"\"\n",
+    "\n",
+    "        out_state = U_theta(self.theta, input_state, N, D)\n",
+    "\n",
+    "        # rho_AB = utils.matmul(utils.matrix_conjugate_transpose(out_state), out_state)\n",
+    "        rho_AB = matmul(transpose(\n",
+    "            fluid.framework.ComplexVariable(out_state.real, -out_state.imag), perm=[1, 0]), out_state)\n",
+    "\n",
+    "        # compute the partial trace and three losses\n",
+    "        rho_B = partial_trace(rho_AB, 2 ** (N - N_SYS_B), 2 ** (N_SYS_B), 1)\n",
+    "        rho_B_squre = matmul(rho_B, rho_B)\n",
+    "        loss1 = (trace(matmul(rho_B, H))).real\n",
+    "        loss2 = (trace(rho_B_squre)).real * 2\n",
+    "        loss3 = - (trace(matmul(rho_B_squre, rho_B))).real / 2\n",
+    "\n",
+    "        loss = loss1 + loss2 + loss3  # 损失函数\n",
+    "\n",
+    "        # option: if you want to check whether the imaginary part is 0, uncomment the following\n",
+    "        # print('loss_iminary_part: ', loss.numpy()[1])\n",
+    "        return loss - 3 / 2, rho_B"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 配置训练模型 - 模型参数\n",
+    "在进行量子神经网络的训练之前，我们还需要进行一些训练（超）参数的设置，例如学习速率与迭代次数。\n",
+    "- 设定学习速率（learning rate）为0.5, 迭代次数为50次。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ITR = 50 #训练的总的迭代次数\n",
+    "\n",
+    "LR = 0.5 #学习速率"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 进行训练\n",
+    "\n",
+    "- 当训练模型的各项参数都设置完成后，我们将数据转化为Paddle动态图中的变量，进而进行量子神经网络的训练。\n",
+    "- 训练过程中我们用的是[Adam Optimizer](https://www.paddlepaddle.org.cn/documentation/docs/zh/api_cn/optimizer_cn/AdagradOptimizer_cn.html)，也可以调用Paddle中提供的其他优化器。\n",
+    "- 我们将训练过程中的结果依次输出。\n",
+    "- 特别的我们依次输出了我们学习到的量子态$\\rho_B(\\theta)$与吉布斯态$\\rho_G$的保真度，保真度越高说明QNN输出的态越接近于吉布斯态。\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%% \n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "with fluid.dygraph.guard():\n",
+    "    # initial state preparing\n",
+    "    _initial_state_np = concatenate(([[1.]], zeros([1, 2 ** N - 1])), axis=1).astype('complex64')\n",
+    "    initial_state = fluid.dygraph.to_variable(_initial_state_np)\n",
+    "\n",
+    "    # gibbs Hamiltonian preparing\n",
+    "    H = fluid.dygraph.to_variable(hamiltonian)\n",
+    "\n",
+    "    # net\n",
+    "    net = Net(shape=[D + 1, 3, N])\n",
+    "\n",
+    "    # optimizer\n",
+    "    opt = fluid.optimizer.AdamOptimizer(learning_rate=LR, parameter_list=net.parameters())\n",
+    "\n",
+    "    # gradient descent loop\n",
+    "    for itr in range(1, ITR + 1):\n",
+    "        loss, rho_B = net(initial_state, H, N, N_SYS_B, D)\n",
+    "\n",
+    "        loss.backward()\n",
+    "        opt.minimize(loss)\n",
+    "        net.clear_gradients()\n",
+    "\n",
+    "        rho_B = rho_B.numpy()\n",
+    "\n",
+    "        fid = compute_fid(rho_B, rho)\n",
+    "        print('iter:', itr, 'loss:', '%.4f' % loss.numpy(), 'fid:', '%.4f' % fid)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 总结\n",
+    "根据上面训练得到的结果，通过大概50次迭代，我们就能达到高于99.5%保真度的高精度吉布斯态，高效并精确地完成了吉布斯态的制备。我们可以通过print函数来输出学习到的量子神经网络的参数和它的输出态。\n",
+    "\n",
+    "### 参考文献\n",
+    "\n",
+    "[1] M. Kieferová and N. Wiebe, “Tomography and generative training with quantum Boltzmann machines,” Phys. Rev. A, vol. 96, no. 6, p. 062327, Dec. 2017.\n",
+    "\n",
+    "[2] F. G. S. L. Brandao and K. M. Svore, “Quantum Speed-Ups for Solving Semidefinite Programs,” in 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS), 2017, pp. 415–426.\n",
+    "\n",
+    "[3] R. D. Somma, S. Boixo, H. Barnum, and E. Knill, “Quantum Simulations of Classical Annealing Processes,” Phys. Rev. Lett., vol. 101, no. 13, p. 130504, Sep. 2008.\n",
+    "\n",
+    "[4] Y. Wang, G. Li, and X. Wang, “Variational quantum Gibbs state preparation with a truncated Taylor series,” arXiv:2005.08797, May 2020. [[pdf](https://arxiv.org/pdf/2005.08797.pdf)]"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
\ No newline at end of file

tutorial/QAOA.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 简体中文 | [English](./QAOA_En.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 准备\n",
+    "\n",
+    "本文档演示 Paddle Quantum 上量子近似优化算法（QAOA，Quantum Approximate Optimization Algorithm）的工作流程 [1]。\n",
+    "\n",
+    "开始之前完成准备工作：\n",
+    "\n",
+    "   - 调用飞桨 paddlepaddle\n",
+    "\n",
+    "   - 调用常用的库, 例如画图工具库 networkx 和 matplotlib.pyplot\n",
+    "\n",
+    "   - 调用自定义函数 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from paddle import fluid\n",
+    "\n",
+    "import os\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import networkx as nx\n",
+    "\n",
+    "from numpy import matmul as np_matmul\n",
+    "from paddle.complex import matmul as pp_matmul\n",
+    "from paddle.complex import transpose\n",
+    "from paddle_quantum.circuit import UAnsatz"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 背景\n",
+    "\n",
+    "\n",
+    "量子近似优化算法（QAOA，Quantum Approximate Optimization Algorithm）是可以在近期有噪中等规模（NISQ，Noisy Intermediate-Scale Quantum）量子计算机上运行且具有广泛应用前景的量子算法。例如，QAOA 可以用来处理压缩图信号和二次优化等领域常见的离散组合优化问题。这类优化问题通常可以归结为下面的数学模型：\n",
+    "\n",
+    "\n",
+    " $$F=\\max_{z_i\\in\\{-1,1\\}} \\sum_{（i,j）} q_{ij}(1-z_iz_j)=-\\min_{z_i\\in\\{-1,1\\}} \\sum_{（i,j）} q_{ij}z_iz_j+ \\sum_{（i,j）}q_{ij}. $$\n",
+    "\n",
+    "\n",
+    "其中, $z_i \\in \\{-1 ,1\\} $ 是待求的二元参数，系数 $q_{ij}$ 是 $z_i z_j$ 的权重 (weight)。一般地，精确求解该问题对于经典计算机是 NP-hard 的，而 QAOA 被认为对近似求解这类困难问题具有潜在速度优势。\n",
+    "\n",
+    "QAOA 的工作原理是把上述经典优化问题（例如组合优化问题）甚至量子优化问题（例如量子多体系统中 Ising 模型的求解）等价地转化为求解一个物理系统哈密顿量（Hamiltonian）的基态能量（对应优化问题的最优值）及其相应的基态（对应于优化问题的最优解）。在数学形式上，QAOA 等价于求解一个实对角矩阵 $H$ 的最小特征值及其对应的特征向量。\n",
+    "\n",
+    "和另外一种常见的变分量子特征求解器(VQE, Variational Quantum Eigensolver) 一样，QAOA 也是一种量子-经典混杂算法。 然而 QAOA 参数化量子电路的实现更简单，仅需两个可以调节参数的量子电路模块组成。\n",
+    "\n",
+    "接下来，我们通过图的最大割问题 （Max-Cut problem）来展示 QAOA 算法的工作流程和原理。"
+   ]
+  },
+  {
+   "attachments": {
+    "ring4.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "# 示例\n",
+    "\n",
+    "##  1. Max-Cut 问题\n",
+    "\n",
+    "图的 Max-Cut 问题可以描述为：对于一个给定的包含 $N$ 个顶点 （nodes or vertices）和 $M$ 条边 (edges) 的无向图，找到一种分割方案将图的顶点集合分割成两个无交子集合 $S$ 和 $S^\\prime$，使得连接这两个顶点集合之间边的数目尽可能多。如图所示，我们考虑含4个顶点且具有环形结构的图： \n",
+    "\n",
+    " ![ring4.png](attachment:ring4.png) \n",
+    "\n",
+    "Max-Cut 问题建模：在做分割时，若顶点 $i$ 属于集合 $S$ 时，赋值 $z_i=1$；若顶点 $j$ 属于 $S^\\prime$ 时，则令 $z_j=-1$。那么对于图的任意连接顶点 $(i, j)$ 的边则满足：若顶点属于同一集合 $S$ 或 $S^\\prime$ 时，$z_iz_j=1$; 若顶点分别属于不同集合时，$z_izj=-1$。于是 Max-Cut 问题转化为如下优化问题：\n",
+    "\n",
+    "$$ F=\\min_{z_i\\in\\{-1, 1\\}} z_1 z_2+z_2z_3+z_3z_4+z_4z_1.$$\n",
+    "\n",
+    "这里所有 $q_{ij}$ 均设置为 1，表示每条边的权重相等。该问题的所有可行解由比特串 $ \\boldsymbol{z}=z_1z_2z_3z_4 \\in \\{-1, 1\\}^4$ 组成，而且通常需要遍历所有比特串才能得到问题的最小值（最优解）。容易看出，比特串的数目是顶点数目 $N$ 的指数级别，即 $2^N$。因此，随着顶点数目的增加，搜索的代价也会呈指数级别增加。\n",
+    "\n",
+    "接下来，我们提供两种方法来预处理编码经典优化问题的图，即如何通过 Paddle Quantum 输入和可视化无权（或带权重）图：\n",
+    "\n",
+    "- 方法1是通过指定图的顶点和相应的边（及其权重）\n",
+    "- 方法2是通过直接输入图的邻接矩阵。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def generate_graph(N, GRAPHMETHOD):\n",
+    "    \"\"\"\n",
+    "    It plots an N-node graph which is specified by Method 1 or 2.\n",
+    "    \n",
+    "    Args:\n",
+    "        N: number of nodes (vertices) in the graph\n",
+    "        METHOD: choose which method to generate a graph\n",
+    "    Return:\n",
+    "        the specific graph and its adjacency matrix\n",
+    "    \"\"\"\n",
+    "    # Method 1 generates a graph by self-definition\n",
+    "    if GRAPHMETHOD == 1:\n",
+    "        print(\"Method 1 generates the graph from self-definition using EDGE description\")\n",
+    "        graph = nx.Graph()\n",
+    "        graph_nodelist=range(N)\n",
+    "        graph.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0)])\n",
+    "        graph_adjacency = nx.to_numpy_matrix(graph, nodelist=graph_nodelist)\n",
+    "    # Method 2 generates a graph by using its adjacency matrix directly\n",
+    "    elif GRAPHMETHOD == 2:\n",
+    "        print(\"Method 2 generates the graph from networks using adjacency matrix\")\n",
+    "        graph_adjacency = np.array([[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0]])\n",
+    "        graph = nx.Graph(graph_adjacency)\n",
+    "    else:\n",
+    "        print(\"Method doesn't exist \")\n",
+    "\n",
+    "    return graph, graph_adjacency"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "这里指定方法1来预处理图：\n",
+    "\n",
+    "- 图的顶点数目 $N=4$\n",
+    "- 图的输入方法 GRAPHMETHOD = 1 \n",
+    "\n",
+    "注意：上述两种方法给出的图的顶点均从 $0$ 开始计数。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# number of qubits or number of nodes in the graph\n",
+    "N=4  \n",
+    "classical_graph, classical_graph_adjacency= generate_graph(N, GRAPHMETHOD=1)\n",
+    "print(classical_graph_adjacency)\n",
+    "\n",
+    "pos = nx.circular_layout(classical_graph)\n",
+    "nx.draw(classical_graph, pos, width=4, with_labels=True, font_weight='bold')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. 编码量子优化问题\n",
+    "\n",
+    "接下来需要把上述经典优化问题映射为量子优化问题。利用替代关系 $z=1\\rightarrow |0\\rangle = \\begin{bmatrix}1 \\\\ 0\\end{bmatrix}$ 和 $z=-1\\rightarrow |1\\rangle = \\begin{bmatrix}0 \\\\ 1\\end{bmatrix}$, 我们把二元参数 $z_i\\in\\{-1, 1\\}$ 对应为描述量子比特的 Pauli-Z 算符 $Z_i=\\begin{bmatrix} 1 & 0\\\\ 0 & -1\\end{bmatrix}$ 的两个本征值。于是经典优化问题里的目标函数相应地编码为一个描述系统哈密顿量的矩阵\n",
+    "\n",
+    "$$H_{c}= Z_1Z_2+Z_2Z_3+Z_3Z_4+Z_4Z_1.$$\n",
+    "\n",
+    "其中 $Z_iZ_{j}$ 是 tensor product 运算，表示 Pauli-Z 算符分别作用在量子比特 $i$ 和 $j$ 上，而其余的量子比特上作用单位算符 $I=\\begin{bmatrix} 1 & 0\\\\ 0 & 1\\end{bmatrix}$ ，例如 $Z_1Z_2 =Z_1\\otimes Z_2\\otimes I_3\\otimes I_4$。经过上述操作，我们把经典优化问题转化为求解矩阵 $H_{c}$ 的最小特征值 $F$ 及其对应的向量 $|\\psi\\rangle$, 即\n",
+    "\n",
+    "$$ F=\\min_{|\\psi\\rangle} \\langle \\psi| H_c |\\psi\\rangle.$$\n",
+    "\n",
+    "这里，$|\\psi\\rangle$ 记为一个模长为1的 $2^4=16$ 维复向量，$\\langle \\psi|$ 是其共轭转置。\n",
+    "\n",
+    "Paddle Quantum 中通过函数 H_generator 完成编码任务："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def H_generator(N, adjacency_matrix):\n",
+    "    \"\"\"\n",
+    "    This function maps the given graph via its adjacency matrix to the corresponding Hamiltiona H_c.\n",
+    "    \n",
+    "    Args:\n",
+    "        N: number of qubits, or number of nodes in the graph, or number of parameters in the classical problem\n",
+    "        adjacency_matrix:  the adjacency matrix generated from the graph encoding the classical problem\n",
+    "    Return:\n",
+    "        H_graph: the problem-based Hamiltonian H generated from the graph_adjacency matrix for the given graph\n",
+    "        H_graph_diag: the real part of the problem-based Hamiltonian H_graph\n",
+    "    \"\"\"\n",
+    "\n",
+    "    sigma_Z = np.array([[1, 0], [0, -1]])\n",
+    "    H = np.zeros([2 ** N, 2 ** N])\n",
+    "    # Generate the Hamiltonian H_c from the graph via its adjacency matrix\n",
+    "    for row in range(N):\n",
+    "        for col in range(N):\n",
+    "            if abs(adjacency_matrix[N - row - 1, N - col - 1]) and row < col:\n",
+    "                identity_1 = np.diag(np.ones([2 ** row]))\n",
+    "                identity_2 = np.diag(np.ones([2 ** (col - row - 1)]))\n",
+    "                identity_3 = np.diag(np.ones([2 ** (N - col - 1)]))\n",
+    "                H += adjacency_matrix[N - row - 1, N - col - 1] * np.kron(\n",
+    "                    np.kron(np.kron(np.kron(identity_1, sigma_Z), identity_2), sigma_Z),\n",
+    "                    identity_3,\n",
+    "                )\n",
+    "\n",
+    "    H_graph = H.astype(\"complex64\")\n",
+    "    H_graph_diag = np.diag(H_graph).real\n",
+    "\n",
+    "    return H_graph, H_graph_diag"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "我们可以查看生成矩阵 $H_c $ 的具体形式，并且获取它的特征值信息："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "_, H_problem_diag = H_generator(N, classical_graph_adjacency)\n",
+    "\n",
+    "H_graph_max = np.max(H_problem_diag)\n",
+    "H_graph_min = np.min(H_problem_diag)\n",
+    "\n",
+    "print(H_problem_diag)\n",
+    "print('H_max:', H_graph_max, '  H_min:', H_graph_min)"
+   ]
+  },
+  {
+   "attachments": {
+    "circuit.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. 搭建 QAOA 电路\n",
+    "\n",
+    "通过交替地摆放两个参数可调的电路模块，我们得以搭建QAOA电路\n",
+    "\n",
+    "$$U_x(\\beta_P)U_c(\\gamma_P)\\dots U_x(\\beta_1)U_c(\\gamma_1),$$\n",
+    "\n",
+    "其中放置的次数记为 $P$。具体地，模块一是由描述问题哈密顿量的矩阵生成，即\n",
+    "\n",
+    "$$U_c(\\gamma)=e^{-i \\gamma H_c },$$\n",
+    "\n",
+    "其中 $i= \\sqrt{-1}$ 是虚数单位， $\\gamma\\in [0, \\pi]$ 是可以调节的参数。模块二是\n",
+    "\n",
+    "$$U_x(\\beta)=e^{-i \\beta H_x },$$\n",
+    "\n",
+    "由描述驱动哈密顿量的另一个矩阵生成 \n",
+    "\n",
+    "$$H_x =X_1+X_2+X_3+X_4. $$\n",
+    "\n",
+    "$\\beta\\in [0, \\pi]$ 也是一个可调参数，算符 $X=\\begin{bmatrix} 0 & 1\\\\ 1 & 0\\end{bmatrix}$ 是作用在量子比特上的 Pauli-X 逻辑门，例如 $X_1$ 实际数学表达式为 $X_1\\otimes I_2\\otimes I_3\\otimes I_4$。\n",
+    "\n",
+    "QAOA 电路的每一模块可以进一步分解为若干个作用在单比特和两比特上的含参的量子逻辑门，如图所示:\n",
+    "\n",
+    "\n",
+    "<div>\n",
+    "<img src=\"attachment:circuit.png\" width=\"400\"/>\n",
+    "</div>\n",
+    "\n",
+    "\n",
+    "\n",
+    "其中，模块 $U_x(\\beta)$ 可以分解为在每个量子比特上作用绕 $X$ 方向转动的量子逻辑门 $R_x(\\beta)= e^{-i\\beta X_j}$，而模块 $U_c(\\gamma)$ 则可分解为作用在两比特上的 $ZZ$ 逻辑门 $R_{zz}(\\gamma)= e^{-i\\gamma ZZ}$。\n",
+    "\n",
+    "此外，我们可以设置交叉放置两个模块的次数，记为 QAOA 电路的层数 $P$。于是输入\n",
+    "\n",
+    "- 量子电路的初始状态\n",
+    "- 经典问题的邻接矩阵\n",
+    "- 电路比特数目\n",
+    "- 电路层数\n",
+    "\n",
+    "构建标准的 QAOA 量子电路："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def circuit_QAOA(theta, input_state, adjacency_matrix, N, P):\n",
+    "    \"\"\"\n",
+    "    This function constructs the parameterized QAOA circuit which is composed of P layers of two blocks:\n",
+    "    one block is U_theta[layer][0] based on the problem Hamiltonian H which encodes the classical problem,\n",
+    "    and the other is U_theta[layer][1] constructed from the driving Hamiltonian describing the rotation around Pauli X\n",
+    "    acting on each qubit. It finally outputs the final state of the QAOA circuit.\n",
+    "    \n",
+    "    Args:\n",
+    "         theta: parameters to be optimized in the QAOA circuit\n",
+    "         input_state: initial state of the QAOA circuit which usually is the uniform superposition of 2^N bit-strings \n",
+    "         in the computataional basis\n",
+    "         adjacency_matrix:  the adjacency matrix of the graph encoding the classical problem\n",
+    "         N: number of qubits, or equivalently, the number of parameters in the original classical problem\n",
+    "         P: number of layers of two blocks in the QAOA circuit\n",
+    "    Returns:\n",
+    "        the final state of the QAOA circuit: cir.state\n",
+    "\n",
+    "    \"\"\"\n",
+    "\n",
+    "    cir = UAnsatz(N, input_state=input_state)\n",
+    "    \n",
+    "    # This loop defines the QAOA circuit with P layers of two blocks\n",
+    "    for layer in range(P):\n",
+    "        # The second and third loops construct the first block U_theta[layer][0] which involves two-qubit operation\n",
+    "        #  e^{-i\\beta Z_iZ_j} acting on a pair of qubits or nodes i and j in the circuit in each layer.\n",
+    "        for row in range(N):\n",
+    "            for col in range(N):\n",
+    "                if abs(adjacency_matrix[row, col]) and row < col:\n",
+    "                    cir.cnot([row + 1, col + 1])\n",
+    "                    cir.rz(\n",
+    "                        theta=theta[layer][0]\n",
+    "                        * adjacency_matrix[row, col],\n",
+    "                        which_qubit=col + 1,\n",
+    "                    )\n",
+    "                    cir.cnot([row + 1, col + 1])\n",
+    "        # This loop constructs the second block U_theta only involving the single-qubit operation e^{-i\\beta X}.\n",
+    "        for i in range(1, N + 1):\n",
+    "            cir.rx(theta=theta[layer][1], which_qubit=i)\n",
+    "\n",
+    "    return cir.state"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "在标准 QAOA 的基础上，我们还支持对电路结构进行扩展，进一步探索 QAOA 更多可能性。例如，可以将模块二的驱动哈密顿量 $H_x$ 中的的绕单比特 X 方向转动 $R_x(\\beta)$ 扩展为绕任意方向转动，且任意方向等价于依次绕 Z, X, Z 方向转动适当的角度，即$R_z(\\beta_1)R_x(\\beta_2)R_z(\\beta_3)$："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def circuit_extend_QAOA(theta, input_state, adjacency_matrix, N, P):\n",
+    "    \"\"\"\n",
+    "    This is an extended version of the QAOA circuit, and the main difference is U_theta[layer]([1]-[3]) constructed\n",
+    "    from the driving Hamiltonian describing the rotation around an arbitrary direction on each qubit.\n",
+    "\n",
+    "    Args:\n",
+    "        theta: parameters to be optimized in the QAOA circuit\n",
+    "        input_state: input state of the QAOA circuit which usually is the uniform superposition of 2^N bit-strings\n",
+    "                     in the computational basis\n",
+    "        adjacency_matrix:  the adjacency matrix of the problem graph encoding the original problem\n",
+    "        N: number of qubits, or equivalently, the number of parameters in the original classical problem\n",
+    "        P: number of layers of two blocks in the QAOA circuit\n",
+    "    Returns:\n",
+    "        final state of the QAOA circuit: cir.state\n",
+    "\n",
+    "    Note: If this U_extend_theta function is used to construct QAOA circuit, then we need to change the parameter layer\n",
+    "           in the Net function defined below from the Net(shape=[D, 2]) for U_theta function to Net(shape=[D, 4])\n",
+    "           because the number of parameters doubles in each layer in this QAOA circuit.\n",
+    "    \"\"\"\n",
+    "    cir = UAnsatz(N, input_state=input_state)\n",
+    "\n",
+    "    for layer in range(P):\n",
+    "        for row in range(N):\n",
+    "            for col in range(N):\n",
+    "                if abs(adjacency_matrix[row, col]) and row < col:\n",
+    "                    cir.cnot([row + 1, col + 1])\n",
+    "                    cir.rz(\n",
+    "                        theta=theta[layer][0]\n",
+    "                        * adjacency_matrix[row, col],\n",
+    "                        which_qubit=col + 1,\n",
+    "                    )\n",
+    "                    cir.cnot([row + 1, col + 1])\n",
+    "\n",
+    "        for i in range(1, N + 1):\n",
+    "            cir.rz(theta=theta[layer][1], which_qubit=i)\n",
+    "            cir.rx(theta=theta[layer][2], which_qubit=i)\n",
+    "            cir.rz(theta=theta[layer][3], which_qubit=i)\n",
+    "\n",
+    "    return cir.state"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "搭建 QAOA 量子电路的工作完成后，此时量子电路的输出状态为\n",
+    "\n",
+    "$$|\\psi(\\boldsymbol{\\beta},\\boldsymbol{\\gamma}, P)\\rangle=U_x(\\beta_P)U_c(\\gamma_P)\\dots U_x(\\beta_1)U_c(\\gamma_1)|+\\rangle_1\\dots|+\\rangle_N.$$\n",
+    "\n",
+    "其中每个量子比特的初始状态处于量子叠加态 $|+\\rangle=\\frac{1}{\\sqrt{2}}\\left(|0\\rangle+|1\\rangle\\right)$ 。最终，我们得到量子优化问题的损失函数\n",
+    "\n",
+    "$$F_P=\\min_{\\boldsymbol{\\beta},\\boldsymbol{\\gamma}} \\langle \\psi(\\boldsymbol{\\beta},\\boldsymbol{\\gamma}, P)| H_c|\\psi(\\boldsymbol{\\beta},\\boldsymbol{\\gamma}, P)\\rangle.$$\n",
+    "\n",
+    "因为 QAOA 是一个量子-经典混杂算法，所以搭建完成 QAOA 电路且得到相应的损失函数后，我们可以进一步利用经典的优化算法寻找最优参数 $\\boldsymbol{\\beta},\\boldsymbol{\\gamma}$，从而形成一个完整的闭环网络。\n",
+    "\n",
+    "下面的函数给出了通过 Paddle Quantum 搭建的完整 QAOA 网络："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class Net(fluid.dygraph.Layer):\n",
+    "    \"\"\"\n",
+    "    It constructs the net for QAOA which combines the  QAOA circuit with the classical optimizer which sets rules\n",
+    "    to update parameters described by theta introduced in the QAOA circuit.\n",
+    "\n",
+    "    \"\"\"\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        shape,\n",
+    "        param_attr=fluid.initializer.Uniform(low=0.0, high=np.pi, seed=1024),\n",
+    "        dtype=\"float32\",\n",
+    "    ):\n",
+    "        super(Net, self).__init__()\n",
+    "\n",
+    "        self.theta = self.create_parameter(\n",
+    "            shape=shape, attr=param_attr, dtype=dtype, is_bias=False\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, input_state, adjacency_matrix, out_state_store, N, P, METHOD):\n",
+    "        \"\"\"\n",
+    "        This function constructs the loss function for the QAOA circuit.\n",
+    "\n",
+    "        Args:\n",
+    "            self: the free parameters to be optimized in the QAOA circuit and defined in the above function\n",
+    "            input_state: initial state of the QAOA circuit which usually is the uniform superposition of 2^N bit-strings\n",
+    "                         in the computational basis $|0\\rangle, |1\\rangle$\n",
+    "            adjacency_matrix: the adjacency matrix generated from the graph encoding the classical problem\n",
+    "            out_state_store: the output state of the QAOA circuit\n",
+    "            N: number of qubits\n",
+    "            P: number of layers\n",
+    "            METHOD: which version of QAOA is chosen to solve the problem, i.e., standard version labeled by 1 or\n",
+    "            extended version by 2.\n",
+    "        Returns:\n",
+    "            The loss function for the parameterized QAOA circuit.\n",
+    "        \"\"\"\n",
+    "        \n",
+    "        # Generate the problem_based quantum Hamiltonian H_problem based on the classical problem in paddle\n",
+    "        H, _ = H_generator(N, adjacency_matrix)\n",
+    "        H_problem = fluid.dygraph.to_variable(H)\n",
+    "\n",
+    "        # The standard QAOA circuit: the function circuit_QAOA is used to construct the circuit, indexed by METHOD 1.\n",
+    "        if METHOD == 1:\n",
+    "            out_state = circuit_QAOA(self.theta, input_state, adjacency_matrix, N, P)\n",
+    "        # The extended QAOA circuit: the function circuit_extend_QAOA is used to construct the net, indexed by METHOD 2.\n",
+    "        elif METHOD == 2:\n",
+    "            out_state = circuit_extend_QAOA(self.theta, input_state, adjacency_matrix, N, P)\n",
+    "        else:\n",
+    "            raise ValueError(\"Wrong method called!\")\n",
+    "\n",
+    "        out_state_store.append(out_state.numpy())\n",
+    "        loss = pp_matmul(\n",
+    "            pp_matmul(out_state, H_problem),\n",
+    "            transpose(\n",
+    "                fluid.framework.ComplexVariable(out_state.real, -out_state.imag),\n",
+    "                perm=[1, 0],\n",
+    "            ),\n",
+    "        )\n",
+    "\n",
+    "        return loss.real\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. 训练网络\n",
+    "\n",
+    "我们开始训练整个 QAOA 网络，即通过优化参数向量 $\\boldsymbol{\\beta}=(\\beta_1,\\beta_2,\\beta_3,\\beta_4)$ 和 $\\boldsymbol{\\gamma}=(\\gamma_1,\\gamma_2,\\gamma_3, \\gamma_4)$ 来达到求解 $H_c$ 最小特征值的目的。\n",
+    "\n",
+    "与经典机器学习算法一样，首先设置 QAOA 网络里的超参数:\n",
+    "\n",
+    "- 电路比特数目 N\n",
+    "- 电路的层数 P\n",
+    "- 迭代次数 ITR\n",
+    "- 学习步长 LR"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "N = 4 # number of qubits, or number of nodes in the graph\n",
+    "P = 4 # number of layers \n",
+    "ITR = 120  # number of iteration steps\n",
+    "LR = 0.1  # learning rate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "然后，灵活调用：\n",
+    "\n",
+    "- 量子电路初始状态：每个量子比特态处于相干叠加态 $\\frac{1}{\\sqrt{2}}\\left(|0\\rangle+|1\\rangle\\right)$\n",
+    "- 采用标准 QAOA （记为 METHOD=1）或者扩展 QAOA （记为 METHOD = 2）\n",
+    "- 经典优化器 Adam optimizer \n",
+    "\n",
+    "最后，训练模型并保存结果："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def Paddle_QAOA(classical_graph_adjacency, N, P, METHOD, ITR, LR):\n",
+    "    \"\"\"\n",
+    "    This is the core function to run QAOA.\n",
+    "\n",
+    "     Args:\n",
+    "         classical_graph_adjacency: adjacency matrix to describe the graph which encodes the classical problem\n",
+    "         N: number of qubits (default value N=4)\n",
+    "         P: number of layers of blocks in the QAOA circuit (default value P=4)\n",
+    "         METHOD: which version of the QAOA circuit is used: 1, standard circuit (default); 2, extended circuit\n",
+    "         ITR: number of iteration steps for QAOA (default value ITR=120)\n",
+    "         LR: learning rate for the gradient-based optimization method (default value LR=0.1)\n",
+    "     Returns:\n",
+    "         optimized parameters theta and the bitstrings sampled from the output state with maximal probability\n",
+    "    \"\"\"\n",
+    "    out_state_store = []\n",
+    "    with fluid.dygraph.guard():\n",
+    "        # Preparing the initial state\n",
+    "        _initial_state = np.ones([1, 2 ** N]).astype(\"complex64\") / np.sqrt(2 ** N)\n",
+    "        initial_state = fluid.dygraph.to_variable(_initial_state)\n",
+    "\n",
+    "        # Construct the net or QAOA circuits based on the standard modules\n",
+    "        if METHOD == 1:\n",
+    "            net = Net(shape=[P, 2])\n",
+    "        # Construct the net or QAOA circuits based on the extended modules\n",
+    "        elif METHOD == 2:\n",
+    "            net = Net(shape=[P, 4])\n",
+    "        else:\n",
+    "            raise ValueError(\"Wrong method called!\")\n",
+    "\n",
+    "        # Classical optimizer\n",
+    "        opt = fluid.optimizer.AdamOptimizer(learning_rate=LR, parameter_list=net.parameters())\n",
+    "\n",
+    "        # Gradient descent loop\n",
+    "        summary_iter, summary_loss = [], []\n",
+    "        for itr in range(1, ITR + 1):\n",
+    "            loss = net(\n",
+    "                initial_state, classical_graph_adjacency, out_state_store, N, P, METHOD\n",
+    "            )\n",
+    "            loss.backward()\n",
+    "            opt.minimize(loss)\n",
+    "            net.clear_gradients()\n",
+    "\n",
+    "            print(\"iter:\", itr, \"  loss:\", \"%.4f\" % loss.numpy())\n",
+    "            summary_loss.append(loss[0][0].numpy())\n",
+    "            summary_iter.append(itr)\n",
+    "\n",
+    "        theta_opt = net.parameters()[0].numpy()\n",
+    "        print(theta_opt)\n",
+    "\n",
+    "        os.makedirs(\"output\", exist_ok=True)\n",
+    "        np.savez(\"./output/summary_data\", iter=summary_iter, energy=summary_loss)\n",
+    "\n",
+    "    # Output the measurement probability distribution which is sampled from the output state of optimized QAOA circuit.\n",
+    "    prob_measure = np.zeros([1, 2 ** N]).astype(\"complex\")\n",
+    "\n",
+    "    rho_out = out_state_store[-1]\n",
+    "    rho_out = np_matmul(np.conjugate(rho_out).T, rho_out).astype(\"complex\")\n",
+    "\n",
+    "    for index in range(0, 2 ** N):\n",
+    "        comput_basis = np.zeros([1, 2 ** N])\n",
+    "        comput_basis[0][index] = 1\n",
+    "        prob_measure[0][index] = np.real(np_matmul(np_matmul(comput_basis, rho_out), comput_basis.T))\n",
+    "\n",
+    "    return prob_measure"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "调用模型训练结果，输出得到的最优参数向量 $\\boldsymbol{\\beta}^*$ 和 $\\boldsymbol{\\gamma}^*$，并且将 QAOA 的输出结果和真实结果进行比较："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "classical_graph, classical_graph_adjacency = generate_graph(N, 1)\n",
+    "\n",
+    "prob_measure_dis = Paddle_QAOA(classical_graph_adjacency, N =4, P=4, METHOD=1, ITR=120, LR=0.1)\n",
+    "\n",
+    "# Load the data of QAOA\n",
+    "x1 = np.load('./output/summary_data.npz')\n",
+    "\n",
+    "H_min = np.ones([len(x1['iter'])]) * H_graph_min\n",
+    "\n",
+    "# Plot it\n",
+    "\n",
+    "loss_QAOA, = plt.plot(x1['iter'], x1['energy'], \\\n",
+    "                                        alpha=0.7, marker='', linestyle=\"--\", linewidth=2, color='m')\n",
+    "benchmark, = plt.plot(x1['iter'], H_min, alpha=0.7, marker='', linestyle=\":\", linewidth=2, color='b')\n",
+    "plt.xlabel('Number of iteration')\n",
+    "plt.ylabel('Performance of the loss function for QAOA')\n",
+    "\n",
+    "plt.legend(handles=[\n",
+    "    loss_QAOA,\n",
+    "    benchmark\n",
+    "],\n",
+    "    labels=[\n",
+    "            r'Loss function $\\left\\langle {\\psi \\left( {\\bf{\\theta }} \\right)} '\n",
+    "            r'\\right|H\\left| {\\psi \\left( {\\bf{\\theta }} \\right)} \\right\\rangle $',\n",
+    "            'The benchmark result',\n",
+    "    ], loc='best')\n",
+    "\n",
+    "# Show the picture\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## 5. 解码量子答案\n",
+    "\n",
+    "当求得损失函数 $\\langle \\psi(\\boldsymbol{\\beta},\\boldsymbol{\\gamma}, P)| H_{\\rm Cut}|\\psi(\\boldsymbol{\\beta},\\boldsymbol{\\gamma}, P)\\rangle$ 的最小值以及相对应的一组参数 $(\\boldsymbol{\\beta}^*,\\boldsymbol{\\gamma}^*)$ 后，我们的任务还没有完成。为了进一步求得 Max-Cut 问题的解，需要从 QAOA 输出的量子态 \n",
+    "\n",
+    "$$|\\psi(\\boldsymbol{\\beta}^*,\\boldsymbol{\\gamma}^*, P)\\rangle=\\sum_{i=1}^{2^4}\\lambda_i |\\boldsymbol{x}_i\\rangle$$\n",
+    "\n",
+    "中解码出经典优化问题的答案。上式中  $\\boldsymbol{x}_i=x_1x_2x_3 x_4\\in \\{0, 1\\}^4$，对应着经典问题的一个可行解。物理上，解码量子态需要对量子态进行测量，然后统计测量结果的概率分布：\n",
+    "                 \n",
+    "$$ p(\\boldsymbol{x})=|\\langle \\boldsymbol{x}|\\psi(\\boldsymbol{\\beta}^*,\\boldsymbol{\\gamma}^*,P)\\rangle|^2.$$\n",
+    "              \n",
+    "\n",
+    "某种程度上，某个比特串出现的概率越大，意味着其对应的 Max-Cut 问题最优解的可能性越大。\n",
+    "\n",
+    "此外，Paddle Quantum 提供了查看 QAOA 量子电路输出状态的测量结果概率分布的函数："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "prob_measure = prob_measure_dis.flatten()\n",
+    "\n",
+    "pos = nx.circular_layout(classical_graph)\n",
+    "# when N is large, it is not suggested to plot this figure\n",
+    "name_list = [np.binary_repr(index, width=N) for index in range(0, 2 ** N)]\n",
+    "plt.bar(\n",
+    "        range(len(np.real(prob_measure))),\n",
+    "        np.real(prob_measure),\n",
+    "        width=0.7,\n",
+    "        tick_label=name_list,\n",
+    "    )\n",
+    "plt.xticks(rotation=90)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "最后，再次利用参数代换 $|x \\rangle\\rightarrow z=2x-1\\in\\{-1, 1\\}$，可以从量子答案中解码得到 Max-Cut 问题的可行解。 此时，记 $z_i=-1$ 的顶点属于集合 $S^\\prime$ 以及 $z_j=1$ 的顶点属于集合 $S$，这两个顶点集合之间存在的边就是该图的一个可能得最大割方案。 \n",
+    "\n",
+    "选取测量结果中出现几率最大的比特串，然后将其映射回经典解，并且画出对应的最大割方案：\n",
+    "\n",
+    "- 蓝色顶点属于集合 $S$\n",
+    "- 红色顶点属于集合 $S^\\prime$\n",
+    "- 折线属于图的一条割线"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Find the position of max value in the measure_prob_distribution\n",
+    "max_prob_pos_list = np.where(prob_measure == max(prob_measure))\n",
+    "# Store the max value from ndarray to list\n",
+    "max_prob_list = max_prob_pos_list[0].tolist()\n",
+    "# Change it to the  binary format\n",
+    "solution_list = [np.binary_repr(index, width=N) for index in max_prob_list]\n",
+    "print(\"The output bitstring:\", solution_list)\n",
+    "\n",
+    "# Draw the graph representing the first bitstring in the solution_list to the MaxCut-like problem\n",
+    "head_bitstring = solution_list[0]\n",
+    "\n",
+    "node_cut = [\"blue\" if head_bitstring[node] == \"1\" else \"red\" for node in classical_graph]\n",
+    "\n",
+    "edge_cut = [\n",
+    "    \"solid\" if head_bitstring[node_row] == head_bitstring[node_col] else \"dashed\"\n",
+    "    for node_row, node_col in classical_graph.edges()\n",
+    "    ]\n",
+    "nx.draw(\n",
+    "        classical_graph,\n",
+    "        pos,\n",
+    "        node_color=node_cut,\n",
+    "        style=edge_cut,\n",
+    "        width=4,\n",
+    "        with_labels=True,\n",
+    "        font_weight=\"bold\",\n",
+    ")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "source": [
+    "# 参考文献\n",
+    "\n",
+    "[1] Farhi, E., Goldstone, J., & Gutmann, S. (2014). A quantum approximate optimization algorithm. arXiv:1411.4028."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.10"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "metadata": {
+     "collapsed": false
+    },
+    "source": []
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

tutorial/QAOA_En.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## English | [简体中文](./QAOA.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Preparation\n",
+    "\n",
+    "This document provides an interactive experience to show how the quantum approximate optimization algorithm (QAOA) [1] works in the Paddle Quantum. \n",
+    "\n",
+    "To get started, let us import some necessary libraries and functions："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from paddle import fluid\n",
+    "\n",
+    "import os\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import networkx as nx\n",
+    "\n",
+    "from numpy import matmul as np_matmul\n",
+    "from paddle.complex import matmul as pp_matmul\n",
+    "from paddle.complex import transpose\n",
+    "from paddle_quantum.circuit import UAnsatz"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Background\n",
+    "\n",
+    "QAOA is one of quantum algorithms which can be implemented on near-term quantum processors, also called as noisy intermediate-scale quantum (NISQ) processors, and may have wide applications in solving hard computational problems.  For example, it could be applied to tackle a large family of optimization problems, named as the quadratic unconstrained binary optimization (QUBO) which is ubiquitous in the computer science and operation research. Basically, this class can be modeled with the form of\n",
+    "\n",
+    "$$F=\\max_{z_i\\in\\{-1,1\\}} \\sum_{（i,j）} q_{ij}(1-z_iz_j)=-\\min_{z_i\\in\\{-1,1\\}} \\sum_{（i,j）} q_{ij}z_iz_j+ \\sum_{（i,j）}q_{ij} $$\n",
+    "\n",
+    "\n",
+    "where $z_i$s are  binary parameters and coefficients $q_{ij}$ refer to the weight associated to $x_i x_j$. Indeed, it is usually extremely difficult for classical computers to give the exact optimal solution, while QAOA provides an alternative approach which may have a speedup advantage over classical ones to solve these hard problems.\n",
+    "\n",
+    "QAOA works as follows: The above optimization problem is first mapped to another problem of finding the ground energy or/and the corresponding ground state for a complex many-body Hamiltonian, e.g., the well-known Ising model or spin-glass model in many-body physics. Essentially, it is transformed to find the smallest eigenvalue and the corresponding eigenvector(s) for a real diagonal matrix $H$. Then, QAOA designates a specific routine with adjustable parameters to approximately find the best solution. Moreover, to accomplish the task, these parameters could be updated via some rules set by fast classical algorithms, such as gradient-free or gradient-based methods. Thus, it is also a quantum-classical hybrid algorithm just as the variational quantum eigensolver (VQE).\n",
+    "\n",
+    "Here, the Max-Cut problem in graph theory is used to explain how QAOA works."
+   ]
+  },
+  {
+   "attachments": {
+    "ring4.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "# Example\n",
+    "\n",
+    "##  1. Max-Cut problem\n",
+    "\n",
+    "Given a graph $G$ composed of $N$ nodes and $M$ edges, the problem is to find a cut protocol which divides the node set into two complementary subsets $S$ and $S^\\prime$ such that the number of edges between these sets is as large as possible. For example, consider the ring case with four nodes as shown in the figure.\n",
+    "\n",
+    " ![ring4.png](attachment:ring4.png) \n",
+    " \n",
+    "\n",
+    "Thus, given a cut protocol, if the node $i$ belongs to the set $S$, then it is assigned to $z_i =1$, while $z_j= -1$ for $j \\in S^\\prime$. Then, for any edge connecting nodes $i$ and $j$, if both nodes are in the same set $S$ or $S^\\prime$, then there is $z_iz_j=1$; otherwise, $z_iz_j=-1$. Hence, the cut problem can be formulated as the optimization problem \n",
+    "\n",
+    "$$ F=\\min_{z_i\\in\\{-1, 1\\}} z_1 z_2+z_2z_3+z_3z_4+z_4z_1.$$\n",
+    "\n",
+    "Here, the weight $q_{ij}s$ are set to $1$ for all edges. Indeed, any feasible solution to the above problem can be described by a bitstring $ \\boldsymbol{z}=z_1z_2z_3z_4 \\in \\{-1, 1\\}^4$. Moreover, we need to search over all possible bitstrings of $2^N$ to find its optimal solution, which becomes computionally hard for classical algorithms.\n",
+    "\n",
+    "Two methods are provided to pre-process this optimization problem, i.e., to input the given graph with/without weights: \n",
+    "\n",
+    "- Method 1 generates the graph via its full description of nodes and edges,\n",
+    "- Method 2 specifies the graph via its adjacency matrix.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate_graph(N, GRAPHMETHOD):\n",
+    "    \"\"\"\n",
+    "    Args:\n",
+    "        N: number of nodes (vertices) in the graph\n",
+    "        METHOD: choose which method to generate a graph\n",
+    "    Return:\n",
+    "        the specific graph and its adjacency matrix\n",
+    "    \"\"\"\n",
+    "    # Method 1 generates a graph by self-definition\n",
+    "    if GRAPHMETHOD == 1:\n",
+    "        print(\"Method 1 generates the graph from self-definition using EDGE description\")\n",
+    "        graph = nx.Graph()\n",
+    "        graph_nodelist=range(N)\n",
+    "        graph.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0)])\n",
+    "        graph_adjacency = nx.to_numpy_matrix(graph, nodelist=graph_nodelist)\n",
+    "    # Method 2 generates a graph by using its adjacency matrix directly\n",
+    "    elif GRAPHMETHOD == 2:\n",
+    "        print(\"Method 2 generates the graph from networks using adjacency matrix\")\n",
+    "        graph_adjacency = np.array([[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0]])\n",
+    "        graph = nx.Graph(graph_adjacency)\n",
+    "    else:\n",
+    "        print(\"Method doesn't exist \")\n",
+    "\n",
+    "    return graph, graph_adjacency"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this notebook, Method 1 is used to process and then visualize the given graph. Note that the node label starts from $0$ to $ N-1$ in both methods for an $N$-node graph. \n",
+    "\n",
+    "Here, we need to specify:\n",
+    "\n",
+    "- number of nodes: $N=4$\n",
+    "- which method to preprocess the graph: GRAPHMETHOD = 1 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# number of qubits or number of nodes in the graph\n",
+    "N=4  \n",
+    "classical_graph, classical_graph_adjacency= generate_graph(N, GRAPHMETHOD=1)\n",
+    "print(classical_graph_adjacency)\n",
+    "\n",
+    "pos = nx.circular_layout(classical_graph)\n",
+    "nx.draw(classical_graph, pos, width=4, with_labels=True, font_weight='bold')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Encoding\n",
+    "\n",
+    "This step encodes the classical optimization problem to its quantum version. Using the transformation $z=1\\rightarrow |0\\rangle = \\begin{bmatrix}1 \\\\ 0\\end{bmatrix}$ and $z=-1\\rightarrow |1\\rangle = \\begin{bmatrix}0 \\\\ 1\\end{bmatrix}$, the binary parameter $z$ is encoded as the eigenvalues of the Pauli-Z operator acting on the single qubit, i.e., $z\\rightarrow Z=\\begin{bmatrix} 1 & 0\\\\ 0 & -1\\end{bmatrix}$. It yields that the objective function in the classical optimization problem is transformed to the Hamiltonian\n",
+    "\n",
+    "$$H_c= Z_1Z_2+Z_2Z_3+Z_3Z_4+Z_4Z_1.$$\n",
+    "\n",
+    "Here, for simplicity $Z_iZ_{j}$ stands for the tensor product $Z_i\\otimes Z_j$ which represents that Pauli-Z operator acts on each qubit $i, j$ and the identity operation is imposed on the rest. And the Max-Cut problem is mapped to the following quantum optimization problem\n",
+    "\n",
+    "$$ F=\\min_{|\\psi\\rangle}\\, \\langle \\psi| H_c |\\psi\\rangle$$\n",
+    "\n",
+    "where the state vector $|\\psi\\rangle$ describes a $4$-dimensional complex vector which is normalized to $1$, and $\\langle \\psi|$ is its conjugate transpose form. It is equivalent to find the smallest eigenvalue $F$ and the corresponding eigenstate(s) for the matrix $H_c$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def H_generator(N, adjacency_matrix):\n",
+    "    \"\"\"\n",
+    "    This function maps the given graph via its adjacency matrix to the corresponding Hamiltiona H_c.\n",
+    "    \n",
+    "    Args:\n",
+    "        N: number of qubits, or number of nodes in the graph, or number of parameters in the classical problem\n",
+    "        adjacency_matrix:  the adjacency matrix generated from the graph encoding the classical problem\n",
+    "    Return:\n",
+    "        H_graph: the problem-based Hamiltonian H generated from the graph_adjacency matrix for the given graph\n",
+    "        H_graph_diag: the real part of the problem-based Hamiltonian H_graph\n",
+    "    \"\"\"\n",
+    "\n",
+    "    sigma_Z = np.array([[1, 0], [0, -1]])\n",
+    "    H = np.zeros([2 ** N, 2 ** N])\n",
+    "    # Generate the Hamiltonian H_c from the graph via its adjacency matrix\n",
+    "    for row in range(N):\n",
+    "        for col in range(N):\n",
+    "            if abs(adjacency_matrix[N - row - 1, N - col - 1]) and row < col:\n",
+    "                identity_1 = np.diag(np.ones([2 ** row]))\n",
+    "                identity_2 = np.diag(np.ones([2 ** (col - row - 1)]))\n",
+    "                identity_3 = np.diag(np.ones([2 ** (N - col - 1)]))\n",
+    "                H += adjacency_matrix[N - row - 1, N - col - 1] * np.kron(\n",
+    "                    np.kron(np.kron(np.kron(identity_1, sigma_Z), identity_2), sigma_Z),\n",
+    "                    identity_3,\n",
+    "                )\n",
+    "\n",
+    "    H_graph = H.astype(\"complex64\")\n",
+    "    H_graph_diag = np.diag(H_graph).real\n",
+    "\n",
+    "    return H_graph, H_graph_diag"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The explicit form of the matrix $H_c$, including its maximal and minimal eigenvalues, can be imported, which later could be used to benchmark the performance of QAOA. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "_, H_problem_diag = H_generator(N, classical_graph_adjacency)\n",
+    "\n",
+    "H_graph_max = np.max(H_problem_diag)\n",
+    "H_graph_min = np.min(H_problem_diag)\n",
+    "\n",
+    "print(H_problem_diag)\n",
+    "print('H_max:', H_graph_max, '  H_min:', H_graph_min)"
+   ]
+  },
+  {
+   "attachments": {
+    "circuit.png": {
+     "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/wAAAEwCAYAAAAKFHodAAAAAXNSR0IArs4c6QAAAAlwSFlzAAAXEgAAFxIBZ5/SUgAAQABJREFUeAHsnQe4FEXWhuveS84ICiISlShRkSCSDCCCEs2ouIjur655F+MdE4iRxRwxoLKCEnQxB1hAxEBGQclBQHK+pP7P19BjT0/33AndE3q+ep5iuqurTp16ay49p8IppRhIgARIgARIgARIgARIgARIgARIgAR8RyDHdy1ig0iABEiABEiABEiABEhAqWMEQh5BkAAJeE7gkNSwxfNaWEFcBGjwx4WNhUiABEiABEiABEiABNKUQA/R6zmJNdJUP6pFAn4ksEoadYPEj/3YuExuEw3+TO496k4CJEACJEACJEACJGAmUFduFkksZk7kNQmQQFII7JdaGklcmpTaWElUBHKjysVMJEACJEACJEACJEACJJD+BC4UFWnsp38/UUN/EsDfHv4GGdKIAA3+NOoMqkICJEACJEACJEACJJAQgXIJlWZhEiCBRAnwbzBRgi6Xp8HvMlCKIwESIAESIAESIAESIAESIAESIIF0IFAkHZSgDiRAAiRAAiRAAiRAAiTgIYE9OTk5ezyUT9EkkFUENE0rJQ1GZEhzAjT407yDqB4JkAAJkAAJkAAJkEBiBPr16zdr7NixnRKTwtIkQAIGgf79+387bty4TsY9P9OXAJf0p2/fUDMSIAESIAESIAESIAESIAEXCCxZskStXLnSBUmZJ+LgwYPq+++/Vzt37sw85alxwgRo8CeMkAJIgARIgARIgARIgARIgATSkcCePXvUddddp+rXr69at26tcJ9tYeTIkapNmzaqbt26atKkSdnW/KxvLw3+rP8KEAAJkAAJkAAJkAAJkAAJ+I/A2rVr1ZlnnqlefvllvXGy71zl5maf+XPcccfp7f/zzz9Vr1691EMPPeS/zmaLHAlk3zfeEQUfkAAJkAAJkAAJkAAJkAAJ+IHA77//rtq2bat+/vlnvTkVKlRQX3zxhSpRooQfmhdTG6644gp1++2362Uw6HH//fer66+/XuGawf8E6LTP/33MFpIACZAACZAACZAACZBA1hBYvHix6tKli1q3bp3e5mLFiqkPP/xQNW3aNC0Z/PHHH2rGjBlq48aNavPmzWrr1q36wEStWrVUzZo1VbNmzVSVKlUS0v2JJ55Qe/fuVc8//7wu56WXXlL79+9Xr732mpITLBKSzcLpTYAGf3r3D7UjARIgARIgARIgARIgARKIkgCW8Z9zzjlBYx/FXnnlFdW5c+coJSQn27Zt2xT21r///vtq4cKFESstUqSIuuCCC9TgwYNV165dI+aN9BD1rV69Wn300Ud6tlGjRqny5curp59+OlIxPstwAjT4M7wDqT4JkAAJkAAJkAAJkIA3BEaPHq0vCcfeZ6+XP5cuXVpVrFhRj1h+Xq9ePXXqqaeqcuXKedM4H0rdsWOH6t69u27UGs3Lz89XV155pXGb8k94zH/88cfV8OHD1fbt26PSB2WwQgGxT58+CoZ6PN+LvLw8NWbMGNWpUyf1ww8/6HWPGDFCnXDCCeqOO+6IShdmIgESIAESIAESIAESIAESIIFUEQhIxdiYHBL79ev3jRjsMQVZZh0iwyozGfey1Fpr0KCBdtVVV2mTJ0/WxPCLqQ3ZlPnw4cPaeeedF9Jnl19+eVohWLRokXbaaaeF6FimTBntxhtv1N544w1Njs7TZBBAk1l47euvv9aeffZZ7aSTTgrJj+8d0iAr3rBhwwatWrVqQbn4nn388ccxicPflMPfQEDSGUiABEiABEiABEiABEiABEjAdQIBkRg0ZIzreAx+2QceJseQl6pPGGn/+te/NBhsDKEEHn744ZD+qlGjhiYz/qGZUng3ceJETVZxBHWEoX/XXXdpmzZtiqjVvn37tGHDhmklS5YMlsX3D0Y/BgfiDRhAMn+PZXWJtnz58qjF0eAXehkSuKQ/QzqKapIACZAACZAACZAACSSPAJbUw7HZypUrVUFBge7wDM7U1q9fr+bOnau2bNlSqDKNGjXSPcWXKlVKYR82nKMhHjhwQJcJp2mQvXv3bvXrr7+q3377TclMtaNcOKHDUvAXX3xRP1rt//7v/xSWaWd7+OabbxSW7psD9u2XLVvWnJSya3yP0FdG37Zv31598MEHyjguL5JixYsXV0OGDNG3esCzvhFwCsGgQYN0HwBGWiyfshpCXXvttbp/A5TDd7tv377qu+++U3ByyEACJEACJEACJEACJEACJEAC6UYgIAqFzFziPp4Z/sKmOnv27BlWj7lu2TeuYZl5LEEMf23WrFmaGKuaGGMhM8Jm2ca17PHXZBAglip8lxez3LIHPaQvrrnmmrRp53vvvafl5uYG9RswYIAmgzwx64fvUseOHYNyjO/AV199FbMsowBWQMhJACEy77vvPuNxxE/O8EsPMJAACZAACZAACZAACZAACSSVQEBqCzFgcO+Fwf+Pf/wjrB5z3UuXLo1oMEXzUI5o02CAySy+Y10w2LD9IFvD3//+9xA2MP7FA35a4Jg5c6ZWtGjRoH733HNPQnpNnTo1KMv4rl188cUJybQu7Ye+c+bMKVQmDX7pAQYSIAESIAESIAESIAESIIGkEghIbWFGkRcGf5MmTcLqMeqGoz03w3//+18Ne74N+dbP6tWra7LFwM0qM0LWtGnTNDicM/N455130kL3Xbt2hTjcu+KKKxLWS5bdh7QV7Zbl95qcIpGQ7A4dOoTIbdGihSbbTiLKpMEv9DMk5GaInlSTBEiABEiABEiABEiABNKCgDhaUwsWLHDUpUuXLo7P4nmAo+ZeeOEFx6Jr1qzRz2h3zODDB9gPjz3tYpUGW1e/fn11ySWXBO9TeXHrrbcq7LNHaN26dXCvfCI64bjGqlWrhoiAH4jZs2eHpMV6M3To0JAikPfqq6+GpPEmcwnQ4M/cvqPmJEACJEACJEACJEACKSAgS6tDDE2rCjjn3O0gR8wp2bPvKHbcuHFK9nM7Pvfbg9GjR4cNutx7771K9sunvKmTJk0KGviVKlVS48ePVyVKlHBFr0OHDoXJWbFiRVhaLAlnnHGGwqCSOTzwwAO6M0lzGq8zk0Dq/yIykxu1JgESIAESIAESIAESyFIC3377bcSWi3O1iM/jeQjv/gMHDoxY9OWXX4743C8PccpBIBAIaQ5OVbj00ktD0lJxI8vrde/5Rt3ig0Edf/zxxm3CnwcPHgyTsWrVqrC0WBMeeuihkCI4jeKJJ54ISeNNZhKgwZ+Z/UatSYAESIAESIAESIAEUkQAx8A5BRzFF81xa07lI6VjyXqkMGHCBP34wEh5/PAMR+7JmfEhTRGHeGlxROGwYcMUjH6Ek08+WT+OL0TRBG7kRAL9+DyrCPHvYE2K+b5ly5bq9NNPDykHgx/H9TFkNgEa/Jndf9SeBEiABEiABEiABEggiQSwf3/hwoWONXqxnN+orEaNGsal7Sf2cye6vNtWcBolYs++deb5mGOOSYu9+3/88Yd68cUXg7QeffRRJV7vg/eJXixbtsxWRMWKFW3TY00cPHhwSBFxPKjefvvtkDTeZB4BGvyZ12fUmARIgARIgARIgARIIEUEpkyZkvT9+0ZTYYAVFvxu8GN1hXV2H476xFt9YWg8f47Z/b179+r1tG/fXvXp08fVOuW4PFt5WFXiRgDHsmXLhoii874QHBl5Q4M/I7uNSpMACZAACZAACZAACaSCQCr27xvtXLt2rXHp+Llv3z7HZ3548Prrr4c1Y8CAAWFpyU7ASQmGDwX4W3jyySddV+HNN9+0ldm4cWPb9FgTS5curS677LKQYvPnz1fff/99SBpvMosADf7M6i9qSwIkQAIkQAIkQAIkkEICkQx+L/fvo8k//PBDoS2vXbt2oXkyNQP2sH/44Ych6mOffJs2bULSUnGDo+0KCgr0qjFTbt0Pn6hOOOIPq0usoVmzZsqtJf2QfcUVV1irCJ44EPaACRlBgAZ/RnQTlSQBEiABEiABEiABEkg1AThjS9X+fbT966+/LhQBDGC/hvfeey+4ZN5oYzrM7mNVxTvvvGOopPLz84PXbl3YrWyAbDgrdDO0bds2bABhzJgxaufOnW5WQ1lJJECDP4mwWRUJkAAJkAAJkAAJkEDmEkjl/v3du3erWbNmRYRXt25dhWXZfg12Rm+PHj1S3tzJkyerHTt26Hp06NBBFXaaQqwKY2XDqFGjwophRUnfvn3D0hNJyMvLU+eee26ICHz3MNjCkJkEaPBnZr/FqnVO/QuGl0WUgjmxFmZ+EiABEiABEiABEiABpSIt5wcfLz30jx07VuH8+Ujh+uuvj/Q4o58tWLAgbEsDvPNjSXuqA2bAjTBo0CDj0rXPm2++Wa1fvz5MXiAQULm57ptz5513XlhddoMtYZmYkJYEiqSlVlQqQQL985r1bnOeptSF4jSkrdj49USgfiZIsz5Py5tCWyJHmnwnlv/EueNnfqLU2EMJVsjiJEACJEACJJA6AqcOLtqkau0y89cv36V+ejmyRZQ6LVmzDwhEMvjhOO3YY4/1rJUjRoyIKBve1a3HqkUskGEPP/roozCNMcDihcEbVlGEBJyc8PHHH+s5ypQpo/r16xchd+yPxo8fr+yc9d1yyy2qf//+sQuMokS3bt0UHA/iCEQjwH8EVhqUL1/eSOJnhhCgwZ8hHRWVmp0CRZpWKHut/IXeJfFEYypf/la1wwePeGzNLVKiiPwBN0YUmYOa9m67Wmlths2bMPNlGv5RUWYmEiABEiCBFBNo0HtopaKq5CU5OVp3UaVljsqpCpWa1WyotJpPYRrsZ03LmXxA7R3z6/i7N+MZAwkkSmDjxo1q0aJFjmK8nN3HUXRz5851rBsPhgwZosqVKxcxTyY/nDp1apj6Xbp0CUtLdsKkSZOCfgWwFL5kyZKuqbBhwwZ13XXXhcnr1auXJ6cAGBVVqVJFNWnSRM2bN89IUocPH1bTpk1T559/fjCNF5lBgAZ/ZvRToVo2vvCJRkVy896RBfvNkXnfzo1q66of1M6Ni9W+7X/kiMWvy8jJLZpTonxVVfa4+qpijVaqRNnjTpTBgeeb9W43+ODh1pcvnHiH85usUC2YgQRIgARIgAS8I9C461PH5JbUArk5OYOkFvlVfWRoWzt8SB06WKDyihRXObl5MP67y+RU9+KqxONNej356uG9OYGFn922xTvNKDkbCMDgNM94WtvslcF/6NAhdd9991mrC7nv2rWrbvCHJProBgymT58e1qKzzjorLC3ZCZ999lmwygsuuCB4nejF4sWLVc+ePRUcRZoDvP+/++67nq9saNmyZYjBDx3+97//0eA3d0aGXNPgz5COiqRm0wuf6qnyFDxplC7YvUn9MX+S2r5uvm0R7bDMd2xdrceNi79U5as1Ucc3uUAVL125eV5e7iyRdem8ibeFr5mylcZEEiABEiABEkgOgWa9n4RnrlFi0VfGyrWdGxapbatnq12bl6oDe7YGlShaqqIqU6muqnBiC1W2SqMSubk5N+WW0i6V8gPnjr/9yLrbYG5ekED0BDDLHil07Ngx0uO4n8Hju52xawisUaOGGj16tOcGoFFfKj7nzJkT5iUeqxkaNGiQCnVC6jS+F1gC3707Fh2FB3jxxwkLv/76q1q7dq3CPQYxsBoA7cAy+Vq1aikMGsEvwZdffqkv19+2bVuIMPgrwNYGN1cRhFRguoHB/8Ybb5hSlLJbZRGSgTdpSYAGf1p2S/RKNe31ZN+c3Jz/SIm8LTKjv3b2OHX40P6oBWBgYOeGxeqEFv3UMTValZaBg/Ei8+J5E27/IGohzEgCJEACJEACHhJo0vvJf4mh/yiq2LlxiVo7d3xOwc5wB1Z4DuN/654f1dbVP6oS5armVGvaW1a11ZNBgpxJIueu+eNvH458DCQQK4FU7N+H4Tds2DBHVWHwYoa5cuXKjnn88MDO0ISH+lSHZcuWqdWrV+tqnHLKKbY+HODQ79Zbb7V1umfVH4MG8PCPgQFrgOO+4cOHq+LFi1sfeXLfokWLMLk//vij2rNnjypVqlTYMyakL4Hc9FWNmhVG4JQLn2yncnPelXx5G379XK3+8d2YjH1DPgYIUBYyIAsyddlGBn6SAAmQAAmQQIoINO395D25YuzLUmptnaxgWzbtBeVk7FtV3LdjvZ4f5cRhrbzech+FPGs+3pNAYQRSsX//008/1Wd5sXfaLrRp00bfU40Zfr8HO4MfThJTHYzZfejRuXPnMHX27t2rbrrpphBjv0iRIvosfsWKFfUjFM1OB7FlxGrsYzAHx/7BaWOyjH00pHnz5mGrRnBKxMyZM8PayYT0JkCDP737x1E77GPMy80dK46Kiv35+xS1fpE4208wQMafv0+VHZE5xSAbdSQoksVJgARIgARIIG4CTXs9cWlOTu7DMPZX/fB2zp+/RV5S7VQRyqE85EBe095PXeKUl+kkYEdgypQpdsnBNDf37x88eFA9+uij+l5p65JuVFi6dGk1dOhQhRUHlSpVCurg5wu7LQ2YUU91MK/6sDP44eRx06ZNQTWxdB8e8JG3Q4cOqnXr1oU6WqxXr55Kha8CnDhw0kknBXU3Luz6wnjGz/QkQIM/PfulUK3ySqmnxDKvtmvTUrVu3sRC80ebYd28CQoyIVuvI9qCzEcCJEACJEACLhJocv7TdVRunpwgo2QJ/wc529bMTkg6yq+d++ERL385Oa/o8hOSyMLZRMBs2FnbjWXYbuzfl/Eo9d577yksVb/rrrt0r+jWui677DIFZ254nszZXqseybzfunVrmOM61J8OM/zG9wKz9HbfgYYNGyrzCgwca4cj/D744AM1ceJEfV+/3aCOme+MGTP0wZ/du3ebk5NybWfwL1myJCl1sxL3CHAPv3sskyapaZ+nW8rKxCsPHzqgrf7pPfnx8tcZmYkroSmRqeqfPUTLyS1ypdQ1ct6Ht/6cuFxKIAESIAESIIHoCeQUV8/LC67M1tU/q83Lwr1zRy/pr5ybl01TpSvVVhVPbFlGiXx50u2vp7wiAWcC5qXb1lww0I899lhrclT3MPJx3B6WbMPYX7BggW05OFAbOXKkOuOMM2yf+zlx+fLlts2zM0ZtM3qU+Pvvv6s1a9bo0rH8HUv0rQF73efPn68b+fC1AI/7O3fu1E97wCABlvfDAd9xxx2nD2Bg1h8rF7ACYNasWUFx8OVw9dVXq7FjxwbTknFRvXr1sGqc+iMsIxPShgAN/rTpihgU0VS+DCbn/Ll0qtq/2/3jhSFz09IpOcfVO0v+Q1L5otmFMWjHrCRAAiRAAiSQEIEmFz59thj7XQ/u36MFZ+UTkvhXYZEn3vsbaEWKleqKeuZPvPXLv57yigTCCeAs9F9++SX8wdEUGOPWo9OsmeGVHXLgCwCfiJgphRG4bt06a3b9HisH2rVrp6655hrd2DPv9bYt4NNEJwPTzsBOJgJjdh912i3nN3SBF36szECMNsATP5b7r1ixIlhk3Lhx+qDQpZdeGkzz+sLO4Dfr5HX9lO8OARr87nBMmpSG3Z+oqXK0HocPHdY2LvnmyNJED2oX2apy3U5aTl5uD9T5y+Q7VnpQDUWSAAmQAAmQQBiBnFztXuwt27j4q5xD+91dxgp5kFutSU9x/I96FA3+sB5ggplAYfv33377bYXoRsjLy9P3dvft21f16dNHHX/88W6IzWgZdgY/BkNgSKcyRGvwx6MjZvyfeuop/TtgLn/DDTfogwtVq1Y1J3t2bWfwY4CqoKDAszop2H0C3MPvPlNPJRYrnnupTO7nbl872/UfQWbF8YMIdaCuIsVz6NzIDIfXJEACJEACnhFo0vOJBvJjvuOhAwUaluB7ESAX8lEP6vOiDsr0DwGzYed1q3DuOc5rh2FHY/8IbRx9Zw1ly5YN8yBvzeP1vbHNA4M0Z555puvV9erVSzVr1ixELvwZvPjiiyFpXt7YGfzYhrJyJecBveTutmzO8LtN1GN5msq5ANP629bO9bimI3VUrHGazLHkYkk/zy32nDgrIAESIAESyCl6ZJB525qfcnBsrBcBciG/Uu126mh9AS/qoUx/EIhk8MNx3N13311oQzEjCm/tWPr//fffq++++07hiDNrGDBggL5P+7nnnlN2xpY1fzbc283ww9t9KsNvv/0W3Ipx6qmnerLaAKsYBg4cqG655ZaQpmJQ6P7770/KgIfTd5DL+kO6JO1vaPCnfRf9pWCtToES8rd/moysabs2LvFsOb9Ro9QBpyKYATkNda/4NrDPeMZPEiABEiABEvCEgJbbQ0aaZZXZPE/EG0K3r5uvYPAr1KdUwEjnJwmYCaxfvz7i/v0ePXrEtDfbkL1jxw4Fo3748OEKntvNYdKkSQqzx59//rlq06aN+VFWXm/eHO6vqkKFCillYczuQ4lI+/cTVdKu/zG7/tVXX6lzzjknUfGFlncaWIEPCobMIcAl/ZnTV6r0MWWaiLpF9+34w7NZDzMOzICgLtR5tG7zY16TAAmQAAmQgKsEqvUMlJKB7eba4cOafkSsq9JDhe3683eFelAf6g19yjsSOEKgsP37nTp1igsV9p/jaD146K9fv36YDHhy79mzp4In+GwPe/bsCUOQaoPfvOrDS4O/RYsWCjP91oBBoWQEnCBgF+z6xC4f09KDgDHDjxdd6fRQiVo4ETi0e1vzIqUrqYKdG52yuJ6OukqWr6ZQtwhf4XoFFEgCJEACJEACRwmU3LnlVHVM+by9O9aJMX7QUy6Qj0HtkhVOyJN6O0hlP3laIYUni4Dt4M3hw4eLxqOA2bCzlseRau3bt7cmx3Rfs2ZN/Ug+nNe+f3/oFhZsAejWrZu+/D/eY/9iUiZNM9sZl04zz8lqgvG9KFq0aMLfgUg6FytWTMFfAVaEmIPdNgfzc7euIxn8Ef6m8DcY3zmVbilOOQYBeFfcYRj8d8pNwHjCz/QksEmO4TuhaW91YF/o0i8vtTXqkrpflnoQGUiABEiABEjAEwKbf/+fKnN6bbV/15+eyLcKLZB6xOBXUu8n1me89xcBWRYe1wH2hmFnRwN7t8uUKWP3KKa0OnXqqP/7v/9TI0aMCCu3dOlSNXjwYDV+/PiwZ9mSYGfwp3KGf/HixeqPP/7Q8bdq1UqVLu3tnClWg1gN/mQ5zStevLi+wkB2+IZ83dAnEf6mYFciMqSewARRoTeX9Ke+I6LWIDevmJ738MHQEeCoBcSR0ajLqDsOESxCAiRAAiRAAlERKFKirJ7vwN7Q2ayoCseR6cDeIwPoRr1xiGARHxPA/v1ff/3VsYXxLue3E3jvvfcqrBiwCziTffXq1XaPsiLNzuBP5Qy/eRDIy+X8RudaV34gPVlO87CdAEa/Ndj1iTUP79OHAA3+9OmLwjUxRtds9vIUXjjOHEZdRt1ximExEiABEiABEiiMgDG47JV3fmv9Rj1GvdbnvM9uAl7t37ejWqlSJVW7dm27R+rQoUO6537bh1mQuHfv3rBWYtY7VSHZBv+2bdvCmrpr1y6VLKPbzuB3Y2VLWKOY4BkBGvyeoXVfsPHDJK9I+Eib+7UdkWjUZdTtVT2USwIkQAIkQAJyNMwRCMZgs9dIjHqMer2uj/IzioDZE7tVcTf271tl1qpVy5oUvM9m5325ueHmCgZBUhUMgx+GcLt27TxVA0a93Qw/Ks3Ly/O0bkP4vn3hh3TZDUIY+fmZfgTC/4LST0dqdJTAgb1HRviKlqyYNCZGXUbdSauYFZEACZAACWQdAWNwOVkz7kY9Rr1ZB5wNjkjAMOzsMp122mmu7N83y7abyTaeJ2sJt1FfOn2WKhXuh9F6lGGy9MUWD2z1QGjdurVycmrnlj7r1q2zFQUnjnYz77aZE0gsKChQiNZQokQJaxLv05iAsVlot+iYHA85aQwj3VXbv3sLhvKOKVGuStJUNeqSurdIpakbTk1ai1kRCZAACZBAqggc3L8bzmrKFyuVnIFto56DBbuwmT95DnJSBTg76oV1GOZFTWaJ0b9HnCFFwQFO2eCczSm4uX8fdcAp2vz5852qS9rybUcFUvgABr91RjlVBr951Ucy9u/PnDnTlvzJJ59sm+52ohNn9EmEvynYleFnKbqtHOVFQ0B3VGMY/E9ICUSGNCawt8W1RZSmthcvc2ypvGKl1KH93v4toQ6pS95Cao/UXUV9G/D2jKQ0Zk/VSIAESIAEvCdQs8XlLaSWn4uXPc77yqQGo56aLa/ovG3N7NlJqZSVeE0gIBXkWyuRPfIzJK2TNd3pPpn796HDL7/8opyMKzzP5j3T6TTDb171kQyDf/r06ej+sJAsg9860GIogj6J8DcFmzJg5OVn6glwSX/q+yB6DY4Y3PpfftkqDaMvF2dOUx3TaezHCZHFSIAESIAEoiYwd+3iBTLRWVC8TBUtt4i3S0YhH/VoStuHeqNWkhmzgoDZsLM2GPv3zzgjrlP+rKKC94UNMKTyGLqgkim6SBeDH6swjO8FlvK3adPGcyIzZmCcKjwky+B3GoSy65NwLZmSLgRo8KdLT0Sph5aj4TxFVfHEllGWiD+bUYdRZ/ySWJIESIAESIAEoiDw08sHZFnZTPGll1O2Sv0oCsSfBfJRj6xi+17p9cYviyX9R8C8dNvaOi/27xuGpLUu4/7EE080LrPu0251g5Mh6iUcrMLYuHGjXgWMfa/30G/YsEEtWGA/Fnn22Wd72dSgbKcZ/tKlw3bNBMvwIv0IGEv6008zamRLYL+27z/Fcko8KbPvxYuVqpSzf89m23yJJopsJXVg5qMAdSYqj+VJgARIgARIIBoCOZr6SMzwjhVOaKa2r50bTZG48kA+gl5fXBJYyK8E4ChtyZIljs1ze/8+Kpo6dapjfXhQo0aNiM8TfQiv9zgJYNmyZQqGJupr0qSJgnO4SOHgwYM6KxjD8ChfvXp1VbduXVf1tRvs2LFjRyS1PHlmHpRp1uzI/x+eVHRU6OjRo9Xhw4fDqsDsPhwGJiM4DayccMIJyaiedbhEgDP8LoFMlphfx9+9WdNy3s2RUKXhuZ5VC9moA3WhTs8qomASIAESIAESMBHYe1CNkdtD5ao11YoUL2N64t4l5EI+6jlan3vCKSnjCRS2vN5tg3/p0qVBz+9O8GrWrOn0KKH0TZs2qfz8fN1Ab9CggerevbsaOHCgOuuss9Rxxx2nqlWrph5//HF14IAsvjEF3D/33HOqdu3aqnHjxqpfv37qyiuvVF26dFHQ9cwzz1Tvv/++qUT8l3bHFToZovHXUnhJs8GPNnsd3njjDdsqrrjiCtt0LxKdOKPfGTKHAA3+zOmroKY5Bw8+LDcHKtZopZU6xv0XAGRCNuo4Wlewbl6QAAmQAAmQgJcElnx821pZXjYxNzcv59iTO3tSFeRCPupBfZ5UQqEZS8Bs2Fkb4cX+/WnTplmrCbv3wuCfM2eOOvXUU9WDDz6ozMe/mY9cw2kF//znP1Xz5s0V8iNgdh0DAzfeeKNas2aNngYu4sRNv8Y/aNPFF1+shgwZEkyL98LOuNy5c6ft7He8dRRWzrx/H3nLlStXWJGEnv/444+2y/llLk5dfvnlCcmOpbDdkv5ixYrpA0GxyGHe1BKgwZ9a/nHVPu+jO5fLfzyPYwb+xFMvU7lFisclx64QZEEmZKMO1GWXj2kkQAIkQAIk4BWBQ9qBh7CnrHLdjlqx0pVdrQbyIBfyUY+rwinMFwQiGfxe7N+PxuDHUnk3w7hx43THg6tWrdLFYvn+hx9+qC/n37t3r8J58x07dgxWuWjRItWrVy/1559/qq5du6ovv/xSf4al3ZjJhwGO1QLvvvtusAwuhg8frmYneACGncGPP2A7YzSkchdv0H603Qjr1683Lj35fOSRR2zlDho0SN8yYfvQg0S7GX4MPsmRfB7URpFeEWBveUXWY7l79i1/UKbg55WQo4tqtJKlPTkudKXIgCzIhGzU4XEzKJ4ESIAESIAEwggsnPDPOeJN743cvDwZ2L5EnueE5YkvIUcGtS9RkAv5qCc+OSzlVwKp2L+P2dxIAU7rypcvHylLTM+effZZddFFF+l77osWLapGjBihG+W9e/fWl/FDWP369fUBAPMe/pUrV+rPjbPhGzVqpBYuXKj69++vsCoARvDtt98epstXX30VlhZLgt2SfpT/7bffYhGTUF6rE0f4O/AqoK4JE3Qf3SFVHHPMMWrYsGEhaV7f2A1s2A3AeK0H5SdGwAUrMTEFWDo+Ar9/8kzBoYNaX5mg2FL++FNUzVYDxObPi0+YlEJZyIAsyDx8+EAf1BG3QBYkARIgARIggQQIFKh9d4rH/rVlKtdV1ZpcmICkv4pCDuRB7hH5fz3jFQmAQKTZfTx3e/8+nOXB4V2kcPzxx0d6HPIMM/bvvPNO0Jt8yEO5gYF+xx13KMyQy2JO9dZbb6mbb75Z5eWF/4aEgYml+3YBAxAwSs0DES+++KLCFgBrwMx/IgEzytDVGrAKIVnB+r3warAB34dbb73VtlmY9Tdvm7DN5HIiVjZYQ506daxJvE9zAjT407yDIqm3cNJtvx9Sh7uJhb6jQvXmqu6ZN6qipSpGKmL7DGVQFjIgCzIXTPjnUtvMTCQBEiABEiCBJBDQHcZqhy+RQej9x57cUVVp2DWhWlEeciBPiVw6pE0Ip28LWw07c0O92L+PZeIFBZHnV+A8L5oAY7F9+/YKTt2w794a4FH/qquuCtb373//W11yCVbQOAenrQSYybeeBY/BBLvQtGlTu+So03D8HVYcWENhAyXW/PHeY3DE6sgx0ikO8daDctddd52aOzf8dBJsoxg8eHAiouMqa2fwJ9qfcSnCQgkRoMGfEL7UF1744R0/HD6stZf/jFaXrlRL1T97iFalwbkqt2iJQpVDHuRFGZSFDMiCzEILMwMJkAAJkAAJeExg7vg7psmpVAOkmkNVG3aT5fiXqpy8ojHVivwoh/KQA3mQG5MQZs4aApEMfi/279vtkbbCrlw5Oj8WkydPVqtXr7YWD94/88wz6qefftLvzzjjDHXTTTcFnzldmPetG3mwGuCaa64xboOf9erVC14bF1j+3aNHD+M27s8OHTqElU3WDP+CBQt0/wRmBXB8YaJbFczycI1Bmtdee82arFq0aKHgcyHZ++axvWXr1q1h+tj1RVgmJqQVARr8adUd8Skzf+Jt8w/tUc1l3/1/8ooUy6na6DzV6LwHNOzHF2/7qmSF6qpoyfJ6xDXS8Ax5kBdlUBYyICs+LViKBEiABEiABNwnsGDCbe8f1rS+sgRt7zE1T5dB6n+p8ifgDOzwJb6htefo+ZAf5VAeciAvNB/vSOAIAezLjrRU2+3l/Kg1mtn7smXLRtVFWFJvhLPPPtu4DH7C4DfCvffea1xG/LRzuHfeeecpu3PYsVUAz+DFHb4Bzj33XPXZZ5+54tHezshM1gy/0yDQ3XffHZFdLA8fe+wx/fhDaxlsZ/jvf/+r4Mch2cFudh9bCuC7gSGzCBTJLHWprROBhZ/dtkWeXdKk91MvyDane8WIP7viiacqxAhBDH3tS+3g4YfmT7pjaoR8fEQCJEACJEACKSMwf/xtExv1fKpV0SLaO8VLV2pWq/XVqmD3JrV9zVy1a9NSVbDrT3X40H5xxldMFS9zrL5Pv3z1Zqq44eFf0+YeOKguX/TRbfZrjlPWMlacTgTsHKWZ9bMzOs3P47muWLGivg8+0kw/DOjCwqxZs9Qnn3yiZ6tSpYqCAz5zgPO15cuX60lYqdCtm77ixZwl7Bre+u2Wl19wwQVheZGAtmCVwYEDB/TnMPrdCmeeeWaYKAzObN682fN97WaDH6cQYHXDvn37FJjjO4PTC+INON0APhRGjRoVJqJBgwZq0qRJKhYfDmFCEkiYN29eWGn0g50/hbCMTEgrAjT406o7EldGfhRNESlTTun1WF05Y7jn3q1r/yYO+U7JK1ZKF35o/x5VsHODOnRw36cVj297w/z/3rYs8VopgQRIgARIgAS8JXDEWO9/arPeba/VctSdYszXOa7+WQrRKcig9jKJj80fP/NVpcYecsrHdBLA/vOHH344Igg4sfMiNG7cWM2YMcNR9O7dux2f4QEMbBiN2GuOEAgEVOnSpfVr458KFSqoli1b6kvTnY58M/Ian/DGv3//fuM2+Nm5c+fgtd2Fm4a+Ib9GjRoKs904KcAIaC+ONLzwQnecehpyzZ+HZQ+QsX8fvgQwkII6n3/+eT0buMOJXTz72qdOnar7VFixYoW5Sv0a9bz55psq2tUdYQJcSIB+1uDFoJe1Dt6TAAnETiBfiuANYI2B2EWxBAmQAAmQAAmkA4FA7im9Hu9Uu+2gaXXa/11rcO7dWqPzAvon7pGO52L6cOtiOnRXcnUISHXW3zxav379vhFv8ZrMWGs//PCDNn36dE1mo7VXX31VE0dpmnibDytjlSNLmTU5wk6TJdaaGMOaHKenzZkzR1u8eLEmhrHYn/EF8ZQfsW4xsiIKvvLKK4PlZVZYkwGAiPmjfZifnx+Ua7AQJ37RFnc934ABA8L0ue2221yvxywQ3xej7bKlQ3+0ceNGTZwIBtNLliypiXFuLhbxGt+ZQYMGabInPyjDqEMGS7ShQ4dqMtAQUYbXD8UBpCaDRGH64TtvBPxNGXpbPgNyz0ACJJBEAvlSV9gfrKQFkqgDqyIBEiABEiABLwjwHecF1cyWGRD1w373yJ72mXbpbqWdc845hh0U8ycGC+rWrRums6EbjEBxnmYrd8iQIcFyMCBlz7xtvngSYeAaOhifMLpTFV555ZUwfWR7gqfqYIDHaPsDDzwQrEucI2q1atUKPkOegQMHauLzIJjHfCFbD7S3335ba9euXUgZQ7Ysk9cuu+wyTfxImIul7BqDYoZuxicGxeSkh6BONPiFDAMJpAmBfNEj7I9W0gJpoh/VIAESIAESIIF4CfAdFy85/5YLSNPCfvfI3uMf7dLdSkvU8BSP85psGQjT29BPjs8LmbnHzHOXLl1C8j/55JNBYyzRC9mjrpUoUSJEPnR5/fXXExUdd3nxGq/J0YghOsmJAdqOHTvilllYQdmfH6xPlriHZIdx3rBhw+Bzo69k+4F21llnaX369NFat24dsV9R5vzzz9dXioQIT/GNOBEMaxdWJZgDDX7pvQwJRTJET6pJAiRAAiRAAiRAAiRAAnEREOP1oHGsmRiNuhd5SVPYl2184hoRz+GYDOfaY388HLQVFBTo0bjG3nY8w9n2cFZ3xRVXxKWXUQjnzH/99de6HBwDZw1jxoxR2FON/f6ypFzNnz9fYX85Ao7JGz58uJLl7dZicd9///33erutAjp27GhNSto9nNfhiD+zc0X0EZwVXnTRRa7rAb7GPvZSpUopMd5D6pBVGQp99f777+v+H+AHAmHVqlV6DMlsukF/wfmdDAjoDv9OPPFE09P0uLQ7ctDuKMb00JZaFEaABn9hhPicBEiABEiABEiABEggownIcuS9MA7TOTRr1kz99NNP6oUXXlA4Ys96zjzORUc0BziLe/rpp5XM9puTE742e6Y3hMEwhYO6VIZrr702xOCHLhgM8cLgh5f6LVtwCJZSZ5xxhn7coH5j+geDSLL6Ql188cX6gA2OCly6dKkeYfjjhAXxe6DADp9wPIi+qly5sklKel2Krwu9LWatZCWDatu2rTmJ1xlEgAZ/BnUWVSUBEiABEiABEiABEvAvARiI8PyOKPuolTgX1AcBZM+4bnzKkmrdaDz55JNV165dozpeLx5adgZ/Kmf3jTagzTCc16xZYyTpM/yyrF+VK1cumObGhZlBYScTYEWILOPXoxt1p1IGBlCwesUcxD+B+ZbXGUaABn+GdRjVJQESIAESIAESIAES8D+BVq1aKcRkB2xf+O6778KqjdbgX7t2rbrjjjsUZr9lz7++TSJMWJwJWA6PpeUPPvhgUAK2WWCZv5xWEExz4yIWg9+N+tJFhjgXDFEFW1zcZhtSAW88J8DjajxHzApIgARIgARIgARIgARIIDMIOO3fj3ZJtzgP1JfZv/vuu2rRokWuN/pvf/ubPphgFoxZaTeDef9+2bJllThldFN82spasmSJmjVrVoh+3bt3V1WqVAlJ401mEaDBn1n9RW1JgARIgARIgARIgARIICYCcC4Ix37Yi968eXN10003qd27d9vKmDJlSli6+EBQjRo1Cku3JmDPuxyfpyfDGWK9evWsWRK+Fy/46txzzw2R8/nnn6tly5aFpCVyI6cgKDkKURcBB3uY5c6G8Oabb4Y1E34TGDKbQHZ8ezO7j6g9CZAACZAACZAACZAACcRNAI7lPvjgg2B5GLRwYvj8888H04yLSZMmGZfBz5YtW+onFwQTHC6effZZtWvXLv0pHNmVLl3aIWdiyTiR4NNPPw0KQVsef/xx3eFhMDGBi2+++SZYurD9+8GMGX6xc+fOMH5Y2YCTERgymwBn+DO7/6g9CZAACZAACZAACZAACTgSwH58s7FvZJw5c6ZxGfzEcv4ff/wxeG9c1KpVy7h0/IRX+yeeeEJ/XqFCBTVs2DDHvIk+OOeccxSiObzxxhtq/fr15qS4r7Nx//4zzzwTXNVggHvkkUeMS35mMAEa/BnceVSdBEiABEiABEiABEiABCIRsDPgkR/n2psDlv3feOON5qTg9Z49e4LXdhc4LvD8889XmCVGwFGBVvl25RJJe+yxx0JWHcB534gRIxIRqZfFaoGpU6fq1xi4aNGiRcIy010AVmU89dRTIWrCSaN160RIBt5kDAEa/BnTVVSUBEiABEiABEiABEiABGIjAG/5duH2228PJuO4P9w7DQ58+eWXatu2bcH85gtsD4BhaByV17NnT3X11Vebs3hyDV8El19+eYjsF154wVHPkIwRbubMmaO2b9+u54DR68QvgoiMe/Tcc8+pzZs3B/VGmzGgwuAPAvb/A/ijbWwFCZAACZAACZAACZAACWQ1Abvj9GAYd+nSReeCZfC9e/dWI0eO1O/hoA9GvNlJH4zBAQMGKDjlM8LGjRvVXXfdpXuwX7hwoZ6MI/PGjRtnZPH8E1sIKlWqFKxnx44d6p577gnex3ORbcv54ZwQJyuYA1Z6nH766eYkXpMACaQxgXzRTbOJgTTWmaqRAAmQAAmQQDQE+I6LhlJ25QlIc8N+9/Tr1+8bmcXO2nDdddeFMClZsqR29tlna2LUh6Qfe+yx2vTp03VOckSbJsZ/yHM5ok4TQ1CTPf0h6TIjrInRmBK+o0ePDtElJydHmzFjRty6iJO6oDwZ+IhbTqYUvOqqq4Ltxd+OnIKgydaMQtXH35Td35qkBSQykAAJJJFAvtQV8od89D6QRB1YFQmQAAmQAAl4QYDvOC+oZrbMgKgf9rsn2w1+2ZeuiRd77YQTTghjA14wki+88EJNjrYLMfRkb7526623aqVKlbIth7IdOnTQvvjii5Byyb4xG+nQqXHjxtr+/ftjVkP8GGjlypXT21q5cmXt8OHDMcvIpAKTJ08O69dPPvkkqibQ4JdvWoYEHsuXIR1FNUmABEiABEiABEiABEggHgLYk33HHXeom2++WWE//u+//65WrFih70+vV6+ewlnzDRo0CBMNx3tw5jZkyBA1ZcoUvdzatWuVGMOqTp06+rJvu3JhgjxOeO211xSODoRuCNhi8Oijj6r77rsvpppnz56tsC0AoVOnTiFOAWMSlAGZ0U5Z+RGi6Z133qm6desWksabzCdAgz/z+5AtIAESIAESIAESIAESIIFCCRQtWlSdd955heazZjjuuONU//79rclpcw/93n//fd1IP3DggK4XjpSDA0E494s2fPPNN8GsnTt3Dl778QLG/erVq4NNa9++vRo6dGjwnhf+IUCnff7pS7aEBEiABEiABEiABEiABLKSQLt27RSc+BmhoKBAyVL/4Ky/kR7pE6sYjOBng3/UqFHq5ZdfNpqqqlWrpsaMGaOKFOFccBCKjy5o8PuoM9kUEiABEiABEiABEiABEshWAv/4xz/ULbfcEmw+lvhjln/37t3BtEgXxYsX1x9Xr15dNWzYMFLWjH321VdfhSzlF58FSvbyK/HvkLFtouKRCdDgj8yHT0mABEiABEiABEiABEiABDKEAHwOXHzxxUFtsS//kksuUeKAL5jmdDF27FiF/HPmzHHKktHp8G3Qt29fZWx7KFasmPrggw9Us2bNMrpdVD4yARr8kfnwKQmQAAmQAAmQAAmQAAmQQIYQkBMH1Ntvv63Ei3xQ448//lh3WBhMcLiAc0Ps+a9UqZJDjsxNXr9+vTr//PPV9u3b9UaUKFFCTZgwQcnxjJnbKGoeFQEa/FFhYiYSIAESIAESIAESIAESIIFMIADnhNiTPmDAgKC6zz77rMrPzw/eZ9PFli1bdO/7K1eu1JtdtmxZ9dFHH8XlwDGbuPmlrTT4/dKTbAcJkAAJkAAJkAAJkAAJkIBOIC8vT7311lvqwQcfDB6v9/TTT6tDhw5lHaHnn39ezZ07V293rVq11PTp0zmzn0XfAhr8WdTZbCoJkAAJkAAJkAAJkAAJZBOB++67T8FRXatWrbJ2rzpOHKhdu7a69tprdf8ETZo0yaavQNa3lWcvZP1XgABIgARIgARIgARIwN8Edu7cqTZs2LDJ361k65wINGrUSF/CjuebNmXf1+Ckk05S3333nY5n3759CjHRgL8phswgQIM/M/qJWpIACZAACZAACZAACcRJ4LPPPutUtWrVOEuzGAmQgA2BTjZpTEpDAlzSn4adQpVIgARIgARIgARIgARIgARIgARIIFECNPgTJcjyJEACJEACJEACJEAC6UJASxdFqAcJZCkB/g2mWcfT4E+zDqE6JEACJEACJEACJEACcRP4M+6SLEgCJOAGAf4NukHRRRk0+F2ESVEkQAIkQAIkQAIkQAIpJTBOat+SUg1YOQlkLwH87eFvkCGNCNBpXxp1BlUhARIgARIgARIgARJIiMBGKd1J4uMSm0nMk8hAAiTgLYFDIn6uxDsl4m+QIY0I0OBPo86gKiRAAiRAAiRAAiRAAgkTmC8SuiUshQJIgARIwAcEuKTfB53IJpAACZAACZAACZAACZAACZAACZCAlQANfisR3pMACZAACZAACZAACZAACZAACZCADwjQ4PdBJ7IJJEACJEACJEACJEACJEACJEACJGAlQIPfSoT3JEACJEACJEACJEACJEACJEACJOADAjT4fdCJbAIJkAAJkAAJkAAJkAAJkAAJkAAJWAnQ4LcS4T0JkAAJkAAJkAAJkAAJkAAJkAAJ+IAADX4fdCKbQAIkQAIkQAIkQAIkQAIkQAIkQAJWAjT4rUR4TwIkQAIkQAIkQAIkQAIkQAIkQAI+IECD3wedyCaQAAmQAAmQAAmQAAmQAAmQAAmQgJUADX4rEd6TAAmQAAmQAAmQAAmQAAmQAAmQgA8I0OD3QSeyCSRAAiRAAiRAAiRAAiRAAiRAAiRgJUCD30qE9yRAAiRAAiRAAiRAAiRAAiRAAiTgAwI0+H3QiWwCCZAACZAACZAACZAACZAACZAACVgJ0OC3EuE9CZAACZAACZAACZAACZAACZAACfiAAA1+H3Qim0ACJEACJEACJEACJEACJEACJEACVgI0+K1EeE8CJEACJEACJEACJEACJEACJEACPiBAg98HncgmkAAJkAAJkAAJkAAJkAAJkAAJkICVAA1+KxHekwAJkAAJkAAJkAAJkAAJkAAJkIAPCNDg90EnsgkkQAIkQAIkQAIkQAIkQAIkQAIkYCVAg99KhPckQAIkQAIkQAIkQAIkQAIkQAIk4AMCNPh90IlsAgmQAAmQAAmQAAmQAAmQAAmQAAlYCdDgtxLhPQmQAAmQAAmQAAmQAAmQAAmQAAn4gAANfh90IptAAiRAAiRAAiRAAiRAAiRAAiRAAlYCNPitRHhPAiRAAiRAAiRAAiRAAiRAAiRAAj4gQIPfB53IJpAACZAACZAACZAACZAACZAACZCAlQANfisR3pMACZAACZAACZAACZAACZAACZCADwjQ4PdBJ7IJJEACJEACJEACJEACJEACJEACJGAlQIPfSoT3JEACJEACJEACJEACJEACJEACJOADAjT4fdCJbAIJkAAJkAAJkAAJkAAJkAAJkAAJWAnQ4LcS4T0JkAAJkAAJkAAJkAAJkAAJkAAJ+IAADX4fdCKbQAIkQAIkQAIkQAIkQAIkQAIkQAJWAjT4rUR4TwIkQAIkQAIkQAIkQAIkQAIkQAI+IECD3wedyCaQAAmQAAmQAAmQAAmQAAmQAAmQgJUADX4rEd6TAAmQAAmQAAmQAAmQAAmQAAmQgA8I0OD3QSeyCSRAAiRAAiRAAiRAAiRAAiRAAiRgJUCD30qE9yRAAiRAAiRAAiRAAiRAAiRAAiTgAwI0+H3QiWwCCZAACZAACZAACZAACZAACZAACVgJ0OC3EuE9CZAACZAACZAACZAACZAACZAACfiAAA1+H3Qim0ACJEACJEACJEACJEACJEACJEACVgI0+K1EeE8CJEACJEACJEACJEACJEACJEACPiBAg98HncgmkAAJkAAJkAAJkAAJkAAJkAAJkICVAA1+KxHekwAJkAAJkAAJkAAJkAAJkAAJkIAPCNDg90EnsgkkQAIkQAIkQAIkQAIkQAIkQAIkYCVAg99KhPckQAIkQAIkQAIkQAIkQAIkQAIk4AMCNPh90IlsAgmQAAmQAAmQAAmQAAmQAAmQAAlYCdDgtxLhPQmQAAmQAAmQAAmQAAmQAAmQAAn4gAANfh90IptAAiRAAiRAAiRAAiRAAiRAAiRAAlYCNPitRHhPAiRAAiRAAiRAAiRAAiRAAiRAAj4gQIPfB53IJpAACZAACZAACZAACZAACZAACZCAlQANfisR3pMACZAACZAACZAACZAACZAACZCADwjQ4PdBJ7IJJEACJEACJEACJEACJEACJEACJGAlQIPfSoT3JEACJEACJEACJEACJEACJEACJOADAjT4fdCJbAIJkAAJkAAJkAAJkAAJkAAJkAAJWAnQ4LcS4T0JkAAJkAAJkAAJkAAJkAAJkAAJ+IAADX4fdCKbQAIkQAIkQAIkQAIkQAIkQAIkQAJWAjT4rUR4TwIkQAIkQAIkQAIkQAIkQAIkQAI+IECD3wedyCaQAAmQAAmQAAmQAAmQAAmQAAmQgJUADX4rEd6TAAmQAAmQAAmQAAmQAAmQAAmQgA8I0OD3QSeyCSRAAiRAAiRAAiRAAiRAAiRAAiRgJUCD30qE9yRAAiRAAiRAAiRAAiRAAiRAAiTgAwI0+H3QiWwCCZAACZAACZAACZAACZAACZAACVgJ0OC3EuE9CZAACZAACZAACZAACZAACZAACfiAAA1+H3Qim0ACJEACJEACJEACJEACJEACJEACVgI0+K1EeE8CJEACJEACJEACJEACJEACJEACPiBAg98HncgmkAAJkAAJkAAJkAAJkAAJkAAJkICVAA1+KxHekwAJkAAJkAAJkAAJkAAJkAAJkIAPCNDg90EnsgkkQAIkQAIkQAIkQAIkQAIkQAIkYCVAg99KhPckQAIkQAIkQAIkQAIkQAIkQAIk4AMCNPh90IlsAgmQAAmQAAmQAAmQAAmQAAmQAAlYCdDgtxLhPQmQAAmQAAmQAAmQAAmQAAmQAAn4gAANfh90IptAAiRAAiRAAiRAAiRAAiRAAiRAAlYCNPitRHhPAiRAAiRAAiRAAiRAAiRAAiRAAj4gQIPfB53IJpAACZAACZAACZAACZAACZAACZCAlQANfisR3pMACZAACZAACZAACZAACZAACZCADwjQ4PdBJ7IJJEACJEACJEACJEACJEACJEACJGAlQIPfSoT3JEACJEACJEACJEACJEACJEACJOADAjT4fdCJbCH/SfgAAEAASURBVAIJkAAJkAAJkAAJkAAJkAAJkAAJWAnQ4LcS4T0JkAAJkAAJkAAJkAAJkAAJkAAJ+IAADX4fdCKbQAIkQAIkQAIkQAIkQAIkQAIkQAJWAjT4rUR4TwIkQAIkQAIkQAIkQAIkQAIkQAI+IECD3wedyCaQAAmQAAmQAAmQAAmQAAmQAAmQgJUADX4rEd6TAAmQAAmQAAmQAAmQAAmQAAmQgA8I0OD3QSeyCSRAAiRAAiRAAiRAAiRAAiRAAiRgJUCD30qE9yRAAiRAAiRAAiRAAiRAAiRAAiTgAwI0+H3QiWwCCZAACZAACZAACZAACZAACZAACVgJ0OC3EuE9CZAACZAACZAACZAACZAACZAACfiAAA1+H3Qim0ACJEACJEACJEACJEACJEACJEACVgI0+K1EeE8CJEACJEACJEACJEACJEACJEACPiBAg98HncgmkAAJkAAJkAAJkAAJkAAJkAAJkICVAA1+KxHekwAJkAAJkAAJkAAJkAAJkAAJkIAPCNDg90EnsgkkQAIkQAIkQAIkQAIkQAIkQAIkYCVAg99KhPckQAIkQAIkQAIkQAIkQAIkQAIk4AMCNPh90IlsAgmQAAmQAAmQAAmQAAmQAAmQAAlYCdDgtxLhPQmQAAmQAAmQAAmQAAmQAAmQAAn4gAANfh90IptAAiRAAiRAAiRAAiRAAiRAAiRAAlYCNPitRHhPAiRAAiRAAiRAAiRAAiRAAiRAAj4gQIPfB53IJpAACZAACZAACZAACZAACZAACZCAlQANfisR3pMACZAACZAACZAACZAACZAACZCADwjQ4PdBJ7IJJEACJEACJJClBHKytN1sNgmQAAmQAAlERYAvyqgwpX2m8qJhM4lNJdaXWFtiTYmVJR4rMU+iNRyShD8lbpK4UuJyiYslzpM4V+J2iQwkQAIkQAIkkGoCdUQBvOOaSKwrEffVJOIdV06iXSiQxLUS10lcJnGpxPkS8X7DPQMJkAAJkAAJZAUBGvyZ2c0w8M+VeJbE9hIbSXSzLzWRt0jiNIlfSvxCIgcABAIDCZAACZCA5wROlhq6S+wkEe84GPZuBgx04/32rcTJEn+TyEACJEACJEACJEACKSVQSWofLPEriQckwihPVkR9qBf1Qw8GEiABEiABEnCTQGMR9rDEJRKT9W4z6kGdqBs6MJAACZAACZAACZBAUglgFv8/EvdLNH6cpPITekCfLhIZSIAESIAESCBeAqWk4N8k/iAxle81c93QBTpBNwYSIAESIAESIAES8IRAUZE6QCL2G5p/iKTbNfSDntCXgQRIgARIgASiIYCVYgGJWFqfbu81Qx/oBh25qk0gMJAACZAACZAACbhDIFfEwIBeKtH40ZEJn9AXekN/BhIgARIgARKwIwAHew9I3CnRrXfbIRdl2ekEXaGzk3NAecRAAiRAAiRAAulLwE1Hb+nbyszQrKOoOVIiPO3HE+B1eLZEeCCGA6LlEuGh+DqJ90q0BuxXfEniCRJrS4STJHhBbiGxjsR4Ajz83yRxajyFWYYESIAESMCXBDAYfI3EoRJxckysAVvJjPfbfLnGIPMKiRsl4p2TL9EaHpOENyTWklhXIjz8G++4YnIda/hTCtwt8XWJh2MtzPwpI3CM1JyXstpZMQlkDwEMvm7JnuaypSQQGwF4H35Hot3MQqS0DVLmDYkXSzxeolPADyE7OQGnApIOeZD7hkTUY1c+Uhra47ZXZRHJQAIkQAIkkGEEThF9Z0mM9M6wezZHymBguoPEEhKdQr48sCsfcCgAWZAJ2ajDrmyktO+lDNrEkN4Eeoh6KyVG6ks+Ix9+B9z9DuBvDn97DCRAAiYC/eQaMxTR/oeDpYWvSOwsETMm0YR8yWQnPxBNYcmDelAf6o1lGSbahfYxkAAJkAAJZB8BvDuwuqxAot07yC4NM/f3ScSMfLQh0Xcc6kKdqNtOJ7s0tAlti/Y9LFkZkkgAfRrL986uj5kW/d8DWZGV+TuAv71Y/g9P4n8NrIoEkksAywmfkWj+A4l0jR8i10ssIzHWkC8F7GQHYhUk+VE/9IjlhxHaGc/ySSnGQAIkQAIkkIEEsMLrc4l27x67tC8lb1eJORJjDW6941A3dIAudjrapaGNXM0mENIs3Cb62PUX08iF34HkfAfwN8iQRgSKpJEu2aJKTWnoWImtomjw75LnEYmjJR6MIr/XWXZJBS9KfFXiFRLvkXiSxEjhRnnYWmJ/iSsjZeSzuAhwf2Jc2FgoywgckvZyb2FyOr2NVIN3XPUoqvtS8jwgcVoUeb3OAkPgs6OxvXzmSzxbYqRwjjyEbwG832ZGyshnSSVAB4tJxc3KSCCMAP8Gw5AwIZsI4MfBZomFjTBiOfxAiXkSEw340WJXXyBRwVIe+kHPaLYloN1oP4M7BLBHCgModn3LNHLhdyD8O4C/F/zdMHhHACvA4GCvsO8f9s7DqHYj5IsQu/oCLgiHjtHs80eb0XaG9CAQEDXsvhNMIxd+B5LzHcDfIEMaESiSRrr4XZWLpIGjJRaN0FD8R/SaxH9JzITZKMyajZI4UeJwiX+TmCPRLmAm+r8Sr5D4vl0GpkVNAHujPpDIrRJRI2NGElA1hAH+bhpJxLYkBncJ3CfiHixE5B55HpD4tMSDEtM9TBMFT5N4q8SAxFIS7QLe6y9IPFbiQ3YZmJYWBPbk5OTgO8hAAiTgAgFN0/B/otP/iy7UQBFuESjiliDKiUgAR+M9LzGSg5/f5Pk1EvEDI9MCBieulfimxNclnizRLuBH0XsSK0p8yS4D06IicKHkorEfFSpmIoEQAvi7wd/PUyGpvEmUwJMioLA9m19JnkESV0jMpICBicclYpvCaxK7SHQKGPCoIPF2pwxMTx2Bfv36zRo7dmyn1GnAmknAXwT69+//7bhx4zr5q1X+bE0kA9SfLU5+q+6SKrHvPRLrcfIcswiZaOyL2sEA/dEOtMcpgAN4gAtDfATKxVeMpUiABIQA/37c+xrg//NXJUYy9rFy7WGJ50pcITFTwwpR/ByJaAva5BTAAkwivfOdyjKdBEjAIwJ79uxRI0eOVGKgelRDeotdvXq1euCBB9S3336b3opSO08I8IXkCdag0H/I1dDgXfjFAUm6RSIc/uwIf5yRKWgH2oN2oX1OAVzAh4EESIAESCAzCYwQtbGVyylslQc9JWK5/2GnTBmUjjagLWgT2uYUwARsGEiABNKAwNy5c1WLFi3UzTffrC655BK1bdu2NNAquSqMGjVKBQIB1blzZ/X3v/9d7d8P1yMM2UKgSLY0NAXt7Cd1Ph2h3u3y7AKJUyPkyeRH/xblZ0ucJLG8Q0PAZ53E7BxudYCSQDL3JyYAj0X9RYB7Cz3vzzukhpsi1LJcnmFGfGmEPJn6CP5oWkn8QmJth0aAzSqJTzg8ZzIJkEASCEycOFFdfvnlavfu3XptZ555pipf3ulnaRIUSlEV5513nho6dKgqKChQL774opo/f76aMGGCqly5coo0YrXJJECD3xvaHUTsaIlOKyg2yrNuEmEQ+zlgMKOzxE8lHmfTUPABJ/BAXoYECHB/YgLwWNR3BLi30NMuvVikPxahhkXyDMY+BnT9GjCQ0V4ijP5GDo0Eo9US/+PwnMkkQAIeEnj77bfVwIED1aFDh/RaTj/9dPXxxx8rcd7oYa3pKbpVq1Zq0qRJqlevXmrv3r1q+vTpqlOnTurLL79UVatWTU+lqZVrBGBwMbhL4GQRN1FicQexqyT9TIl+N/aN5qOdaC/abRfACbzAjYEESMCGwPfff6/+9re/qWnTptk89UcSZmHQRrSVIa0JtBXt4KDV6RfzT/Kso0Q/G/vSPD2gjWgr2mwXwAiswIyBBEggiQSwhP3qq68OGvt16tRRH330kSpdunQStYiuql9//VU988wz6rLLLlNnn322vv2gVq1aqmHDhgoz81iC/9JLL6kdOxLb/Xvuueeqd999V+XmHjH/Fi5cqDp06KA2bNgQnaLMRQIkoBMoJv/+LBEOfeziH5JeS2IyQ75UZqdLIJlKSF21JKL9drogDdzAj6FwAgHJEsZRZvi/kWXMDD4j8NBDD2l5eXl6f8vL2met+6s555xzjt5GtBVtTjTg78Hu70TS8PfDEB+BClJshcSw/3+Ops2Xz2Svlc130Ccg6ckKaDPa7sRlhTwDO4bkEAhINWF9wXdkov+rZk55mckOvjfxXTjmmGM0MarTqgGy6kAbM2aMdsopp4R9V+2+v0iTwQpt8ODB2qpVqxJqy7PPPhtSZ/PmzbXt27fHLJPvWemVDAmc4Xe3o3B0TwsHkTslvbvEFQ7P/Z6MdqP94GAXwA3LHxlIgASEwIEDB/TR/vvuu0+foShatKjucMivcP7xj3+oIkWK6G1FmzHTAQYMaUXgZdGmpoNGayUd/8dvd3ju52S0GW0HA7sAZmDHkGEEDh48qHr06KGOP/54hf+D8X+UlxF7yzGzKwaY7lzt2muvVS+//LKaPXu2gi4MhROYOXOmuvjii4Mz+8WLF1dYQVa/fv3CCycpx5w5c1TLli11B4ILFiwI1oqZd6xEwEx8+/btVZUqVYLPcAE/BPg+oOznn38e8iyWmxtuuEH961//ChaBPr179+Y7N0iEFyTgTKCnPAoZMTPdwxXmOc5FPX2Sb9LDrF/A01qdhYMDeJh1MV+DI0NkAgF5bGamX3P2IubB6bQtsG/fPk1+ZAb7WPYbau+9917a6uuWYh9++GHIrAwYgEU8gTMPkf8TiePpILv/d46mweBtFodMN4rkH9Uh+Pdy9D7ghvAYZYABWFh1Me7BkMF7AgGpwmAe/IznHfnbb78Fy9vJTGZayZIlNRkI1cTQ0zA7zBBO4I8//tBkP3pIn73xxhvhGVOUcvjwYe2RRx7RZPAoqCPe7/Ld1GbMmKHJ3vowzTZv3qyJca7JwEWwDL53MjigvfDCC2H5o02ALl27dg2RKQPv0RbX8/E9Kz3BkFUEjpXWbpIY8odjuh+cQhr5Jj3M+gVSqBN4mHUxX4MjeDI4EwjIIzMz/TqeHzMx/c/OzEkhILPaWvfu3UP699FHH01K3elQicxehLQdRj+YxBr4Q8T5P5A4ntSRMnBxHdI3R+9xVN35ElMV8qViO70CKVIILMDETicwBEsGbwkERHwY/3jekevXrw8ztOxkJzvtxBNP1I09Gv5/vRlkBYTWsWPHkH6/8MIL/8qQ4qs9e/Zo4kw2RD/5Tmoywx+VZr///rvWtGnTkPIYOJAVDVGVt8u0du1arWLFiiEyZY+/XVbbNL5n5S8/Q0KRDNEz3dV8VBSs5KDk+5LOpXyhcMDjLIkXhSbrd+AInjjHmCEJBGREXD+eZePGjUr+R/ekRnjELVOmjJIXi6pQoYKqVKmSql69uid1ZbpQ2Z+nJk+eHGzG9ddfH7L0LvjApxdYwrp69Wol+/j1FsKjMpi8/vrrPm1xRjTradGylIOm/5b0/zo8y8ZksACTW2waD4ZgeaHNMyalIQEsqca7EU7NcJwZvJtv3bpVyUCAmjdvnnrllVciOlKDg7j8/HzVtm1bVapUKX07gOEhHkv0IRPnoeNTDEL1yy+/6HIhe/HixY7L+PF/JBy5vfrqq+r5559X8D6f7eHee+9VU6ZMCWKQffv68XPBhBReoH+xNeTrr7/WtcC2kJEjR+p9GK1adevWVTh14LTTTgsuvce2N2xfwPelXLly0YoK5qtWrZr+/bn00kuDaXgHw6P/SSedFEzjBQmQgFKtBYLTaP5yeVY+xZDypf6Q0buj94EU6wUu4GOnG3iCK4M9gYAkh3GLZ/YCQ7ayXyxMlp18t9MwqgwndPfcc4/21VdfaVhelu0hEAiE9AVm+jFrkY1hwIABISwefPDBmDBw5kH+Yt0JOEI2pC9M97PlOtXOVvNN+pj1DEh6qgKYgI1ZH/M1mDJ4RyAgos289et435GR/uO55ZZbwuox1/3aa69FKh7xmRiJ2nfffafh/0LzEnCzfFzD0akMiEaU5feHcrpLyHYwcBk9enRaNBvvcKw0MPpNJj20L774Im7dxMdNUJYhUzz8xy0PBWXQIESm+A+IatsI37PSAwxZQQBOD3+QGPKHcvQe3lXaSEx1yBcF7PQLpFoxqR98wMlOP3ClU0mBYBMCkhbGLN4fM9gHZicv2Wk1atTQ8CJbuXJlQi+uTC38ySefaNjLZ3CXkXdNZpIytTkJ671r1y5NZhiCPPA9/fTTT6OWyx8i8k1KPMBwXSwx2A+m6z1y3UBiqkO+KGCnXyDFioENGNnpBqapHihJMR5Pqw+I9DDu8b4jI/2n07dv37B6jLpLlCihYRm3G2Hp0qVakyZNHOtCnU888YQbVWWcDFkhEebpvmfPnmnTDgxWG98JWemoiQPGhHRbtGhRUJ4hF9+NRMKaNWs0+Igw5OFzxIgRhYrke1ZIMWQFgUhOjEamCYF80SPkj/jofSBN9AMnO/2QRgdH9p0UsGMW74+Zxx9/XHcE1KdPH33veJs2bTQY33Z1WNMws9C6dWu9HEawxcurBjkXXHCB7gymc+fOWrt27fQfKlaHM1ZZxj1+JGGm2855TaFvnwzNgEEO2eYQwlzOC87Q1rinNpwYGUcS4vuBo5VWrFgRVQX8ISLEEg93iIiQ76Xp/r7ExbsiId+kk1nXgCvSExNyv4Nu0BNsGbwhEBCx5u+Cfh3vO9LpPxysSqtcuXJYPUbdcp66U9G40uUM9rA96kZd+MSAcSIzx3EplQaFHnjggZA+wOCwbI1IA800fX+9LN/X9YNeEyZMSFgv+LSxW/Ehy/oTkn3nnXeGcJQtKIW+b/melb88Bt8TwOj8KokhfyBH7zfKZ7qcuZvvoGNA0tMhgBN42XEEX86ChPdSwI6X2z9mNm3apGGW2a4upOE82FheMHhJwTkNHMIMGTJEa9GihaNsyMdWg0RHwhN6+yWpMH40dujQIYTFlVdemaTa07+au+66K4RNly5dotr+wR8i8leUWCgjxf+UGML/6P1y+SwhMR1Cvihhp2MgDZQDI7Cy0w9swZjBfQIBERnG3O135Ny5c8PqMNcLb+xuhyVLltgae0a92bYyzG5mGicZpEPYuXNnyCo1N53vWh3tof/Hjh2bULNxGoAcCxnynb788ssjyuR7VshnSOCS6fg7CrPPJzoUHyLp2xyeMTmUADiBl10AX87y25FJQhoc69WsWdOxpiuuuELJMjLH59YHcFLTuHFjBecww4YNUz///LOSvfv6ebLWvLhftmyZEo+76ttvv7V77Ju0l156SU2dOjXYHpz3LEvpgvfZfiGrPdTJJ58cxACnR2DG4DmBG6SGyg613Cbp+xyeMfkvAmAEVnYBbMGYIUMJfPPNNxE1lxVuEZ/H8xD/Fw4a5PyzaN26dWrUqFHxiM7IMrJcXnekaCgvs+jq/vuxsCb14eabb1biWV9XpFOnTq4634XzY2uQ1W/WpJju4eTwn//8Z0gZmaDRf6uFJPImIwnQ4I+v28DtdoeiP0t69vxv6wAhxmTwAje7AM78ntqR8Tht9+7d6scff3Ss5fzzz3d8Fu0Dma1V//vf/5RsA7AtIksYlTiu0z0X22bI8ESZnQj7EfDYY4/ppxlkeNNcU79YsWJBj/2GUFl6qFatWmXc8tN9AkVF5M0OYr+V9PEOz5gcTgCsvg1P1lPAGKwZMpBAJIMfp9LA07kX4cwzz4woVo42jfjcLw9/++23sNNbZHZf1a9fP+VNlK0VQd0wCPHUU0+5ppMcxajw28EacOpDouGmm27ST1Qy5Mj0vrrjDu4+Mnhk8icNqfh670IpVseh6COSrjk8Y7I9AfACN7sAzuDNkGQC06ZNCx79Yq1a9lXrs+/W9HjucVTRmDFjVL169WyL4xgkvMRxdJHfwu233x5ypBMYmI/H8Vt7423PRRddpGQLSLC4OPRTsi0keM8L1wlcLBKPd5Dq9H+1Q3YmCwEnZmAM1gwZRkC2YoWszLKqf8YZZ+hH8FnT3bh3elcasn/99VeF43b9HrD6y2rk3n333WnRbDl9KKiHbNELeX8FH8R5AWMfx/FZg12aNU9h92XLlg37DYKBrZkzZxZWlM/TnAAN/vg66EaHYvC8O8HhGZMjEwA38LMLTrzt8jLNJQKRZi9atmwZ15mvTqqJAxo1fPhwp8dqzpw56q233nJ8nokPsKVB9tyFqI6liBhMYQglgHOrhw4dGpKIQaJIK1BCMvMmVgL/51AAK7G+dHjGZGcCYOa0is2JtbM0Pkk5Adm/r+QUFUc9vFjOb1SG1QOFhUSXdxcmP9XP//zzTzVu3LgQNcThsGrYsGFIWipuJk2apH744Qe9avF1pMSXg6tqYLujXTjllFPskmNOu+6668LKZMuqkbCG+yiBBn/snVlbijhtzILFgjPkGWInAG5OFh94gztDEglE2juP/Whuhx49eigY/k7Bby8czERguZwRsAyRs/sGjfDPbt26qdNPPz34gEsNgyjcvsBxcm0dhDr9H+2QnckmAk7swBrMGTKIQKQBcTTDS4N//fr1hZJau3ZtoXkyOcPbb78dturvqquuSnmT8F6S44WDemD7mThSDN67cSEn+NiKgY8kN8Kpp54a5lvpP//5j9q+fbsb4ikjRQRo8McOHv+j5NgU2yBpo23SmRQ9AfADR2sA79T/T27Vysf34l024uypFz9m4NRPPPM7UsWIOUb1/RDgpO+zzz4LaQoGALDXj8GZwPXXXx/ycMqUKQqRwVUCVztIWyXpoVNqDhmZbEsA7MDQLvD9ZkcljdMiGfzlypVTMJq8CoYjuEjyxYt7pMcZ/+z1118PaYMc+6suvjj1u2Owak9OL9J1O+GEExQMfjcDtjZisMMasDXypJNOsibHfX/ttdeGlN2zZ4965513QtJ4k1kE+Osy9v66yKHIGEkP31TjkJnJtgTADxztghN3u7xMS5AAHOnBMYxdgGFemNMgu3LRpBX2I2X58uXRiEn7PM8++2yIjnIUjsI+dYbIBPCDDqzMwW8rP8xtS9F1P4d635V0rmBzgBNFMtiBoV3ob5fItPQkgHej+WQVq5Z4P3q5NSvSYIOhS2H7/I18mfiJ/eQLFy4MUb1nz55p4exWjt4L6vXwww8rGOJuhgkTJig5MjlM5MCBA12dMOjVq5fCVjpz4LvWTCPzrmnwx9ZnjSR7Q4cinN13ABNjshNHcAd/hiQQiPSDAjMX0ewhjEfNwmbw7TzTxlNPKsvgZT1x4sQQFfr3769KlCgRksabcAL48YTjIM3hgw8+UHJ+sDmJ1/ETaC5F6zoU5/SOA5gYkp0YgjnYM2QAAfhfwQkyTsGLLW/munA0aaRQsmRJVb169UhZMvrZa6+9FqZ/OmyHg7PE2bNn67pVrlxZdzYcpmiCCa+++mqYBKxuuOuuu8LSE0moWrVq2LJ++K2YNWtWImJZNoUEaPDHBr+HQ/bFkv6jwzMmx0YAHMHTLpxvl8g09wlEMvi9WM6PFhQUFNgeNWNunXV21/wsU65Hjx6dlnsPM4Wfdakhvjd+c+iYwr5w+j92vui0IIV6+aVqMARLu+DE3i4v01JIINL7EWp59Y6EbDiwLcwDP/zhWGdnUdYPAccFYz+5OWArnJfMzXVFun7vvfeCj+FPAEfKuhkwUYDj/qxh8ODBCtsH3A52Ry9zlt9tysmTR4M/NtZdHbL/9VfukIHJMRFw4tktJinMHBeBbdu2BUep7QR49WKdMWOGbvTb1Wmk+WGZonV2An4L2rdvbzSRn4UQaNasWZivh1deeaWQUnwcJYFzHfI5/Z/skJ3JEQg4sXRiH0EUH6WCQCSDv0KFCq4ewWZt3zPPPGNNCrv387npWNIOH0PmgFODCtsOaM7v1bXZ4B80aJCr1WzcuFFZB7tRQc2aNdW9997ral2GsO7duxuXwU+sqMORlAyZR4AGf/R9VlyynuGQfbJDOpPjI+DEE/zRDwweEsD+faf/0OFFH+cLexGyYZkilsMtWBA6Ucq9+7F/m6w/RH755ReF7y1DQgRKSum2DhI+cUhncuwEnFiCPfqAIY0J4Nz3adOmOWrYoUMHV/dSmyvasGFDoY7TsJ3AfJqJubwfru0GW84666yUN+2nn35Sv/32m65H8+bNVYMGDVzVCQMI1i2PGOT45JNP1HHHHedqXYawVq1aKWxNMAdMCM2f77RIyZyT1+lGgAZ/9D1yqmS1Mza3SPpP0YthzigIgCe4WgP4t7Qm8t5dAnYvVKMGvABwrqwXAWfXRgp9+/bN+GWK1tl9tPfss8+O1Gw+syFgNfiRhbP8NqBiSzpNshe1KbJR0ubapDMpPgJgCabWAPboA4Y0JoDTYnbt2uWooVcr4FDhv//974ir4GAAWr3XOyqaoQ/snCWmg8H/4YcfBolecMEFwetEL4xj/qxH8cHnD34zNWwI91beBGyVaN26dZhwnowThiQjEmjwR99NTjMf00UE17dEzzGanOAJrnahnV0i09wjEMng9+rHzLfffhs8ysapJbfffrvTo4xIx6oJHNljDnhpe7ViwlyP367xPYRjKnP4+OOPHVemmPPx2pFAG4cnMyRdc3jG5NgJgCWY2gWnPrDLy7QUEIj0foQ6Xr0jv/vuO/X44487thh79nFcW+3atR3zZPoD+C4wZtGNtuA0hHR4h5pXKBZm8OOIOxytiJMGcIQf2oTVG3v37jWapX8iH06mgbd/c4Ahjr5OxlZAbJewBrtBF2se3qcfgSLpp1LaatTMQTOnF7dDdiZHSeA7ydfTJq9TP9hkZVKsBLZs2RLR8Pbqx8xTTz0VUVUcuYNlcpkcsAxu69atIU1o164dvfOHEInuBgMlHTt2VJ9++mmwANiCMfb4M8RFwAkc/i9mcJcAmPayEenUBzZZmZQKApEM/mOOOUY1bdrUdbVwCgkMP2wnsAswAEeOHKnsnKzZ5c/UNLuZ5bp167p+9F2sfOBT4Mcfj/jtxhJ4OyMZe/Cffvpp9e6776rVq1crzNzbBSzPx++stm3bqlGjRil4xjeH448/Xr355pvqnHPOMSd7dm3XFhr8nuH2VDAN/ujxNnHIOtshncmJEfjZobhTPzhkZ3IsBPBCddq/D4+zMFDdDlgiidlZp4DjheyWwjvlT9d0ux8rXbp0SZm6MJCXLFmizzTgB+Mpp5yi7zuEn4ZMCNheYjb4oTN+iNDgj7v3nP5v5TsubqSOBZ2YOvWBoyA+SB6B/fv3KziXdQoYhHTbOz62D1xyySW6kWhXL45kw8kv/fr1s3vsqzQ7QxPvrVQH+HQwBmM6iQ8Fu+8AzrXHKo3CAgYGcAqB9SQClIMMHMtXqVKlwsS49tzO4IcvAfjN8XI7gWsNoKAgARr8QRSFXtR3yEHvFQ5gEkxe4FDeqR8csjM5FgJYWu8UsJfLuozaKW+06du3b9dnLpxGuzHIgGXwxx57bLQi0zaf3Y8VLwZQIgFYtmyZGjFihBozZkyYAyCUA2+8xOEN+O9//7trzqc+++wz3RjHWclu/UCz+yGCQZWbbropEgI+syeQI8n17B/xOD4HLokkO73f0AfoC/vpv0RqZNmECXz//fcKy6ydgtsr4LDUG0beokWLbKuEYzgYgOmwpN1WQZcT7QbN3XqfJKKqedWH3SA++s9s7JctW1afxcdqAAwUbNq0SR9IgkM8p3Duueeq8ePHOz32LL1GjRq64z7oaA7oCxr8ZiK89guBKtIQvICtcWcGNDDfRm+0I5ABuoOvlTnu0R/ZHALS+DAuMsL/jRjOCYUmTZqEyTXquv/++xOSbVe4T58+jvXJS1GTM2ftimVkmgxahLVVRvOT0pbly5drYC0z+WE6GP1r/ZQBHk2WEyas35o1azSZhdLrlZmqhOUZAlauXBnWFlkOaTzW8PdgbdPR+4B8MoQSqCq3YTwlbUdotrS8y3fQPZCW2v6lFNjaMUdfMCRGICDFw9gm+o584IEHwmSa65EtRcH/fxK5kIFwLRAIaHgHmuUb13L0nybLw7UDBw4kUk1Gld23b5/t+0tmwlPejtNOOy3YT7/++muYPrKEX5NZ/2Aeox9j+cS7WxzThslORoKsXAnT/frrr9er5ntWejFDAp32RddRtRyyrXRIZ7I7BJz41nRHPKWYCWCZlvXIOPNzLFVzK8jLW1199dXK7NnWLLtq1aoKI8h+8WCP5W/WI3WwVy8ZKxcmTpyo7ykEa6ftGmb2xjVms0499VT92B8jLZ7Pxx57LOhZ2s2ZKGPmwawTlkPKDy5zEq+jI+D0f6rT/8HRSWWuSASc2Dr1RSRZfJYEAuaZXGt1+L+8cePG1uSY7mUQUw0bNkx3vCcGf9h589h6dd111+lO3m655RZVpEj2LNIFG7v3V6NGjWJi7HZmbI37+ecjO1CrVaum6tcPX4SKbYl4/3br1k1F2jKHZ/ABccMNN6gXXnhBlSlTJqgu2o6Vd6k4jebEE08M6mFcyCSCccnPDCGQPf9bJNYhTodcrk5MLEsXQgB87d6g2T7DXwi2+B7DwJYhW9vC2CcIJzJuBCxvu+qqq4JObswy4XEXL7WHHnoo7PxXc75Mu54+PfzQiUR/HEbD4K677lKPPvpoNFlt82C5IfaPwviP51zh9evXB3+gwEDHWcJuhhYtWihZBRIiEqzj0TVESPbd8B2X/D7H+81uA7JTXyRfQ9YYJIBB6pkzZwbvrRex7t/H1gAMUMKPCrY84Tx1DAw7BRw99+STT2atjxJsR7MLXp1Bb1eXXdr//ve/4ECE3XJ+owy2ZiDinbpjxw59MAe/tzCIg4EbbJeUlRsh+/9r1aql4LDY8A8AWTfffLPq0KGD7cCCUZfbnxiwsAYa/FYi6X9vGPw5oqr9L/30b0MyNHTykBG6qSUZmmRXHU58nfoju+i43NpIsxcw9uEZPZGwdOlShVkLeKm1G6nHCgKcM+yFl+NE9HajrPUoIcj0eu/hvffem5Cxb7QbP07wo2PWrFkK5zzHEp544ongUUOYuUr0O2Stu06dOtYk3QlhWCITCiPg9H/q5sIK8nncBJzYOvVF3BWxYOIEYOzD6HcK48aNU5EMPpRDeRy/BkMfzvgiBRiCWBHVt29f1bt3b4UB02wOTgYmjORUBvPvpmh8OMC4x2kOiIUFrAjAexy/m4yAo/uuvPJKfc8/JkiSEexm+LHiwmmCKBk6sY7YCRgG/71S9MHYi4eUwIDBUon4RMRZ6sa18RltWrqVd1ozBI+6I23amU76txD97AJ0v1yiXZ+ki/52eiPtJIl1JTrp6ZRu11a7tEjlUb8vQySHfTDG4wmYzZ88ebI+ewGndeaRakMeRrFhGOKHjV+D3eyEl+clYybokUceiYgTnoTh7ReOguz6xVwYZwbjLGDIjTZgC8OLL76oZ8fgBhz2uR048+AaUadfzVtcq4GCrASc2Dr1hbU875NIwGzYOVUbTR6nsuZ0HFN72WWXqSpVuJjR4GL3DsWsOBzNpjKY+7ywAZ949Lz11lv1IxdxZLIRMPj+1ltvqYEDBxpJnn7avWcLCgrUunXrPK2Xwt0lYBj8mOFPNEAGDLFsCs2ksYiZGPqI0oiZGO4RpRH9GHZLo/A/u91AhJFmOzQsL4TT4gWCWQcnT8CQKY7XIh6NB4MRXlyN2Qt8wkhEObuALQLYnw8jH4ag2zO/dnWmMs1udqJ8+fKeqISBm3/+85+2snGUHc5zxpJArKRAP6DvoN/ixYvVwoUL9b2DGL23BuwphNxof4TiR+vu3fg6K3XfffeFLFW0yo733m7mwY51vPKzqFxxh7budUhncuIEnNg69UXiNVJC3ATMhp1VCGZro5ndxbF+eE9iMBQGrN1KN8geOnSovrw7WQadtT3peG9n8Hv1Do22/ejLefPm6dkxgI/JC7dDuXLl1ODBg8NW6+F0hmR9P+zes2gn37Vu97a38tw0+L3VlNJJIDsIlJZmIsYcDh069JeHlxhLR5rdhyi8XBATDTDwEc8//3yFF1m2BLsfK14sRcRsPZb7WX9I4kgf7OXHnndrwBLDk08+WY89evRQcAYF4x4/Os2OBrGUcPjw4QqGfGEBsxHPPfecng1H94gn38KKxPXcbubB+BGyefPmdg5Cb5H0qyU6reRxSjcG3PDciHZpmVi+lbTJLrSXxGESY2lTLHnd4Gfn5wVtgfesC4/qHotOseRNRP9SUNImYEk/PPVDD3O0q8suzUl/pDPEQQD77eHHxClgyX2s70f5/0n3PzJy5MiQI9tQBwzJa665Rp/FxbG0OL4t28Mff/wRhsCLd2hYJRESsGrRWNbuxey+UTX8Q1h98cyYMUN3UJsMfzVO3z+nCR1Db36mFwEa/OnVH9SGBFJCINLsBZbMFTYDL4MNwdncSA2Ag52uXbtmlbEvRywpePK1Bi9+rNx2221KjgAKVlWqVCk1atQoddFFFwXTCrvArD+MfpyiAEdRhgdilMMSfTmaSuEc4UhhxIgRQQ/TQ4YM0R0TRcof7zO7mQcMUmBlgQx6OK31xNIKb5ZXxNuQ9C13hqiGmInhElEaMdPCnaIwYioDBhKwydzNAQe7wQm7NKcBC7u8dmkoX9sOngyI2jlJtMsakgbjCrPzTiGa2X1rWWyngkNUxNGjR+sOTbFM2hwwEA//KV9//bXu1M38LNuujdVi5nZ78Q41yy/s2vy7yUuDX47ItVXlnXfe0R0c2z50MRFbJ+xCYX4o7MowLXUEDIM/N3UqsGYSIIFUEzC/uKy6YGQZ+8gKC8Zyxf9v70vA75quvnelppd6FP1QJSJEibymVFJD+YyJElRFiBiboJqghiDlf6sSJGpKgoRqyUsMEZImJVT7GENCYp5FgiD18rw1vGr4er7f7+S/T/Y5Z+97z7n3nHOntZ5n/e856+xh7d+5/7untddC7Hbf6/CUKVOUee6M+blzfNddd6kJEyaoww47rFKRLfHcnICbDcp6sIIY0Oqmm24Kqthoo43UrFmz1HbbbRfI0lxQv/vuu883/9eh7rjLP3PmTDV48GBnUbQy4K4VqWvXrv5ZVGfiGh8wfKONbEcSbOlEJggIAlYEOCZsORMsxK2vaqu8XP9I9KqZ8JuoH3XUUb4JPyf3UaKzQJ7nZ79JR37tSrSyiFLWfWi0/Er35vei1u9AubroLJeL91EMykV1KFde2meuCT/1QX9Pf2A24i4Dn+lFQ9vinE2WxYKfrdykslasn8eEX9Ev6bfGS9EvRz5XfFEFC8Gi4b8DMPuCdVl6Wrp0adm2LVy4MH2hyIGOwBs+fLi1bDiM8+64446qym22TNgdsmIAHweZNgXm+EE9sMjwnnrqqUzKx4KFB8uMoOwBAwaULRcWAEFaRF0om7bWhxjAB3WZfRgGyR7/H0yZXAcDL8FF+rO2/A5U20ciSo0Trx49etT6Mxbk79+/v7MehFgN0rXjxYYbbhjDBv5o6gYFjhgE+sCsPnc9bO3v3bt37vWyAlhwBm01+1FE3pF+tjn6kpl4b0rv8HfgmlwLfQuZ6Tmdn2QuRepr/ZlU1mj5GYD8BHCUnoLgZrBun/mZtK22dFm2fwfoR47ScxA8D867/mow0e1n8E+bx+IPIP8crNOZdehrW7uSylzlMn/LUbnz+3RGVG2YPDrU4U4vz391dIR/XtCHqCFDhih0YmrXXXlMuHUpuiqvW5rl7gRDHs6ePVsXra655hq14447Bve1XPCcPJ3uYfHGL4Yxoxmqz+aD4dNPP1U05yexfTyHmifR/wA5GmXAZv6Zpx5StiAgCLQmAjRbnj9/vrNxWe7sjhs3zreqYv8YpfHjxytM+isep4rma5V7Wz+aZR+aFqeHHnooyJKnOb+uhFF1orR48eKoKJd7WpbwaGf0WIvtneSigBRaKwL+D4qe8NdaGPOzwDeyKKgBy2DsCduE/38gH9+A+poqcaZlm/DfDXnJTNiA1w9Ap70tenEWca9F3goiOt5jsPNyixOcef0q2liYfXFU8qOovNK9aZYWTUtv7rWaEXKQwjOK0Vj0PK940EEHKVgQtHSMYVenmKWHYZ7T14NE7GJl7r33xBNPVFdccYXvWZrvbcaMGf6CTfT7woUG7a9g6NChas01+XXOl2huyIUGk1yYm2nkWhAQBASBSgg8+uijsQVFM0+1IWvNMvR1z549FY9i2ZyhceGBDvzyXkTVujTap+03Pcs+NG17zXFTERN+HpWLEp07sj+m3528if1sdMJP301CTYFA5hP+pmh1lUpyR9lGm9iEIssMARe+rveRWcV1LIiOksjl6CPbQ+x00uohNZkdVzRzFrsXK6+8soLpl9VTO8/48zz/2LFjo1W3zL1toLLGGmv4O9NZNZLegjXRSV7WxHd4wQUX+I78WPa0adNiE352/vTRQOKuu7YI8AU5/nFN+OEU6zFUa3M4dwXkV4FdljwueblFOOYxOWlaW7p61L8x9D8DHKUPIWBYhjQ6pUmbRfu3gX7kKPHM4qtg/V5sddlkRelPCzabY0lizpG01lt/2nS1yVz6Uy6UEoFy/SOLyqKPNFXq3r27dcLPNPTT0q6kF7TN9te6GWGWlfZafy+4857loo9ND07qbeMIpo1G5LHlz0IWtaJjmZWcOWdRr5SRCQL0XxCY9GdSYgsXssTRNk5I2Yn6qyeONCKuDgHi6prwu95HdTW1cS46lKM5uIuy6sj69evnqkL96U9/arsJf9Y7E9pbLh30lcPa+RISPPjZz36muNPPwQd3vaLEIwXaWR7D8Nk86EfzZHHvGnRgMPi1o/xPIJffkDA46+LWNuGnical4Ebu42jFZpvw3w55CdyIxP7NtUC7FZ5ZF3ULbAgXEvjuqadm2+KCTcb0NnlSWRb5j4YOQ8AhwjEkzph7hYQVbvTEzpaMIUfXX39926OqZVwsdZEOOep63spyOq3jUTKTovfmszyvaYHx2muv+VXwyCMjLuRJZnhcsx5i4ur/zHS1XnOybzsmF93xr7UeyZ8bArLDnwJaejjkL03Ua+1qkHUDLwILZYsAcSW+UeJ74PsQygCBcoMZnr3v1SvV2MipEXe06VH9gw/ixhnszP7xj38ohuxrF7Kdx6ul7bfddps/Ce/bt28txZTNy1B8DNP3l7/8xY++AKeDavPNNw/y0JxfE8MDFkW2nYcuXboUVX2r1MMJ5qfg70QaxHhMXcGLI3K5rQ0BYkpso8R3wHdRb/o3FAjPruqtUbr6rY5hYPqcCluGVDXDkkZVyHp3n+W/+OKL0WqCe31cKhC00YVtws/3Uw8q+vw+HPBamwmHkSrrsYStIhfOfCdYRHsOef7Tko8LrneAuYCXZhEvTVrbIqLkjy+40tJNdvgJQkJ6Celso+lekMuEPyGIKZIRVxvxPQhlhEA5h308C55lZ2IzydPNoPOZVp3w20LaZL0zwY6fnDcdfPDB/oSf9dCRlZ7wc/J///33+9Xvsssu6kc/Su1KomrVbYMROVtYFZwvI9dOlpzcPV9skYuoegRsFgksje9AqEEQeOSRR1S535KsJ/xvv/22dVFcw8EJVruSre223/4i8DE3Soo4v//YYzydFqctt9wyLsxBYvMfwGr4TrCI5tqA45Gq6TmoI0VWiQBXR4SSIfCCI9mODrmIa0PAhavrPdRWW5vmNjuuKARZDma4g79s2bJoFcF91Ola8KAFLmwDFZrgF3X2LksIEZ4qKG7evHnBNc/u6wWdESNGBPK8L1ymhjbM89alBcp3/ba6fotboMl1a4ILU9c7qJui7Vxxuf6Ri+FcFM+Syi3As56sj4JlqXveZdl+0+s94aclGR0b502uCT/CAeZdtV++C2fbOylEIamkKgRkwp8ctoWOpDs75CKuDQEXrgtqK1ZyawS4q052UVbn91n+3LlzXdX48iK8uZdVIMeHPM4QJU6Os97lj9aRxz13FBieh/Tcc7TkU+qLL75QjBJA4nnWQw45xL8u4k+5nYci6m+xOlx93IpVnhZrcB2b48LU9Q7qqGr7Vl1uwk+P+t/73vcyBafShJ8hUtuVbP2oayKaJ0YcMy1atNyol6FvbeFps6yfmyFPP/20tcg+ffpY5VkLXf2s7Z1kXbeUlx0CMuFPjuXjjqQ087d52nUkF3ECBIin7fgEs5afOSYoXJIsR6DcYIbm9RzQZEWVBjIIKZhVVQ1XjmsVvB6DlVrBobd+vaugQ0fRf4A+W3rCCScopimKXBjKQKSqN+D6beXk1O1JrKqq2joTsXRN+F3voK0Bq0fj+Zv27LPPOqvO0gJOV2KeDdcy83OTTTYxb3O75jEGhnzTVltJK+Lir+4LkuZJmu773/9+LKnr9z+WMEOBOZbhhD9vuv3222Ph8FgnF9f32WefvKv3y3fhnLXDykIa08aVyIQ/+ct/Hkk/tSTn9p0t9JMlqYgSIkA849uiy/HnexDKAIFyE/4sd/epqtlJ2lQvyqO7re68ZXR2ZyNXJ2pL20gyfW5fT/gnTpzoq8cQScOGDStUVdl5yBRuzm4+t5S4FmSuBVhLchFVQIBYEtMoEXv3DDOaWu5zRYChTssdu8p6wv/ee+8FO8euhnXtSl+P+dATTzyhjjvuOLXFFlso+p2h9QL7LjqCZXSWhQvtxievv/664kJvt27dFBda11lnHf+T3usZjtflYT5tK1h+lOrRh5rjpm22cbniiGpa/b22nouWMHjw4ExD+0bLN+9d/exmm21mJpPrBkdAJvzJXxDj4v7dkfwAh1zE1SHgwpP48z0IZYBAuUl4lhN+dhba/NumNgcWNsd2trTNKHPtytRjsJIFftq5IuMCz5kzJzA37N+/v8pzQGrT3YVhKy8g2XDISPYNynnIUdZPHXIRp0fAhSWx5zsQagAEzIldVJ08zu/TQWAl2nTTTSslSf2c/mQYcpX+WRgilw5Yv/56eURThmJ78skn1eTJk1Xv3r3V8OHDlfmbO2bMGMXQhDfeeKN/PFBbBLBveP7559V5552n2P8xskutZJvw81icrrPW8pPmN78XjGSUJ7366qvq8cftxsXHHHNMnlWHyrZN+Bk+UvrZEEwNfyMT/nSvaI4j+SDIBUsHOCnFxJF42ug+m1Bk6RF488031TvvvOPMmOXuBTuscjsleQxidMNY7z333KMGDhzohxhkB7Xffvup0aNHVzxD//HHH6udd95ZUb9yiyO6Ltcnz/hx1yNK5sAp+qyR7/WEnzpedNFFgaonnXRScF3UhW0gQqzb2blVjdgvD7UQL+QIiL4VF4skJQLEkFjayIW9La3IckbAnNhFq+Lute03PZouzX2SCX/WEyyOAzjRv/vuu31V4XFd8Xd8ypQpiscLrr766sBPAfvSCRMm+IsDvD711FPVqFGj/CgGXAD5xS9+oWbPnq0YQu7CCy8Mmv6vf/3Lz8MIBLWQbcJPPYr0hRMdN/HYQ540duxYa/EDBgxQ/A4WRbaxCr+LnPQLNQ8C8rbSvatZSD4BHB348HDRnuC/goVqQ4A4xg9rKeVBTvyFMkCg3GBmgw02CM5pZ1CVqjSQce2A11o3J+w0e7vvvvA6EU3RGUKOceNnzJjh71xE6+KuwdFHHx04G3z//fejSVLdc7BCfUyydaLm80a9Nv0tPProo76a3Nnff//9C1fZNuG3DQwLV6x5K+Rv7JUW9btCxqNWy1+4JYGIEiFADImljaR/s6FSBxknctyhdlGWC+K6DjPqiZaZn7SCy3KRgf0yw6zqfomTyCuuuEKZZtr0QM+27rDDDsGu/9/+9jdFU/aXX14eQZKLq/fee6+/cEB9v/rqK98SwNT9yy+/9PtcLgpUS67fdU7CqV8RFB030RoiL6KjPlpcRIk+gbgQUyQxylKUXO8jmk7uGweBlRpHlabQhEuUK2JRhVUeHL6VuyoRcOFI3N1b0lVW1q7Zoh2XiUOW5vws1xVSRteZh+dhHiHgICA62dd18pNnJtlWTvqjdPbZZ/u7FZRzcPPzn/88miTVva1z/OCDD1KV0SiJtZd+Ux+e/eQZ/qLJNuE3B6xF69MC9b2JNjzjaMeRDrmIkyPgwpAHpIm9UAMgwN3tcqbiWU/4uVP94osvlm25zWmdKwN3vdnH01zfRh999JFv9aYn+9ytZz9o++1k/8fFAJP0ZJ+/+bfeemsw2WeaSZMmBQvlZp5XXnnFvE19betDWYjWJXWBVWSIjpvovyAvOu2006yWkb/5zW8KPzr30ksvxZpp+67EEomgoRAofoTWUM2vSpnbHbkOhdzuncuRQcQxBIgfcbTRbTahyKpDoJyJepaDGQ6aynk6pvZZT/gZxoah4ZYsWVIRHJ5R5PnFs846yz+7yDNzRx55pLrsssv8vFxNp5fcWj3P2wYrRQ5UKgKRIoHNjO+oo45KUUJ2SXV4JLNEG9bmc7muiICrjxuInKtXzC0JXAgQO2JooztsQpHVB4HoxM7UgpPcrGOv06KA597LkXmUqlw69rk77bST2nPPPdWvf/1ra9JTTjlF6QVn/nZzZ78c0ZGfjYYOHRqz7HKF4O3Ro4etiMQyWjjYJplF9qPR78Vrr72WWP80Cc8991ylrefMfHyvZ555pikq5Nq2GFWEw8JCGtdGlciEP/3L/i9k+dqSjZPV4g+xWhRpYhHxsy2aEO9bmrhdDaU6J7Xc3XZRlhN+DioqnbFLGtqFK9scNNxxR/mxMR0L2SaCrvZyd4UTfA5qGHJu6tSpflIO7G655Ra19dZbu7ImlmvP9maGIgcqZr21XjNkk0n0c9C9e3dTVNi1bSDiGpwWplTzVzQFTQi/5OVtWhcfxzV/8+rWAmJHDKNErIm5UIMgEJ3YmWptv/32au211zZFNV8nCWVH57ZJ6MEHH1Ts40kMkxel6dOn+4vYlPN3mw73eAa/HNnKYfqTTz45ls127IDe/vv16xdLm1ZgW2gpqh+lhUL0aB8n/K4FjrRt0+kvvfRSdckll+jb4JP92qxZs2refAgKTHhBc36br4Ldd989YQmSrFEQkAl/+jfxIbLMdGQ7HfJVHc9EXB4B4kb8bES8ibtQBgiU293faKON/IlvBtX4RSQJyZNkILN06VK/E6QJHQc0Llq2bJnvcEg/Z6fEOPFcAOAOCsth+KFrr73WDyW07bbbKpuJOvNffvnl/hlHXVYtn5wUR6lWE8doeUXd84ymSfXa3acOtgm/DWtTX7muiMBSpLjfkeoMyLs4nonYjQAxI3Y2ojNgYi7UAAjQMsxmwqxVy3JBXJe57rq2dSD9dPmnK7xrOJXy+zYt22OPPfRl8MlQeZq4k5zEes1mpdenTx/F/jNKtB6gHyBNvOYifRa+emyTzKIm/K5FIGKYFfE4xDnnnBMrjtYdPJ6YZKwUy1yjwNbHcsGrSKeBNTZBsnciIBP+6r4KLo8ZG6K4Y6orsu1zHQsEiJ+NXHjb0oqsAgJ0WOci2wDBlTaJPMlgwnQC5yrz+uuv970B83mvXr1cyfwwcdyxJ9FBEBc3Dj/8cD9GME0CeQ6SAxV6Ir7hhhvUM888o2jWr70U64JLpZLvhVjf1/rZs2dPFR3U8fykzRlOrXXlnZ94aeL7Jb71IC4mRReUGCaJYaKEakZgvKOEzSA/zPFMxG4EiBmxs9EEm1Bk9UGAUV3KkW2XuVz6JM/4u1VpQk8P+pWIE3OtP3faDzss/K/KPode9EmMPkPHtJXom2++CfKYaaNl62f8/WUEINYzf/589dZbb2Wyu8/ybdjTmsHmy0Xrk9WnOeH/wx/+EGwU0N9DOV9BSeqnBcXpp59utZigQ9wHHnjAepwhSdm1prGFVN51113r4rOn1ra0e36Z8Ff3DXgY2RY4snJ5rvIvsyNzm4qJ10hH24kz8RbKAAGGyGHsdBdlPeFR8fVGAAAc4ElEQVTnoKIScSJejngm/7rrrvOTcNBTzoEeJ9a77LKLOuigg9TEiRPLFRs8o8WAuUvN2MEdHR3B8ywuaDLJTjJK9MTbbKTPflJveua3mXAW0aYXXnghVg0HhJXMU2OZRGBD4D4IX7U9gOw8sOzyO8CxiIkVMbMRMSbWQg2AAC3Ifve735XVxNy9Lpsw5cNKC5XmQqutaB61GjFiRODo7YILLlAMCWtSly5dAhmPyCVZkF+wYIHV+R99BLiIfl523HFHPwLOaqut5kqWWs4z/FGfP1zgt513T114mQz0i6AtI2kROGjQIDVkyJAgB48R6mMUgTDhBRdF6GD4yiuvjDmK3HfffRXHCPXcTX/44fjw22ZpkbC5kqyOCKxUx7qbveoVdlHhlnTDbfFeNcI6NNsd8SJuNnLhbEsrsgoIjBkzxt/RdiXjGfYsSe+qlyszaiIeTTt69GhFU30SO9ZyAy4OMtj5c5fDZapvls+FhAMOOCDAhPGDWV8eZOskbZ1pHnVnWabpDPGII47IsuhUZdmiP9h2gFIVKok1Ah4uxuqbyCdNbE6MyOTWjQCxcpklEWNiLVQQAvRcz7PXDLvHySx3bumrhTusPA5ED/blaNiwYb4neoan4446TZ55PItx5qP+TcqVE3124onl/6XMhdZoXt7zPL3uT+gz5pe//GUsGUPo0X8P23jCCSfEntsE3MGOEhd5beb80XR53Nv6UZuOWdbNd6ytyWghSGe+XBjSTgQZnq93796Bb4QkdfM7wwUafueix/voP4gLMgx3GLUMTFJ2Vmm4mKIXOswypZ810ZDrdkDgW2jkc2B21lH+HLJNwI1AHVAiqh/vS42gHHQgTsTLpiPxJc5CYQRKuI3hhZ3vv2Ml2icMajyYuXlwMuOhs/IwAfaOP/74WJ5oOVhR9mA+5uHMu58fu+serAJ0sVV9jhw5smy96NSc5eLsn4fOz8+Pjs+DcyNn2jQPYKboobMN9MLigIeYt2mKSJ0WJo5BfRp3dPapy6l3BhyLCNoBnwh1UwdnaQM9NJ4LFy4M9OH/g5ZHPku4F6qMwLeRZBE4hjNknBVVPniMRAVQB+qw6VgqoO5KVRAjYmXTj9gSY6HsESihyBjme++99xM2eVay/v37B78/aS/Yz8IiLqaz1g278X6fbCv3/PPPD/LBwsmbPXu2LVlVMlhxBWVrXRDZpqqyssiEc+4xfeC9PouinWUg7n1QJ6z/gnQ4ruBtvPHGwTPig4UbD9ZnQRrz4p///KcHn0IeLClDeTSu/Dz00EM9+JAws9XtGtYFMT1x9MT7+uuvA52kn8VbE2oLBA5AK2P/EJ2yOxsEgQ6HjqUG0W+aQz/iSnyF4giUIIp97/jDi3B0HnbVY89s6dPIOCHm5Lsaevfdd8vqhNBB1mKxg+LBhD9oy+TJk63p0grhcdaDOWJQLhzheI888kjaYlKn5yIDTCyDeok/B3Ew1UxdVr0ywOdBoD8n/vUinHkMfTeIJRwJedhhC1SSgQhQqZ0YbzF455Hra2svPpMSOiJ6aX1LmZReWyHESOsT/axPLMva2tMsuUs23HfbbTceYI++h8zuYWEW/P5Uc8HFef6OuXQcPHhwaLKF89XePvvsE0oPL+/VVG3NY+uzqNuECROs6YsQcpEZRwZCbeY9NyfyIo6r9DuBNUGoGliLeIgeFDzX6bD773EDBb4OPBwz9OB4L5ZGp+Xnfvvt53FToJFo3LhxMZ25cWSS9LN4e0Jtg8AstDT2T9EpO7QBUOhw6FdqAN2Ijws74ipkR6AEcQw3/vDq3XDb81plOA5g/s6nuoZTvGCnPqoHnPaFOjqugp999tmhCd3vf//7VPW5EsOE04MTnAC77bbbzlu8eLEreeZyOLgL6tY4wIdA5vXkVSCOPAT6DxgwIK9qKpZLzDR++hNOGkP5ZCACZGonWlg9Bo7hDRnDyf0EXG/qgAI2/Up1VozYECObbsRUrNfye0ElG+6YHD/BPpLMRew11ljDo+UYFy+7devm4Ry9xz6BO8acpMHvite3b1+PE3nEHfdgKu/v6HLyBvN4D+fTg8kn+zHEsw/9BlVzQysl1mXTnzJE0vEn+dQTZ/KDdLweO3ZsNVU68zz55JNB+aY+rh1sZ0EZP4CPnphet99+e8a1LC+Oi8g4wuDXB1N+78svv4zVw4URHAvxEMI3ppeJm3nN94XjCR7O7hc6BokpX0bARQhTZ17jKF0oh/SzQKVJSMzJan9Rp6KIvcGrWoq6AbL54Lctz9pdtAkAID42+hJC4iqUEgE6rMNutaJzHjrO4Tl2Os2hszuyvqazHgx6/DOHMM9S6MRCTOd+PFuPjsxPA7O1mjztHnzwwWratGmK5x+jMV0Zg5gO7ei4hnrRcz4m/X7L6YDtmmuu8b3qp4QilnzKlCmK5yR1TGE63qG3XZ7HK4rYfgxMQtXNnDlTlXOAFEpc5xuYigYa0EFiveivf/1rrOqkZ1JjGUVQDgEO+H4F5s5o1OcP728BMzbXx2ChFQisg0tiE8WMKf4NJqbEVqhABDBJ/6KWc/ZFqIqJvO/hHhZtvq8Anh83iaFlySYxDxbFM+9HbOe3GRqunr/9bDf70RkzZpgQqKlTp6qBAweGZFnc0E8DoxuQOL7imCpKHG8deeSRij5t6BOCoQIZCvjNN9/0fTswD50NkjmWYohChndkdIZGJfosiIZApmNJCXvbqG9M9CoKAbp1ja2Edcq4kl/PhZUOh24lyOtFxIO4uDAr7ya3Xlo3Tr0lG3ZcaQ0tvTbgDZzveaNGjfLgeM/17gM5TeKqPUZgNp3nzczz+lxZv+yyy8wkhV3DCY6/S2S+vw033DBkil6YMikrQgjBkJXGn3L2eeBSjxjyu2FiyJ2VKMnOAxDKjhgmI4S5cT89u2qqKqnD0MXUsVRVadlkIiamLub18pAj2dQjpdgRKEFsYu5fN0MfGf0do1Xa+PHjvWOPPdaDDwIPC+Pe9ttv72ER3TvrrLN8nzvRPFnd9+vXL4YhTdTrTdx1x6Q5pBuP/9FvUdZE60L9Xbr44ouzLr5hy7vqqquCduv228ZN0s8CnSahek5EmwSiRGpejFSDwJtbUu8M2UXgcyzP2lVEPIiLjd6AkHgKtSACMIVUF110kSqVSmrevHnqiSee8D3U0gMxrQpgFqm22GIL3+PtgQce6Fsq1AIDrQnQISntxZceb+E0R2HgVEuxVeelxQJMz9U556z4OYBjRV8/rvg3MjHWML32aurVy+V4XKfI55Pe+bl7YpLs7pto5HI9CqUeDF7fUvohkJ0Cnmh51o4iYkFMbMRwI8RSSBBIhAAm94pcNNG6zxbuzuYl36Yb+95LLrnEtyTERLnmvtysg9aJ/M03w+fSSnH69OnquOOOM5PWfM0de03NYomn9a3l8+abbw5lp/Xl0UcfHZLJjSDQrgjsiIbTFD22KtYpG1YnYDocOpXqpA9xcGFE/IijUHkESngcw7AZdy/yXN7mOUOey9RYIZatH30gSZ3cQYA5ozd37twkyVOloZUDnfVpvfg5dOjQVGXUIzGOQAQ6U/9aozdU2wZiZWJHXWh9ECXZeQBK2dK+KI4rPiH8O++/wef+4HpQByq16VSqgzLEgFjY9CF2xFAofwRKqCL2DqSPjP5Kuu/Z99kwpMVBEkJYuSA/vb1nTXQGTGs9U0c6MMySTKeF9NnA+3YgOo80ceW1KzKD9LNAp0nIdr6sSVRvODWfhkYrtu3i6l0D0YFxcVtJ2H7i4CLiRxyFBIGaEOCqPM+aIWyOXw46K4UBjMICQKJyYa6uEDrHP7PHuMVZEq0c4HQoVORdd93l+0wICRvoBoMcZZ6b51k++oQommgFgmMeoWrhPFDxXKlQ7gjcjxp+76ilC+R8Me28YMu2EwNiYSNiRwyFBIG6IMDfcfqtoU8dTI4VnLA6+x3b+X04OVRYOK+oOzzmK3jy99NxZ7h79+4V86RNAOeFCiEDQ9l45jwa0z6UIOUNFjfUJ5984udi7Hme1W8H+uMf/xhrJv0fCTU3AjLhz/b9XYni/uIokr8Ut4F/7Hje6mK2m+13/WISN+InJAjUhACd+eDsYdBRjxw50ncYmNQ5H3aLFaIE+DpwgLTmmmvWpI8tM50OmUSnQDfddJMpaqhrOlI0nS326dOnLvrdeeedgUNHrcApp9CCWqggBM5DPXTgZ6M1IKRXx81sD1tcxjaz7cTARsSM2AkJAnVDgMfJyOwjuYBLk3jzeJmp2J///Gfz1r9GtIJEk97rrrtO4Ty9n4eL7dgdj5WVhQA+DELF8MgZjxFkRe1ozs+xyKRJk0IQ0qkyQgyGZHLTfAjIhD/bd0YzmGPA4QOmK+r4D1xyhX/PFaK2uGJ72W6230bEi7gRPyFBoGoEOEiBUyF/14Ln5eHsyB8A8DoJsbOjt92PPvrIT77XXnuptdZaK0nWVGm4u/LjH4fX/hA/2Y+IkKqgghKbu/ussh6eejmYQ2jIUIv5fhrd90FI4ea/+RpNGARe/g8Sbw/P+D8M3ir+qGUlbCvbbPNvwEYTK2JG7IQEgboggBjv6sYbb4zVrf3bmA+4wPv444+bIv8azlJjsqgAcekVz+yTuFie5QQ8Wtduu+3mWyuYcoTHU0uWLDFFVV+344T/8ssvV7TQMEm/T1Mm182HwErNp3LDa/zf0LAfmJ82WhNC7mbTAVI7ENvJ9rLdNqqEly2PyASBGAJz5szxJ/sMM0jq2rWrv8t/7bXX+qFydKi/WEYI6KCIux7bbrttEIqGjoF++9vf2pJnIhs3blyoHIbwiZqrhxLU8aYRJvwMZxg115SBSF2+FG+i1gPBXzhq3whyToB3cDxvJTHbyLayzTYiRsSKmAkJAnVDgA5ybRQNDcewhS6rKR6pKke0juvfv79iqF3S2LFj1aabbupf5/WHCwoMQayJfXm0b9XP0nxyHKGdFvLIWL2c1KbRuda03PC4+uqrQ8X89Kc/9cMmh4RyIwgIAiEE+uDuczB3rW1Mxz6/AOdNHajAVn8p74pRPtvncmBEnYgPcRJKh0AJyWPvtJ0dEsFzu7f66qvHMDFxwi6/hwgAHnbwPZxd9CZOnOhhsOA7zFt//fVjeWHWn7t/HjrCMXWkY0GGnWskonM+E1sMEAtXj04U4TcghJXLiZBWTpwJ4ZuVL9ET/f8Dh96Lcf9PXO8Bzps6UIFNh1LOFe+B8tlGW92UERtiJFQ8AiVUGXsv7dxHYiIXw4MYIfqK/sn0Pxnqz4YdZfA/42HhPJRe37z00kvedtttF+SFCXhhfRkWKIJ6qSf7K0S/0apV9ckxhcahEUIRVtWIlJkYMlm3mZ+rrLKKRwd+5Uj6WSAlJAgAgQPA5Sa8/OeaDF4NnBd1oODQP3HnfSmvClEu28N22erVMuJCfITSI1BCFo1j8Nmugxk45vOwAh/gQGwYpx2m3p5tIm/DLirbZpttCvFC/8Ybb4Qm09QDO9nl+tfCnz388MMhbOsx+Ln11ltDOsBU1Fu8eHFZLGQggm9T/jQcVYTeTeSe5jZn5qxGR6ROrU8px3rZJrZN12X7/FWO9UvR5REo4XHsnbRrH8kfymeffTaGB2Ota/rwww894BOk+c53vuPNnz/f69GjRyAjpnD452EHX2fzcPzNu+CCC/zJocZ88ODB3hdffBGkyfuCixAbb7xxSM/DDz+8pmoRPjgoD1aCNZXVDJnfeecdj+9cv0N+InxyRdWlnwVSQoJAJwI/wyftoEL/SJH7BbjfDJwHdaBQW92lPCpDmWwH22OrU8uIB3ERqg6BErJpLIPPdhzMIPZuaFeBOxAzZ84MOikOOrhTb8PLJdtpp528pUuXBmXkfYEzcyH9NthgAw+mdXlXm7h8c+BDzOCQKXHeLBLC+ZMHj8whjLhbVYlkIIK3VQydgWpC78dyfxdk2TvDWN6+Dkt91Ke0/HGmf9kGtqVSe3+daa1SWFoESsgQe0ft2Eeav5OIXR/CBF73vf3228+jZRkt4DRm6667roez/X5W7tzDj03wjGkYog4+aLzNN988JMcxOA++aMwqC7umpYLWX3/Cp0/V9cM/TFDeq6++WnU5zZIRRzGC9hI/bnp89dVXFdWXfhZoCQkCBgJ74ZpeMEL/UJF7ujQdCk7mXQwJE1IH0tnqLSXMnzQZ9ab+bIetPi0jDsRDqHoESsiq8Qw+23Ewc/755wft5y7/Cy+8YO2guGsOL/1BWht+lA0ZMqTQnQkqS3N1OMEL6Xb88cdb21EPISIehHR7/fXXC1WDWJjvi1gRs0okAxGgVhydgKrKmffzHb4O/r85qNSBMkPfkc77UsZ1Ufc3Osu21UcZMSAWQvVFoITqY++oHftI83eSceRxvj22gKqx4qQfYU49+JMxs3kITeudeuqpMWs0nY+fcKDn3X///aF8Rd9EFzR+8IMfeAirl1oN8xgbF5tbnRCGL/S/glCK3rx58xI1W/pZfPuFBIEIAjvhng7qQv9YlvtHIdsGnBV1oCBbnaWsKkA51Jd62+oxZWw/cRCqDYESspu4+tftOJiBQyC/7dyRoMliOYLnYd/U34YdjwAUvXNt6spJdHQXBTGFzSR1uaY/ge9+97vBd22TTTYpVI977703qJvvbe211/YWLVqUSAcZiACxYukwVPcVOPTOLPd/hGxdcFbUgYJsdZYyqoC6UmdbHaaMbScGQvVHoAQVzHfjX7djH2n7seTOLXfEEcXGO/PMMz2e27/++uu9l19+2ZY8kH3wwQfetGnTfN83w4cP9+DU1psyZUrFfEEBOV989tln/s60+e5PPvnk1LXSukGXwU2AViZaM7Jf1e3lp3nUo1LbpZ8FYk1C324SPVtBzXloxK7g6eByIYt2wXOaxF8FvhTMSXKj0npQbCT4VPDKFZR8Gc9pxv9KhXTyWBBIjAC9AOOcoTriiCMUzBLL5qMHfkys1cKFC31P/PQkTA/CW2+9te+FNmnovrKVVPkQppHqpptuUoxZjA7WL2XYsGG+rjhXV2WptWeDj4HA4zJLKzIWL3ZmFDHQxPdDjLp166ZF8tlYCNwJdT4G3wZm3+CiY/HgAPBvwIwTxrPwjUjs044HXwQu1x7qzn56EPhB3ggJAo2MAHZwFUz5fU6jJ3ziqEMPPTRNlkLT4oiCmj59uurdu7cfoYeVYyFf0dM8OSm1Szg+jjWGDh2qcGwugGbgwIFqxIgRwb1cCAKCQPUIrIGst4BDK2qO+88gHwv+P+BqqQMZbXWVqi0Q+agP9aJ+trKjMraX7RbKBoESioliTIc7f6+0GivPGxuBc845J/Reeb4S4YHqpjR3c8zv2qxZswrRhSb7dA5l1n3uueemqlt2HoBefegHqHYuOPT+HPeLIeeqTqUFYyRxUgee2OoqOXOUf7AKHlOnxWBbuVEZ28o2CzUOAiWoEn1P0kem+gVt3sT049OlS5fg/dNXwYIFCxI3aO+99w7yLlmyJHG+Zks4cuTIoJ38f2GUhU8//TRVM6SfbZwfvUqarFQpgTzPHAGGohsM/iX4ywqlc5J8FngxeDx4a3A9ifVTj8Vg6lVpEs/2sZ1sL9stJAgIAmUQGDNmjIJ34SDFnDlznDGRg0Q5XiACQlA6jk0oDISC+zwvTj/9dHXPPfcEVSCUoho9enRwLxcNjcC70O4nYPYVlagrEkwCvwE+HbwOuF7EuqnD62DqRN0qEdvItrLNQoKAINAACBx44IEKYXcDTT7//HN/hx+e6ANZuYvtt99ewQGh6tu3r8IxtnJJm/bZpEmTFBwsBvrT2hFH6BQi4AQyuWgtBGTCX7/3eS2q7gt+NoEKqyPNr8Avgh/vvN4An0UQ62HdrJf185r6VCK2i+1jO4UEAUEgAQI0W7/55psVPAQHqSdPnhzqmIMHBVzgDH9QC5znqVVXXTW4z+viyiuvVPDCHxTPRQY4FVL1PHIRKCMXSRGgmT7tQnmMa1mCTBxVXw5eCp4KHgDmTnvexC8062KdrJs6JBnhs01s2wgw2yokCAgCDYTAiSeeqC688MJAo/fff1/tv//+gal/8MBywaOCsKxTc+fOtTxtftHs2bNDGwk8qgGfDgoRgpq/cdICJwIy4XdCU8iDZ1BLb/Ao8P8mrPHHSMddhffA88D8RePsoNJuO5IkIpbD8lguy2c9rI/1JiG2g+1hu9g+IUFAEEiBwCqrrKJmzJgRmvTDnF3ddhuPRhdLPPeIOMxq9913V4iIkHvlPH95xhlnBPXss88+CuaZipgINSUCd0PrnuCbwTQfrUSrIcEg8AzwR2DmPxm8Dfhb4FqJZbAslsmy/xvMulgn665EbAPbwjYxv5AgIAg0KALssxBWNtAOUXx8Pznwwh/IXBfc4W9Fevrpp30rQhyb85uHKAQKTgrVlltu2YrNlTYZCHzbuJbL+iDwDaodA/4v8DjwYeAkAxum+VEncyTO/97XwM91fr6FT+5YbAi2EZfy9gVvBO4G7gH+z87PLvhMSxwI3Qk+C/x22sySXhAQBFYgQOdDOC+vBg0a5E/+cahOwVuwQvxjhXi5KxLmfNWzZ0+FGMQ517K8+AceeEDRdF9bFRxyyCFq6tSphVgVFNLA9q2EE/djwJPBNN3YAZyE1kSigzuZ6T8Bs397HrwIzD7uH+D1wDbiTv2hYPZvm4F7gdnHrQWuhhYg03Dw49VkljyCgCBQPAKjRo3y+83TTjtNcZKL6De+k9+7726/9TpEYfAdNfKIA+mHP/yh4m4/ohQV/2KkRkFAEFA7AoP7wJxANwtTX+otVAwCJVQT+26I075UvmaaIjGd19GRH8zZ/ffdyiGCtKMktvW8887zGBKwFhJnQsX8GKWshQvVdFLBVaTYb1iDyqgrdabuQs2BQAlqxr5f0kfW8ova3HkZhnC99dbzvxN04odd/uZuUBXal0ql4H8C1nsevPNXUUo4i/SzzfGDSC1lh7/x3tXTUKkfmBPos8Hcoahmxx3ZciVaFNwFHgumzkKCgCCQMQI0K7z44ov9VXk62eEZxFYlxHVWGJCpk046yT9C0KrtbPN2ccB5O5jWYD8Hs49r1MVi9mvs36aB/w0WEgQEgSZFgGEIadLP8/n0RVOEP5pGg+rYY49VixYt8p3v0mJQqL0QkAl/475vDja4q8BwPyeAjwcncSaEZLkSzfVvBN8A5pEBoQZBAOFU1LJly3gmVajFENhqq60UndmR8I5brHXLm9OnTx9FJmXRRv4/CDUsApxA39HJffF5EpjH2f4DXE+iDxouRlwHfqKeikjd2SMgfWT2mDZbiWefzTXGbPqYZmv7aqut5i94ZNl+6Web7Vsg+jYDAjQn3AU8HrwYHJjmFHDN+lgv6xezRoBQZyqh/iLfv9QleLfSd4D/P0KNh8AaUOlIMA/XfgYu6jvHulgn66YOQs2PQAlNKOr7I/UI1vIdiH8H+D8o1EAIyA5/A72MCqrwB+WxTh6Oz63Be4F3Be8MpiVAVvQuCqJjokfBD4JfAgsJAoKAICAICAJ5IUBPUrd28qr4/Al4d/Bu4N7grHb/uYv/FPgR8EPgh8FfgoUEAUFAEBAEBIGWREAm/M37WjkJJ3PnnbQueFswve13A3cFfw+8HpjejjmAWhn8NZiDG+5q0Pz7Q/AS8Fvg18DPgj8CCzUuAlz8ERIEBIHqEJD/n+pwKzIX+6gHOpn1rgTeAtwL3B3MPu77YPZv64AZUo99HIl5/wX+GMw+7j0w+7c3wc+DXwfzSIFQ6yIg/+Ot+26lZc2BgPwPNth7kgl/g72QGtThJP1vnVxDMZK1CRDgIo2QICAIVIeA/P9Uh1s9c3GC/mon11MPqbs5EJD/8eZ4T6Jl6yIg/4MN9m7/P3/Rbgv5buolAAAAAElFTkSuQmCC"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Building\n",
+    "\n",
+    "This part is to build up the parameterized quantum circuit of QAOA to perform the computation process. Particularly, the QAOA circuit is constructed by alternatively placing two parameterized modules\n",
+    "\n",
+    "$$U_x(\\beta_P)U_c(\\gamma_P)\\dots U_x(\\beta_1)U_c(\\gamma_1)$$\n",
+    "\n",
+    "where $P$ is the number of layers to place these two modules. Particularly, one is governed by the encoding matrix $H_c$ via the unitary transformation\n",
+    "\n",
+    "$$U_c(\\gamma)=e^{-i \\gamma H_c }$$\n",
+    "\n",
+    "where $i$ is the imaginary unit, and $\\gamma\\in [0, \\pi]$ is to be optimized. The other one is \n",
+    "\n",
+    "$$U_x(\\beta)=e^{-i \\beta H_x },$$\n",
+    "\n",
+    "where $\\beta\\in [0, \\pi]$ and the driving Hamiltonian or matrix $H_x$ adimits an explicit form of\n",
+    "\n",
+    "$$H_x =X_1+X_2+X_3+X_4 $$\n",
+    "\n",
+    "where the operator $X=\\begin{bmatrix} 0 & 1\\\\ 1& 0\\end{bmatrix}$ defines the Pauli-X operation acting on the qubit.\n",
+    "\n",
+    "\n",
+    "\n",
+    "Further, each module in the QAOA circuit can be decomposed into a series of operations acting on single qubits and two qubits. In particular, the first has the decomposition of $U_c(\\gamma)=\\prod_{(i, j)}e^{-i \\gamma Z_iZ_j }$ while there is $U_x(\\beta)=\\prod_{i}e^{-i \\beta X_i}$ for the second. This is illustrated in the following figure.\n",
+    "\n",
+    "<div>\n",
+    "<img src=\"attachment:circuit.png\" width=\"400\"/>\n",
+    "</div>\n",
+    "\n",
+    "\n",
+    "Then, based on\n",
+    "\n",
+    "- initial state of QAOA circuits \n",
+    "- adjacency matrix describing the graph\n",
+    "- number of qubits\n",
+    "- number of layers\n",
+    "\n",
+    "we are able to construct the standard QAOA circuit:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def circuit_QAOA(theta, input_state, adjacency_matrix, N, P):\n",
+    "    \"\"\"\n",
+    "    This function constructs the parameterized QAOA circuit which is composed of P layers of two blocks:\n",
+    "    one block is U_theta[layer][0] based on the problem Hamiltonian H which encodes the classical problem,\n",
+    "    and the other is U_theta[layer][1] constructed from the driving Hamiltonian describing the rotation around Pauli X\n",
+    "    acting on each qubit. It finally outputs the final state of the QAOA circuit.\n",
+    "    \n",
+    "    Args:\n",
+    "         theta: parameters to be optimized in the QAOA circuit\n",
+    "         input_state: initial state of the QAOA circuit which usually is the uniform superposition of 2^N bit-strings \n",
+    "         in the computataional basis\n",
+    "         adjacency_matrix:  the adjacency matrix of the graph encoding the classical problem\n",
+    "         N: number of qubits, or equivalently, the number of parameters in the original classical problem\n",
+    "         P: number of layers of two blocks in the QAOA circuit\n",
+    "    Returns:\n",
+    "        the final state of the QAOA circuit: cir.state\n",
+    "\n",
+    "    \"\"\"\n",
+    "\n",
+    "    cir = UAnsatz(N, input_state=input_state)\n",
+    "    \n",
+    "    # This loop defines the QAOA circuit with P layers of two blocks\n",
+    "    for layer in range(P):\n",
+    "        # The second and third loops construct the first block U_theta[layer][0] which involves two-qubit operation\n",
+    "        #  e^{-i\\beta Z_iZ_j} acting on a pair of qubits or nodes i and j in the circuit in each layer.\n",
+    "        for row in range(N):\n",
+    "            for col in range(N):\n",
+    "                if abs(adjacency_matrix[row, col]) and row < col:\n",
+    "                    cir.cnot([row + 1, col + 1])\n",
+    "                    cir.rz(\n",
+    "                        theta=theta[layer][0]\n",
+    "                        * adjacency_matrix[row, col],\n",
+    "                        which_qubit=col + 1,\n",
+    "                    )\n",
+    "                    cir.cnot([row + 1, col + 1])\n",
+    "        # This loop constructs the second block U_theta only involving the single-qubit operation e^{-i\\beta X}.\n",
+    "        for i in range(1, N + 1):\n",
+    "            cir.rx(theta=theta[layer][1], which_qubit=i)\n",
+    "\n",
+    "    return cir.state"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Indeed, the QAOA circuit could be extended to other structures by replacing the modules in the above standard circuit to improve QAOA performance. Here, we provide one candidate extension in which the Pauli-X rotation $R_x(\\beta) $ on each qubit in the driving matrix $H_x$ is replaced by an arbitrary rotation described by $R_z(\\beta_1)R_x(\\beta_2)R_z(\\beta_3)$. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def circuit_extend_QAOA(theta, input_state, adjacency_matrix, N, P):\n",
+    "    \"\"\"\n",
+    "    This is an extended version of the QAOA circuit, and the main difference is U_theta[layer]([1]-[3]) constructed\n",
+    "    from the driving Hamiltonian describing the rotation around an arbitrary direction on each qubit.\n",
+    "\n",
+    "    Args:\n",
+    "        theta: parameters to be optimized in the QAOA circuit\n",
+    "        input_state: input state of the QAOA circuit which usually is the uniform superposition of 2^N bit-strings\n",
+    "                     in the computational basis\n",
+    "        adjacency_matrix:  the adjacency matrix of the problem graph encoding the original problem\n",
+    "        N: number of qubits, or equivalently, the number of parameters in the original classical problem\n",
+    "        P: number of layers of two blocks in the QAOA circuit\n",
+    "    Returns:\n",
+    "        final state of the QAOA circuit: cir.state\n",
+    "\n",
+    "    Note: If this U_extend_theta function is used to construct QAOA circuit, then we need to change the parameter layer\n",
+    "           in the Net function defined below from the Net(shape=[D, 2]) for U_theta function to Net(shape=[D, 4])\n",
+    "           because the number of parameters doubles in each layer in this QAOA circuit.\n",
+    "    \"\"\"\n",
+    "    cir = UAnsatz(N, input_state=input_state)\n",
+    "\n",
+    "    for layer in range(P):\n",
+    "        for row in range(N):\n",
+    "            for col in range(N):\n",
+    "                if abs(adjacency_matrix[row, col]) and row < col:\n",
+    "                    cir.cnot([row + 1, col + 1])\n",
+    "                    cir.rz(\n",
+    "                        theta=theta[layer][0]\n",
+    "                        * adjacency_matrix[row, col],\n",
+    "                        which_qubit=col + 1,\n",
+    "                    )\n",
+    "                    cir.cnot([row + 1, col + 1])\n",
+    "\n",
+    "        for i in range(1, N + 1):\n",
+    "            cir.rz(theta=theta[layer][1], which_qubit=i)\n",
+    "            cir.rx(theta=theta[layer][2], which_qubit=i)\n",
+    "            cir.rz(theta=theta[layer][3], which_qubit=i)\n",
+    "\n",
+    "    return cir.state"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, the QAOA circuit outputs\n",
+    "\n",
+    "$$|\\psi(\\boldsymbol{\\beta},\\boldsymbol{\\gamma}, P)\\rangle=U_x(\\beta_P)U_c(\\gamma_P)\\dots U_x(\\beta_1)U_c(\\gamma_1)|+\\rangle_1\\dots|+\\rangle_N$$\n",
+    "\n",
+    "where each qubit is initialized as the superposition state $|+\\rangle=\\frac{1}{\\sqrt{2}}\\left(|0\\rangle+|1\\rangle\\right)$. And we are able to obtain the loss function for the QAOA circuit\n",
+    "\n",
+    "$$F_P=\\min_{\\boldsymbol{\\beta},\\boldsymbol{\\gamma}} \\langle \\psi(\\boldsymbol{\\beta},\\boldsymbol{\\gamma}, P)| H_c|\\psi(\\boldsymbol{\\beta},\\boldsymbol{\\gamma}, P)\\rangle.$$\n",
+    "\n",
+    "Additionally, we may tend to fast classical algorithms to update the parameter vectors $\\boldsymbol{\\beta},\\boldsymbol{\\gamma}$ to achieve the optimal value for the above quantum optimization problem. \n",
+    "\n",
+    "In Paddle Quantum, this process is accomplished in the Net function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class Net(fluid.dygraph.Layer):\n",
+    "    \"\"\"\n",
+    "    It constructs the net for QAOA which combines the  QAOA circuit with the classical optimizer which sets rules\n",
+    "    to update parameters described by theta introduced in the QAOA circuit.\n",
+    "\n",
+    "    \"\"\"\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        shape,\n",
+    "        param_attr=fluid.initializer.Uniform(low=0.0, high=np.pi, seed=1024),\n",
+    "        dtype=\"float32\",\n",
+    "    ):\n",
+    "        super(Net, self).__init__()\n",
+    "\n",
+    "        self.theta = self.create_parameter(\n",
+    "            shape=shape, attr=param_attr, dtype=dtype, is_bias=False\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, input_state, adjacency_matrix, out_state_store, N, P, METHOD):\n",
+    "        \"\"\"\n",
+    "        This function constructs the loss function for the QAOA circuit.\n",
+    "\n",
+    "        Args:\n",
+    "            self: the free parameters to be optimized in the QAOA circuit and defined in the above function\n",
+    "            input_state: initial state of the QAOA circuit which usually is the uniform superposition of 2^N bit-strings\n",
+    "                         in the computational basis $|0\\rangle, |1\\rangle$\n",
+    "            adjacency_matrix: the adjacency matrix generated from the graph encoding the classical problem\n",
+    "            out_state_store: the output state of the QAOA circuit\n",
+    "            N: number of qubits\n",
+    "            P: number of layers\n",
+    "            METHOD: which version of QAOA is chosen to solve the problem, i.e., standard version labeled by 1 or\n",
+    "            extended version by 2.\n",
+    "        Returns:\n",
+    "            The loss function for the parameterized QAOA circuit.\n",
+    "        \"\"\"\n",
+    "        \n",
+    "        # Generate the problem_based quantum Hamiltonian H_problem based on the classical problem in paddle\n",
+    "        H, _ = H_generator(N, adjacency_matrix)\n",
+    "        H_problem = fluid.dygraph.to_variable(H)\n",
+    "\n",
+    "        # The standard QAOA circuit: the function circuit_QAOA is used to construct the circuit, indexed by METHOD 1.\n",
+    "        if METHOD == 1:\n",
+    "            out_state = circuit_QAOA(self.theta, input_state, adjacency_matrix, N, P)\n",
+    "        # The extended QAOA circuit: the function circuit_extend_QAOA is used to construct the net, indexed by METHOD 2.\n",
+    "        elif METHOD == 2:\n",
+    "            out_state = circuit_extend_QAOA(self.theta, input_state, adjacency_matrix, N, P)\n",
+    "        else:\n",
+    "            raise ValueError(\"Wrong method called!\")\n",
+    "\n",
+    "        out_state_store.append(out_state.numpy())\n",
+    "        loss = pp_matmul(\n",
+    "            pp_matmul(out_state, H_problem),\n",
+    "            transpose(\n",
+    "                fluid.framework.ComplexVariable(out_state.real, -out_state.imag),\n",
+    "                perm=[1, 0],\n",
+    "            ),\n",
+    "        )\n",
+    "\n",
+    "        return loss.real\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Training\n",
+    "\n",
+    "In this part, the QAOA circuit is trained to find the \"optimal\" solution to the optimization problem.\n",
+    "\n",
+    "First, let us specify some parameters:\n",
+    "\n",
+    "- number of qubits: N\n",
+    "- number of layes: P\n",
+    "- iteration steps: ITR\n",
+    "- learning rate: LR"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "N = 4 # number of qubits, or number of nodes in the graph\n",
+    "P = 4 # number of layers \n",
+    "ITR = 120  # number of iteration steps\n",
+    "LR = 0.1  # learning rate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then, with the following inputs\n",
+    "\n",
+    "- initial state: each qubit is initialized as $\\frac{1}{\\sqrt{2}}\\left(|0\\rangle+|1\\rangle\\right)$\n",
+    "- Standard QAOA circuit (METHOD = 1) or Extended QAOA (METHOD = 2) \n",
+    "- Classical optimizer: Adam optimizer\n",
+    "\n",
+    "we are able to train the whole net："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def Paddle_QAOA(classical_graph_adjacency, N, P, METHOD, ITR, LR):\n",
+    "    \"\"\"\n",
+    "    This is the core function to run QAOA.\n",
+    "\n",
+    "     Args:\n",
+    "         classical_graph_adjacency: adjacency matrix to describe the graph which encodes the classical problem\n",
+    "         N: number of qubits (default value N=4)\n",
+    "         P: number of layers of blocks in the QAOA circuit (default value P=4)\n",
+    "         METHOD: which version of the QAOA circuit is used: 1, standard circuit (default); 2, extended circuit\n",
+    "         ITR: number of iteration steps for QAOA (default value ITR=120)\n",
+    "         LR: learning rate for the gradient-based optimization method (default value LR=0.1)\n",
+    "     Returns:\n",
+    "         optimized parameters theta and the bitstrings sampled from the output state with maximal probability\n",
+    "    \"\"\"\n",
+    "    out_state_store = []\n",
+    "    with fluid.dygraph.guard():\n",
+    "        # Preparing the initial state\n",
+    "        _initial_state = np.ones([1, 2 ** N]).astype(\"complex64\") / np.sqrt(2 ** N)\n",
+    "        initial_state = fluid.dygraph.to_variable(_initial_state)\n",
+    "\n",
+    "        # Construct the net or QAOA circuits based on the standard modules\n",
+    "        if METHOD == 1:\n",
+    "            net = Net(shape=[P, 2])\n",
+    "        # Construct the net or QAOA circuits based on the extended modules\n",
+    "        elif METHOD == 2:\n",
+    "            net = Net(shape=[P, 4])\n",
+    "        else:\n",
+    "            raise ValueError(\"Wrong method called!\")\n",
+    "\n",
+    "        # Classical optimizer\n",
+    "        opt = fluid.optimizer.AdamOptimizer(learning_rate=LR, parameter_list=net.parameters())\n",
+    "\n",
+    "        # Gradient descent loop\n",
+    "        summary_iter, summary_loss = [], []\n",
+    "        for itr in range(1, ITR + 1):\n",
+    "            loss = net(\n",
+    "                initial_state, classical_graph_adjacency, out_state_store, N, P, METHOD\n",
+    "            )\n",
+    "            loss.backward()\n",
+    "            opt.minimize(loss)\n",
+    "            net.clear_gradients()\n",
+    "\n",
+    "            print(\"iter:\", itr, \"  loss:\", \"%.4f\" % loss.numpy())\n",
+    "            summary_loss.append(loss[0][0].numpy())\n",
+    "            summary_iter.append(itr)\n",
+    "\n",
+    "        theta_opt = net.parameters()[0].numpy()\n",
+    "        print(theta_opt)\n",
+    "\n",
+    "        os.makedirs(\"output\", exist_ok=True)\n",
+    "        np.savez(\"./output/summary_data\", iter=summary_iter, energy=summary_loss)\n",
+    "\n",
+    "    # Output the measurement probability distribution which is sampled from the output state of optimized QAOA circuit.\n",
+    "    prob_measure = np.zeros([1, 2 ** N]).astype(\"complex\")\n",
+    "\n",
+    "    rho_out = out_state_store[-1]\n",
+    "    rho_out = np_matmul(np.conjugate(rho_out).T, rho_out).astype(\"complex\")\n",
+    "\n",
+    "    for index in range(0, 2 ** N):\n",
+    "        comput_basis = np.zeros([1, 2 ** N])\n",
+    "        comput_basis[0][index] = 1\n",
+    "        prob_measure[0][index] = np.real(np_matmul(np_matmul(comput_basis, rho_out), comput_basis.T))\n",
+    "\n",
+    "    return prob_measure"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After the completion of training, the QAOA outputs the results, including the optimal parameters $\\boldsymbol{\\beta}^*$ and $\\boldsymbol{\\gamma}^*$. By contrast, its performance can be evaluated with the true value of the optimization problem."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "classical_graph, classical_graph_adjacency = generate_graph(N, 1)\n",
+    "\n",
+    "prob_measure_dis = Paddle_QAOA(classical_graph_adjacency, N =4, P=4, METHOD=1, ITR=120, LR=0.1)\n",
+    "\n",
+    "# Load the data of QAOA\n",
+    "x1 = np.load('./output/summary_data.npz')\n",
+    "\n",
+    "H_min = np.ones([len(x1['iter'])]) * H_graph_min\n",
+    "\n",
+    "# Plot it\n",
+    "\n",
+    "loss_QAOA, = plt.plot(x1['iter'], x1['energy'], \\\n",
+    "                                        alpha=0.7, marker='', linestyle=\"--\", linewidth=2, color='m')\n",
+    "benchmark, = plt.plot(x1['iter'], H_min, alpha=0.7, marker='', linestyle=\":\", linewidth=2, color='b')\n",
+    "plt.xlabel('Number of iteration')\n",
+    "plt.ylabel('Performance of the loss function for QAOA')\n",
+    "\n",
+    "plt.legend(handles=[\n",
+    "    loss_QAOA,\n",
+    "    benchmark\n",
+    "],\n",
+    "    labels=[\n",
+    "            r'Loss function $\\left\\langle {\\psi \\left( {\\bf{\\theta }} \\right)} '\n",
+    "            r'\\right|H\\left| {\\psi \\left( {\\bf{\\theta }} \\right)} \\right\\rangle $',\n",
+    "            'The benchmark result',\n",
+    "    ], loc='best')\n",
+    "\n",
+    "# Show the picture\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## 5. Decoding \n",
+    "\n",
+    "However, the output of optimized QAOA circuits \n",
+    "\n",
+    "$$|\\psi(\\boldsymbol{\\beta}^*,\\boldsymbol{\\gamma}^*, P)\\rangle=\\sum_{i=1}^{2^4}\\lambda_i |\\boldsymbol{x}_i\\rangle$$\n",
+    "\n",
+    "does not give us the answer to the Max-Cut problem directly. Instead, each bitstring $\\boldsymbol{x}_i=x_1x_2x_3 x_4\\in \\{0, 1\\}^4$ in the state $|\\psi(\\boldsymbol{\\beta}^*,\\boldsymbol{\\gamma}^*, P)$ represents a possible classical solution. Thus, we need to decode the ouptut of QAOA circuits. \n",
+    "\n",
+    "The task of decoding quantum answer can be accomplished via measurement. Given the output state, the measurement statistics for each bitstring obeys the probability distribution\n",
+    "\n",
+    "$$ p(\\boldsymbol{x})=|\\langle \\boldsymbol{x}|\\psi(\\boldsymbol{\\beta}^*,\\boldsymbol{\\gamma}^*,P)\\rangle|^2.$$\n",
+    "              \n",
+    "And this distribution is plotted using the following function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "prob_measure = prob_measure_dis.flatten()\n",
+    "\n",
+    "pos = nx.circular_layout(classical_graph)\n",
+    "# when N is large, it is not suggested to plot this figure\n",
+    "name_list = [np.binary_repr(index, width=N) for index in range(0, 2 ** N)]\n",
+    "plt.bar(\n",
+    "        range(len(np.real(prob_measure))),\n",
+    "        np.real(prob_measure),\n",
+    "        width=0.7,\n",
+    "        tick_label=name_list,\n",
+    "    )\n",
+    "plt.xticks(rotation=90)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Again, using the relation $|x \\rangle\\rightarrow z=2x-1$, we are able to obtain a classical answer from the quantum state. Specifically, assume that $z_i=-1$ for $i \\in S$ and $z_j=-1$ for $j \\in S^\\prime$. Thus, one bistring sampled from the output state of QAOA corresponds to one feasible cut to the given graph. And it is highly possible that the higher probability the bitstring is, the more likely it gives rise to the max cut protocol.\n",
+    "\n",
+    "The bistring with the largest probability is picked up, and then mapped back to solution to the Max-Cut problem ：\n",
+    "\n",
+    "- the node set $S$ is in blue color\n",
+    "- the node set $S^\\prime$ is in red color\n",
+    "- the dashed lines represent the cut edges "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Find the position of max value in the measure_prob_distribution\n",
+    "max_prob_pos_list = np.where(prob_measure == max(prob_measure))\n",
+    "# Store the max value from ndarray to list\n",
+    "max_prob_list = max_prob_pos_list[0].tolist()\n",
+    "# Change it to the  binary format\n",
+    "solution_list = [np.binary_repr(index, width=N) for index in max_prob_list]\n",
+    "print(\"The output bitstring:\", solution_list)\n",
+    "\n",
+    "# Draw the graph representing the first bitstring in the solution_list to the MaxCut-like problem\n",
+    "head_bitstring = solution_list[0]\n",
+    "\n",
+    "node_cut = [\"blue\" if head_bitstring[node] == \"1\" else \"red\" for node in classical_graph]\n",
+    "\n",
+    "edge_cut = [\n",
+    "    \"solid\" if head_bitstring[node_row] == head_bitstring[node_col] else \"dashed\"\n",
+    "    for node_row, node_col in classical_graph.edges()\n",
+    "    ]\n",
+    "nx.draw(\n",
+    "        classical_graph,\n",
+    "        pos,\n",
+    "        node_color=node_cut,\n",
+    "        style=edge_cut,\n",
+    "        width=4,\n",
+    "        with_labels=True,\n",
+    "        font_weight=\"bold\",\n",
+    ")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "is_executing": false
+    }
+   },
+   "source": [
+    "# References\n",
+    "\n",
+    "[1] Farhi, E., Goldstone, J., & Gutmann, S. (2014). A quantum approximate optimization algorithm. arXiv:1411.4028."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.10"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "metadata": {
+     "collapsed": false
+    },
+    "source": []
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

tutorial/SSVQE.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 概览\n",
+    "- 在这个案例中，我们将展示如何通过Paddle Quantum训练量子神经网络来求解量子系统的特征。\n",
+    "\n",
+    "- 首先，让我们通过下面几行代码引入必要的library和package。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import numpy\n",
+    "from paddle.complex import matmul, transpose\n",
+    "from paddle import fluid\n",
+    "from paddle_quantum.circuit import UAnsatz\n",
+    "from numpy import array, kron"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 背景\n",
+    "- 量子计算中在近期非常有前途的一个量子算法是变分量子特征求解器(VQE, variational quantum eigensolver (VQE)) [1-3].\n",
+    "- VQE是量子化学在近期有噪量子设备（NISQ device）上的核心应用之一，其中一个功能比较强大的版本是SSVQE [4]，其核心是去求解一个物理系统的哈密顿量的基态和激发态的性质。数学上，可以理解为求解一个厄米矩阵(Hermitian matrix)的特征值及其对应的特征向量。该哈密顿量的特征值组成的集合我们称其为能谱。\n",
+    "- 接下来我们将通过一个简单的例子学习如何通过训练量子神经网络解决这个问题，即求解出给定哈密顿量的能谱。\n",
+    "\n",
+    "## SSVQE分析物理系统的基态和激发态的能量\n",
+    "- 对于具体需要分析的分子，我们需要输入其几何、电荷构型等多项信息。具体的，通过我们内置的量子化学工具包可以利用fermionic-to-qubit映射的技术来输出目标分子的量子比特哈密顿量表示。\n",
+    "- 在这里，作为简单的入门案例，我们提供一个简单的2量子位哈密顿量作为例子。 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "sigma_I = array([[1, 0], [0, 1]])\n",
+    "sigma_X = array([[0, 1], [1, 0]])\n",
+    "sigma_Y = array([[0, -1j], [1j, 0]])\n",
+    "sigma_Z = array([[1, 0], [0, -1]])\n",
+    "H = 0.4 * kron(sigma_Z, sigma_I) + 0.4 * kron(sigma_I, sigma_Z) + 0.2 * kron(sigma_X, sigma_X)\n",
+    "hamiltonian = H.astype('complex64')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 搭建量子神经网络（QNN）\n",
+    "- 在实现SSVQE的过程中，我们首先需要设计1个量子神经网络QNN（也可以理解为参数化量子电路）。这里，我们提供一个预设的2量子位量子电路。\n",
+    "\n",
+    "- 我们预设一些该参数化电路的参数，比如宽度为2量子位。\n",
+    "\n",
+    "- 初始化其中的变量参数，${\\bf{\\theta }}$代表我们量子神经网络中的参数组成的向量，一共有12个参数。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "N = 2 # 量子神经网络的宽度\n",
+    "THETA_SIZE = 12 # 量子神经网络中参数的数量\n",
+    "\n",
+    "def U_theta(theta, N):\n",
+    "    \"\"\"\n",
+    "    U_theta\n",
+    "    \"\"\"\n",
+    "\n",
+    "    cir = UAnsatz(N)\n",
+    "    # ============== D1=2 ==============\n",
+    "    cir.ry(theta[0], 2)\n",
+    "    cir.rz(theta[1], 2)\n",
+    "    cir.cnot([2, 1])\n",
+    "    cir.ry(theta[2], 2)\n",
+    "    cir.rz(theta[3], 2)\n",
+    "    cir.cnot([2, 1])\n",
+    "\n",
+    "    # ============== D2=2 ==============\n",
+    "    cir.ry(theta[4], 1)\n",
+    "    cir.ry(theta[5], 2)\n",
+    "    cir.rz(theta[6], 1)\n",
+    "    cir.rz(theta[7], 2)\n",
+    "    cir.cnot([1, 2])\n",
+    "\n",
+    "    cir.ry(theta[8], 1)\n",
+    "    cir.ry(theta[9], 2)\n",
+    "    cir.rz(theta[10], 1)\n",
+    "    cir.rz(theta[11], 2)\n",
+    "    cir.cnot([1, 2])\n",
+    "\n",
+    "    return cir.state"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 配置训练模型 - 损失函数\n",
+    "- 现在我们已经有了数据和量子神经网络的架构，我们将进一步定义训练参数、模型和损失函数，具体的理论可以参考 [4].\n",
+    "- 通过作用量子神经网络$U(\\theta)$在1组正交的初始态上，我们将得到输出态$\\left| {\\psi_k \\left( {\\bf{\\theta }} \\right)} \\right\\rangle $。\n",
+    "- 进一步，在SSVQE模型中的损失函数一般由哈密顿量H与量子态$\\left| {\\psi_k \\left( {\\bf{\\theta }} \\right)} \\right\\rangle$的内积的加权求和给出。\n",
+    "- 具体的损失函数定义为\n",
+    "$$4\\left\\langle {\\psi_1 \\left( {\\bf{\\theta }} \\right)} \\right|H\\left| {\\psi_1 \\left( {\\bf{\\theta }} \\right)} \\right\\rangle + 3\\left\\langle {\\psi_2 \\left( {\\bf{\\theta }} \\right)} \\right|H\\left| {\\psi_2 \\left( {\\bf{\\theta }} \\right)} \\right\\rangle + 2\\left\\langle {\\psi_3 \\left( {\\bf{\\theta }} \\right)} \\right|H\\left| {\\psi_3 \\left( {\\bf{\\theta }} \\right)} \\right\\rangle + \\left\\langle {\\psi_4 \\left( {\\bf{\\theta }} \\right)} \\right|H\\left| {\\psi_4 \\left( {\\bf{\\theta }} \\right)} \\right\\rangle.$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "SEED = 1\n",
+    "\n",
+    "class Net(fluid.dygraph.Layer):\n",
+    "    \"\"\"\n",
+    "    Construct the model net\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, shape, param_attr=fluid.initializer.Uniform(low=0.0, high=2 * numpy.pi, seed=SEED),\n",
+    "                 dtype='float32'):\n",
+    "        super(Net, self).__init__()\n",
+    "\n",
+    "        self.theta = self.create_parameter(shape=shape, attr=param_attr, dtype=dtype, is_bias=False)\n",
+    "\n",
+    "    def forward(self, H, N):\n",
+    "        \"\"\"\n",
+    "        Args:\n",
+    "            input_state: The initial state with default |0..>\n",
+    "            H: The target Hamiltonian\n",
+    "        Returns:\n",
+    "            The loss.\n",
+    "        \"\"\"\n",
+    "        out_state = U_theta(self.theta, N)\n",
+    "\n",
+    "        loss_struct = matmul(matmul(\n",
+    "            transpose(fluid.framework.ComplexVariable(out_state.real, -out_state.imag), perm=[1, 0]), H),\n",
+    "            out_state).real\n",
+    "\n",
+    "        loss_components = [\n",
+    "            loss_struct[0][0],\n",
+    "            loss_struct[1][1],\n",
+    "            loss_struct[2][2],\n",
+    "            loss_struct[3][3]\n",
+    "        ]\n",
+    "\n",
+    "        loss = 4 * loss_components[0] + 3 * loss_components[1] + 2 * loss_components[2] + 1 * loss_components[3]\n",
+    "        return loss, loss_components\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 配置训练模型 - 模型参数\n",
+    "在进行量子神经网络的训练之前，我们还需要进行一些训练（超）参数的设置，例如学习速率与迭代次数。\n",
+    "- 设定学习速率（learning rate）为0.3。\n",
+    "- 设定迭代次数为50次。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ITR = 50 # 迭代次数\n",
+    "\n",
+    "LR = 0.3 # 学习速率\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 进行训练\n",
+    "\n",
+    "- 当训练模型的各项参数都设置完成后，我们将数据转化为Paddle动态图中的变量，进而进行量子神经网络的训练。\n",
+    "- 过程中我们用的是Adam Optimizer，也可以调用Paddle中提供的其他优化器。\n",
+    "- 我们将训练过程中的每一轮loss可以打印出来。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "with fluid.dygraph.guard():\n",
+    "    # Harmiltonian preparing\n",
+    "    hamiltonian = fluid.dygraph.to_variable(hamiltonian)\n",
+    "\n",
+    "    # net\n",
+    "    net = Net(shape=[THETA_SIZE])\n",
+    "\n",
+    "    # optimizer\n",
+    "    opt = fluid.optimizer.AdagradOptimizer(learning_rate=LR, parameter_list=net.parameters())\n",
+    "\n",
+    "    # gradient descent loop\n",
+    "    for itr in range(1, ITR + 1):\n",
+    "        loss, loss_components = net(hamiltonian, N)\n",
+    "\n",
+    "        loss.backward()\n",
+    "        opt.minimize(loss)\n",
+    "        net.clear_gradients()\n",
+    "\n",
+    "        print('iter:', itr, 'loss:', '%.4f' % loss.numpy()[0])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 测试效果\n",
+    "我们现在已经完成了量子神经网络的训练，我们将通过与理论值的对比来测试效果。\n",
+    "- 理论值由numpy中的工具来求解哈密顿量的各个特征值；\n",
+    "- 我们将训练QNN得到的各个能级的能量和理想情况下的理论值进行比对。\n",
+    "- 可以看到，SSVQE训练输出的值与理想值高度接近。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "print('The estimated ground state energy is: ', loss_components[0].numpy())\n",
+    "print('The theoretical ground state energy: ', numpy.linalg.eigh(H)[0][0])\n",
+    "\n",
+    "print('The estimated 1st excited state energy is: ', loss_components[1].numpy())\n",
+    "print('The theoretical 1st excited state energy: ', numpy.linalg.eigh(H)[0][1])\n",
+    "\n",
+    "print('The estimated 2nd excited state energy is: ', loss_components[2].numpy())\n",
+    "print('The theoretical 2nd excited state energy: ', numpy.linalg.eigh(H)[0][2])\n",
+    "\n",
+    "print('The estimated 3rd excited state energy is: ', loss_components[3].numpy())\n",
+    "print('The theoretical 3rd excited state energy: ', numpy.linalg.eigh(H)[0][3])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## 参考文献\n",
+    "[1] A. Peruzzo et al., “A variational eigenvalue solver on a photonic quantum processor,” Nat. Commun., vol. 5, no. 1, p. 4213, Dec. 2014.\n",
+    "\n",
+    "[2] S. McArdle, S. Endo, A. Aspuru-Guzik, S. C. Benjamin, and X. Yuan, “Quantum computational chemistry,” Rev. Mod. Phys., vol. 92, no. 1, p. 015003, Mar. 2020.\n",
+    "\n",
+    "[3] Y. Cao et al., “Quantum chemistry in the age of quantum computing,” Chem. Rev., vol. 119, no. 19, pp. 10856–10915, 2019.\n",
+    "\n",
+    "[4] K. M. Nakanishi, K. Mitarai, and K. Fujii, “Subspace-search variational quantum eigensolver for excited states,” Phys. Rev. Res., vol. 1, no. 3, p. 033062, Oct. 2019.\n",
+    "\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.7"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "metadata": {
+     "collapsed": false
+    },
+    "source": []
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

tutorial/VQSD.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 概览\n",
+    "- 在这个案例中，我们将展示如何通过Paddle Quantum训练量子神经网络来将量子态进行对角化。\n",
+    "\n",
+    "- 首先，让我们通过下面几行代码引入必要的library和package。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import numpy\n",
+    "from numpy import diag\n",
+    "import scipy\n",
+    "from paddle import fluid\n",
+    "from paddle_quantum.circuit import UAnsatz\n",
+    "from paddle.complex import matmul, trace, transpose"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "$\\newcommand{\\ket}[1]{|{#1}\\rangle}$\n",
+    "$\\newcommand{\\bra}[1]{\\langle{#1}|}$\n",
+    "\n",
+    "## 背景\n",
+    "量子态对角化算法（VQSD）[1-3] 目标是输出一个量子态的特征谱，即其所有特征值。求解量子态的特征值在量子计算中有着诸多应用，比如可以用于计算保真度和冯诺依曼熵，也可以用于主成分分析。\n",
+    "- 量子态通常是一个混合态，表示如下 $\\rho_{\\text{mixed}} = \\sum_i P_i \\ket{\\psi_i}\\bra{\\psi_i}$\n",
+    "- 作为一个简单的例子，我们考虑一个2量子位的量子态，它的特征谱为 $(0.5, 0.3, 0.1, 0.1)$, 我们先通过随机作用一个酉矩阵来生成具有这样特征谱的量子态。\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "scipy.random.seed(1)\n",
+    "V = scipy.stats.unitary_group.rvs(4) # 随机生成一个酉矩阵\n",
+    "D = diag([0.5, 0.3, 0.1, 0.1]) # 输入目标态rho的谱\n",
+    "V_H = V.conj().T \n",
+    "rho = V @ D @ V_H # 生成 rho\n",
+    "print(rho) # 打印量子态 rho\n",
+    "rho = rho.astype('complex64')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 搭建量子神经网络\n",
+    "- 在这个案例中，我们将通过训练量子神经网络QNN（也可以理解为参数化量子电路）来学习量子态的特征谱。这里，我们提供一个预设的2量子位量子电路。\n",
+    "\n",
+    "- 我们预设一些该参数化电路的参数，比如宽度为2量子位。\n",
+    "\n",
+    "- 初始化其中的变量参数，${\\bf{\\theta }}$代表我们量子神经网络中的参数组成的向量。\n",
+    "         "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%% \n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "N = 2 # 量子神经网络的宽度\n",
+    "SEED = 1 # 种子\n",
+    "THETA_SIZE = 14 # 网络中的参数\n",
+    "\n",
+    "def U_theta(theta, N):\n",
+    "    \"\"\"\n",
+    "    U_theta\n",
+    "    \"\"\"\n",
+    "\n",
+    "    cir = UAnsatz(N)\n",
+    "    cir.rz(theta[0], 1)\n",
+    "    cir.ry(theta[1], 1)\n",
+    "    cir.rz(theta[2], 1)\n",
+    "\n",
+    "    cir.rz(theta[3], 2)\n",
+    "    cir.ry(theta[4], 2)\n",
+    "    cir.rz(theta[5], 2)\n",
+    "\n",
+    "    cir.cnot([2, 1])\n",
+    "\n",
+    "    cir.rz(theta[6], 1)\n",
+    "    cir.ry(theta[7], 2)\n",
+    "\n",
+    "    cir.cnot([1, 2])\n",
+    "\n",
+    "    cir.rz(theta[8], 1)\n",
+    "    cir.ry(theta[9], 1)\n",
+    "    cir.rz(theta[10], 1)\n",
+    "\n",
+    "    cir.rz(theta[11], 2)\n",
+    "    cir.ry(theta[12], 2)\n",
+    "    cir.rz(theta[13], 2)\n",
+    "\n",
+    "    return cir.state\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## 配置训练模型 - 损失函数\n",
+    "- 现在我们已经有了数据和量子神经网络的架构，我们将进一步定义训练参数、模型和损失函数。\n",
+    "- 通过作用量子神经网络$U(\\theta)$在量子态$\\rho$后得到的量子态记为$\\tilde\\rho$，我们设定损失函数为$\\tilde\\rho$与用来标记的量子态$\\sigma=0.1 \\ket{00}\\bra{00} + 0.2 \\ket{01}\\bra{01} + 0.3 \\ket{10}\\bra{10} + 0.4 \\ket{11}\\bra{11}$的内积。\n",
+    "- 具体的，设定损失函数为 $\\mathcal{L}(\\boldsymbol{\\theta})  = Tr(\\tilde\\rho\\sigma) .$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "sigma = diag([0.1, 0.2, 0.3, 0.4]) # 输入用来标记的量子态sigma\n",
+    "sigma = sigma.astype('complex64')\n",
+    "\n",
+    "class Net(fluid.dygraph.Layer):\n",
+    "    \"\"\"\n",
+    "    Construct the model net\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, shape, rho, sigma, param_attr=fluid.initializer.Uniform(low=0.0, high=2 * numpy.pi, seed=SEED),\n",
+    "                 dtype='float32'):\n",
+    "        super(Net, self).__init__()\n",
+    "\n",
+    "        self.rho = fluid.dygraph.to_variable(rho)\n",
+    "        self.sigma = fluid.dygraph.to_variable(sigma)\n",
+    "\n",
+    "        self.theta = self.create_parameter(shape=shape, attr=param_attr, dtype=dtype, is_bias=False)\n",
+    "\n",
+    "    def forward(self, N):\n",
+    "        \"\"\"\n",
+    "        Args:\n",
+    "        Returns:\n",
+    "            The loss.\n",
+    "        \"\"\"\n",
+    "\n",
+    "        out_state = U_theta(self.theta, N)\n",
+    "\n",
+    "        # rho_tilde 是将U_theta作用在rho后得到的量子态 \n",
+    "        rho_tilde = matmul(\n",
+    "            matmul(transpose(\n",
+    "                fluid.framework.ComplexVariable(out_state.real, -out_state.imag),\n",
+    "                perm=[1, 0]\n",
+    "            ), self.rho), out_state\n",
+    "        )\n",
+    "\n",
+    "        # record the new loss\n",
+    "        loss = trace(matmul(self.sigma, rho_tilde))\n",
+    "\n",
+    "        return loss.real, rho_tilde"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 配置训练模型 - 模型参数\n",
+    "在进行量子神经网络的训练之前，我们还需要进行一些训练（超）参数的设置，例如学习速率与迭代次数。\n",
+    "- 设定学习速率（learning rate）为0.1;\n",
+    "- 设定迭代次数为50次。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ITR = 50 #训练的总的迭代次数\n",
+    "\n",
+    "LR = 0.1 #学习速率"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 进行训练\n",
+    "\n",
+    "- 当训练模型的各项参数都设置完成后，我们将数据转化为Paddle动态图中的变量，进而进行量子神经网络的训练。\n",
+    "- 过程中我们用的是Adam Optimizer，也可以调用Paddle中提供的其他优化器。\n",
+    "- 我们将训练过程中的结果依次输出。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%% \n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "with fluid.dygraph.guard():\n",
+    "    # net\n",
+    "    net = Net(shape=[THETA_SIZE], rho=rho, sigma=sigma)\n",
+    "\n",
+    "    # optimizer\n",
+    "    opt = fluid.optimizer.AdagradOptimizer(learning_rate=LR, parameter_list=net.parameters())\n",
+    "    # gradient descent loop\n",
+    "    for itr in range(ITR):\n",
+    "        loss, rho_tilde = net(N)\n",
+    "\n",
+    "        rho_tilde_np = rho_tilde.numpy()\n",
+    "        loss.backward()\n",
+    "        opt.minimize(loss)\n",
+    "        net.clear_gradients()\n",
+    "\n",
+    "        print('iter:', itr, 'loss:', '%.4f' % loss.numpy()[0])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 总结\n",
+    "根据上面训练得到的结果，通过大概50次迭代，我们就比较好的完成了对角化。\n",
+    "我们可以通过打印$\n",
+    "\\tilde{\\rho} = U(\\boldsymbol{\\theta})\\rho U^\\dagger(\\boldsymbol{\\theta})\n",
+    "$\n",
+    "的来验证谱分解的效果。特别的，我们可以验证它的对角线与我们目标谱是非常接近的。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "print(rho_tilde_np)\n",
+    "\n",
+    "print(\"The estimated spectrum is:\", numpy.real(numpy.diag(rho_tilde_np)))\n",
+    "print(\"The target spectrum is:\", numpy.diag(D))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "### 参考文献\n",
+    "\n",
+    "[1] R. Larose, A. Tikku, É. O. Neel-judy, L. Cincio, and P. J. Coles, “Variational quantum state diagonalization,” npj Quantum Inf., no. November 2018, 2019.\n",
+    "\n",
+    "[2] K. M. Nakanishi, K. Mitarai, and K. Fujii, “Subspace-search variational quantum eigensolver for excited states,” Phys. Rev. Res., vol. 1, no. 3, p. 033062, Oct. 2019.\n",
+    "\n",
+    "[3] M. Cerezo, K. Sharma, A. Arrasmith, and P. J. Coles, “Variational Quantum State Eigensolver,” arXiv:2004.01372, no. 1, pp. 1–14, Apr. 2020.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.10"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "metadata": {
+     "collapsed": false
+    },
+    "source": []
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}