From 545a7eb923621f00175713d643334ce5d75b787c Mon Sep 17 00:00:00 2001 From: liwt31 Date: Thu, 14 Nov 2024 18:04:49 +0800 Subject: [PATCH] update readme and vbe tutorial --- README.md | 6 +- README_CN.md | 5 +- .../vbe_tutorial_groundstate.ipynb | 377 +++++++++--------- tests/static/test_static.py | 6 +- 4 files changed, 198 insertions(+), 196 deletions(-) diff --git a/README.md b/README.md index 3545f21..d432d7d 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ [![ci](https://img.shields.io/github/actions/workflow/status/tensorcircuit/TenCirChem-NG/ci.yml?branch=master)](https://github.com/tensorcircuit/TenCirChem-NG/actions) [![codecov](https://codecov.io/github/tensorcircuit/TenCirChem-ng/branch/master/graph/badge.svg?token=6QZP1RKVTT)](https://app.codecov.io/github/tensorcircuit/TenCirChem-ng) [![pypi](https://img.shields.io/pypi/v/tencirchem-ng.svg?logo=pypi)](https://pypi.org/project/tencirchem-ng/) -[![doc](https://img.shields.io/badge/docs-link-green.svg)](https://tensorcircuit.github.io/TenCirChem-ng/index.html) +[![doc](https://img.shields.io/badge/docs-link-green.svg)](https://tensorcircuit.github.io/TenCirChem-NG/index.html) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/tensorcircuit/TenCirChem-ng/master?labpath=docs%2Fsource%2Ftutorial_jupyter) English | [简体中文](https://github.com/tensorcircuit/TenCirChem-ng/blob/master/README_CN.md) @@ -23,6 +23,10 @@ Getting started with TenCirChem-NG by installing the package via pip: pip install tencirchem-ng ``` +Some functionality of TenCirChem-NG requires JAX. +Please install JAX following [installation instructions](https://jax.readthedocs.io/en/latest/installation.html) +or simply by ``pip install tencirchem-ng[jax]``. + ## Simple to Use TenCirChem is written in pure Python, and its use is straightforward. Here's an example of calculating UCCSD: diff --git a/README_CN.md b/README_CN.md index dabc01e..17bf61e 100644 --- a/README_CN.md +++ b/README_CN.md @@ -5,7 +5,7 @@ [![ci](https://img.shields.io/github/actions/workflow/status/tensorcircuit/TenCirChem-NG/ci.yml?branch=master)](https://github.com/tensorcircuit/TenCirChem-NG/actions) [![codecov](https://codecov.io/github/tensorcircuit/TenCirChem-NG/branch/master/graph/badge.svg?token=6QZP1RKVTT)](https://app.codecov.io/github/tensorcircuit/TenCirChem-NG) [![pypi](https://img.shields.io/pypi/v/tencirchem-ng.svg?logo=pypi)](https://pypi.org/project/tencirchem-ng/) -[![doc](https://img.shields.io/badge/docs-link-green.svg)](https://tensorcircuit.github.io/TenCirChem-ng/index.html) +[![doc](https://img.shields.io/badge/docs-link-green.svg)](https://tensorcircuit.github.io/TenCirChem-NG/index.html) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/tensorcircuit/TenCirChem-NG/master?labpath=docs%2Fsource%2Ftutorial_jupyter) [English](https://github.com/tensorcircuit/TenCirChem-NG/) | 简体中文 @@ -21,6 +21,9 @@ TenCirChem-NG与TenCirChem完全兼容，并具有更多特性和漏洞修复。 pip install tencirchem ``` +TenCirChem的一些功能依赖JAX，请参见[安装指南](https://jax.readthedocs.io/en/latest/installation.html)安装JAX， +或直接通过``pip install tencirchem-ng[jax]``安装。 + ## 简单易用 TenCirChem 用纯 Python 编写，使用起来非常简单。以下是计算 UCCSD 的示例： diff --git a/docs/source/tutorial_jupyter/vbe_tutorial_groundstate.ipynb b/docs/source/tutorial_jupyter/vbe_tutorial_groundstate.ipynb index ce8cceb..7fed5d8 100644 --- a/docs/source/tutorial_jupyter/vbe_tutorial_groundstate.ipynb +++ b/docs/source/tutorial_jupyter/vbe_tutorial_groundstate.ipynb @@ -54,7 +54,7 @@ "import tensorcircuit as tc\n", "\n", "from tencirchem import set_backend, Op, BasisSHO, BasisSimpleElectron, Mpo, Model\n", - "from tencirchem.dynamic import get_ansatz, qubit_encode_op, qubit_encode_basis\n", + "from tencirchem.dynamic import get_ansatz, qubit_encode_op_grouped, qubit_encode_basis\n", "from tencirchem.utils import scipy_opt_wrap\n", "from tencirchem.applications.vbe_lib import get_psi_indices, get_contracted_mpo, get_contract_args" ] @@ -85,8 +85,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2023-08-08 15:44:36.794994: E external/org_tensorflow/tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.cc:267] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected\n", - "WARNING:jax._src.lib.xla_bridge:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" + "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n" ] }, { @@ -107,7 +106,6 @@ "omega = 1\n", "v = 1\n", "# two qubit for each mode\n", - "# modify param_ids before modifying this\n", "n_qubit_per_mode = 2\n", "nbas_v = 1 << n_qubit_per_mode\n", "\n", @@ -148,7 +146,7 @@ "$$\\ket{\\phi}=\\prod_l^L {\\prod_{} e^{\\theta_{ijk} {(\\hat{a}_j^\\dagger \\hat{a}_k - \\hat{a}_k^\\dagger \\hat{a}_j)}} \n", "\\prod_j {e^{\\theta_{lj}\\hat{a}_j^\\dagger \\hat{a}_j (\\hat{b}_j^\\dagger - \\hat{b}_j)}}} \\ket{\\phi_0} $$\n", "\n", - "The anasatz is transformed from electron-phonon basis to qubit basis through `qubit_encode_op()` and `qubit_encode_basis()`" + "The anasatz is transformed from electron-phonon basis to qubit basis through `qubit_encode_op_grouped()` and `qubit_encode_basis()`" ] }, { @@ -162,13 +160,11 @@ "output_type": "stream", "text": [ "ansatz_terms: \n", - " [Op('X Y', [0, 1], 0.5j), Op('Y X', [0, 1], -0.5j), Op('Y', [((0, 0), 'TCCQUBIT-1')], 0.1830127018922193j), Op('Z Y', [((0, 0), 'TCCQUBIT-0'), ((0, 0), 'TCCQUBIT-1')], -0.6830127018922193j), Op('Y', [((0, 0), 'TCCQUBIT-0')], -0.3535533905932738j), Op('Y Z', [((0, 0), 'TCCQUBIT-0'), ((0, 0), 'TCCQUBIT-1')], 0.3535533905932738j), Op('Z Y', [0, ((0, 0), 'TCCQUBIT-1')], -0.1830127018922193j), Op('Z Z Y', [0, ((0, 0), 'TCCQUBIT-0'), ((0, 0), 'TCCQUBIT-1')], 0.6830127018922193j), Op('Z Y', [0, ((0, 0), 'TCCQUBIT-0')], 0.3535533905932738j), Op('Z Y Z', [0, ((0, 0), 'TCCQUBIT-0'), ((0, 0), 'TCCQUBIT-1')], -0.3535533905932738j), Op('X Y', [1, 2], 0.5j), Op('Y X', [1, 2], -0.5j), Op('Y', [((1, 0), 'TCCQUBIT-1')], 0.1830127018922193j), Op('Z Y', [((1, 0), 'TCCQUBIT-0'), ((1, 0), 'TCCQUBIT-1')], -0.6830127018922193j), Op('Y', [((1, 0), 'TCCQUBIT-0')], -0.3535533905932738j), Op('Y Z', [((1, 0), 'TCCQUBIT-0'), ((1, 0), 'TCCQUBIT-1')], 0.3535533905932738j), Op('Z Y', [1, ((1, 0), 'TCCQUBIT-1')], -0.1830127018922193j), Op('Z Z Y', [1, ((1, 0), 'TCCQUBIT-0'), ((1, 0), 'TCCQUBIT-1')], 0.6830127018922193j), Op('Z Y', [1, ((1, 0), 'TCCQUBIT-0')], 0.3535533905932738j), Op('Z Y Z', [1, ((1, 0), 'TCCQUBIT-0'), ((1, 0), 'TCCQUBIT-1')], -0.3535533905932738j), Op('X Y', [0, 2], -0.5j), Op('Y X', [0, 2], 0.5j), Op('Y', [((2, 0), 'TCCQUBIT-1')], 0.1830127018922193j), Op('Z Y', [((2, 0), 'TCCQUBIT-0'), ((2, 0), 'TCCQUBIT-1')], -0.6830127018922193j), Op('Y', [((2, 0), 'TCCQUBIT-0')], -0.3535533905932738j), Op('Y Z', [((2, 0), 'TCCQUBIT-0'), ((2, 0), 'TCCQUBIT-1')], 0.3535533905932738j), Op('Z Y', [2, ((2, 0), 'TCCQUBIT-1')], -0.1830127018922193j), Op('Z Z Y', [2, ((2, 0), 'TCCQUBIT-0'), ((2, 0), 'TCCQUBIT-1')], 0.6830127018922193j), Op('Z Y', [2, ((2, 0), 'TCCQUBIT-0')], 0.3535533905932738j), Op('Z Y Z', [2, ((2, 0), 'TCCQUBIT-0'), ((2, 0), 'TCCQUBIT-1')], -0.3535533905932738j)] \n", + " [[Op('X Y', [0, 1], 0.5j), Op('Y X', [0, 1], -0.5j)], Op('Y', [((0, 0), 'TCCQUBIT-1')], 0.1830127018922193j), Op('Z Y', [((0, 0), 'TCCQUBIT-0'), ((0, 0), 'TCCQUBIT-1')], -0.6830127018922193j), Op('Y', [((0, 0), 'TCCQUBIT-0')], -0.3535533905932738j), Op('Y Z', [((0, 0), 'TCCQUBIT-0'), ((0, 0), 'TCCQUBIT-1')], 0.3535533905932738j), Op('Z Y', [0, ((0, 0), 'TCCQUBIT-1')], -0.1830127018922193j), Op('Z Z Y', [0, ((0, 0), 'TCCQUBIT-0'), ((0, 0), 'TCCQUBIT-1')], 0.6830127018922193j), Op('Z Y', [0, ((0, 0), 'TCCQUBIT-0')], 0.3535533905932738j), Op('Z Y Z', [0, ((0, 0), 'TCCQUBIT-0'), ((0, 0), 'TCCQUBIT-1')], -0.3535533905932738j), [Op('X Y', [1, 2], 0.5j), Op('Y X', [1, 2], -0.5j)], Op('Y', [((1, 0), 'TCCQUBIT-1')], 0.1830127018922193j), Op('Z Y', [((1, 0), 'TCCQUBIT-0'), ((1, 0), 'TCCQUBIT-1')], -0.6830127018922193j), Op('Y', [((1, 0), 'TCCQUBIT-0')], -0.3535533905932738j), Op('Y Z', [((1, 0), 'TCCQUBIT-0'), ((1, 0), 'TCCQUBIT-1')], 0.3535533905932738j), Op('Z Y', [1, ((1, 0), 'TCCQUBIT-1')], -0.1830127018922193j), Op('Z Z Y', [1, ((1, 0), 'TCCQUBIT-0'), ((1, 0), 'TCCQUBIT-1')], 0.6830127018922193j), Op('Z Y', [1, ((1, 0), 'TCCQUBIT-0')], 0.3535533905932738j), Op('Z Y Z', [1, ((1, 0), 'TCCQUBIT-0'), ((1, 0), 'TCCQUBIT-1')], -0.3535533905932738j), [Op('X Y', [0, 2], -0.5j), Op('Y X', [0, 2], 0.5j)], Op('Y', [((2, 0), 'TCCQUBIT-1')], 0.1830127018922193j), Op('Z Y', [((2, 0), 'TCCQUBIT-0'), ((2, 0), 'TCCQUBIT-1')], -0.6830127018922193j), Op('Y', [((2, 0), 'TCCQUBIT-0')], -0.3535533905932738j), Op('Y Z', [((2, 0), 'TCCQUBIT-0'), ((2, 0), 'TCCQUBIT-1')], 0.3535533905932738j), Op('Z Y', [2, ((2, 0), 'TCCQUBIT-1')], -0.1830127018922193j), Op('Z Z Y', [2, ((2, 0), 'TCCQUBIT-0'), ((2, 0), 'TCCQUBIT-1')], 0.6830127018922193j), Op('Z Y', [2, ((2, 0), 'TCCQUBIT-0')], 0.3535533905932738j), Op('Z Y Z', [2, ((2, 0), 'TCCQUBIT-0'), ((2, 0), 'TCCQUBIT-1')], -0.3535533905932738j)] \n", "spin_basis: \n", " [BasisHalfSpin(dof: 0, nbas: 2), BasisHalfSpin(dof: ((0, 0), 'TCCQUBIT-0'), nbas: 2), BasisHalfSpin(dof: ((0, 0), 'TCCQUBIT-1'), nbas: 2), BasisHalfSpin(dof: 1, nbas: 2), BasisHalfSpin(dof: ((1, 0), 'TCCQUBIT-0'), nbas: 2), BasisHalfSpin(dof: ((1, 0), 'TCCQUBIT-1'), nbas: 2), BasisHalfSpin(dof: 2, nbas: 2), BasisHalfSpin(dof: ((2, 0), 'TCCQUBIT-0'), nbas: 2), BasisHalfSpin(dof: ((2, 0), 'TCCQUBIT-1'), nbas: 2)] \n", - "param_ids: \n", - " [1, -1, 0, 2, 3, 4, 5, 6, 7, 8, 9, -9, 10, 11, 12, 13, 14, 15, 16, 17, 18, -18, 19, 20, 21, 22, 23, 24, 25, 26] \n", "ansatz: \n", - " .ansatz at 0x7f2fd4ed29e0>\n" + " .ansatz at 0x7fe2ab768670>\n" ] } ], @@ -180,8 +176,7 @@ " ansatz_terms = []\n", " for i in range(nsite):\n", " j = (i + 1) % nsite\n", - " ansatz_terms.append(Op(r\"a^\\dagger a\", [i, j], v))\n", - " ansatz_terms.append(Op(r\"a^\\dagger a\", [j, i], -v))\n", + " ansatz_terms.append(Op(r\"a^\\dagger a\", [i, j], v) - Op(r\"a^\\dagger a\", [j, i], v))\n", " ansatz_terms.append(Op(r\"a^\\dagger a b^\\dagger-b\", [i, i, (i, 0)], g * omega))\n", "\n", " basis = []\n", @@ -189,24 +184,24 @@ " basis.append(BasisSimpleElectron(i))\n", " basis.append(BasisSHO((i, 0), omega, nbas_v))\n", "\n", - " ansatz_terms, _ = qubit_encode_op(ansatz_terms, basis, boson_encoding=\"gray\")\n", + " ansatz_terms, _ = qubit_encode_op_grouped(ansatz_terms, basis, boson_encoding=\"gray\")\n", + "\n", + " # More flexible ansatz by decoupling the parameters in the e-ph coupling term\n", + " ansatz_terms_extended = []\n", + " for i in range(nsite):\n", + " ansatz_terms_extended.extend([ansatz_terms[2 * i]] + ansatz_terms[2 * i + 1])\n", " spin_basis = qubit_encode_basis(basis, boson_encoding=\"gray\")\n", - " # this is currently hard-coded for `n_qubit_per_mode==2`\n", - " # if the values of param_ids are opposite to each other, the values of the parameters are forced to be opposite in the optimization.\n", - " param_ids = [1, -1, 0, 2, 3, 4, 5, 6, 7, 8] + [9, -9] + list(range(10, 18)) + [18, -18] + list(range(19, 27))\n", - " return ansatz_terms, spin_basis, param_ids\n", + " return ansatz_terms_extended, spin_basis\n", "\n", "\n", - "ansatz_terms, spin_basis, param_ids = get_vha_terms()\n", - "ansatz = get_ansatz(ansatz_terms, spin_basis, n_layers, c, param_ids)\n", + "ansatz_terms, spin_basis = get_vha_terms()\n", + "ansatz = get_ansatz(ansatz_terms, spin_basis, n_layers, c)\n", "\n", "print(\n", " \"ansatz_terms: \\n\",\n", " ansatz_terms,\n", " \"\\nspin_basis: \\n\",\n", " spin_basis,\n", - " \"\\nparam_ids: \\n\",\n", - " param_ids,\n", " \"\\nansatz: \\n\",\n", " ansatz,\n", ")" @@ -366,7 +361,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "9da5b86b", "metadata": {}, "outputs": [ @@ -375,189 +370,189 @@ "output_type": "stream", "text": [ "g: 1.5, nbas: 4\n", - "Iter 0 VQE energy: -3.1462862688238387\n", - "Iter 1 VQE energy: -3.1467101393155392\n", - "Iter 2 VQE energy: -3.1516072207104755\n", - "Iter 3 VQE energy: -3.146809472707097\n", - "Iter 4 VQE energy: -3.1436199703762058\n", - "Iter 5 VQE energy: -3.1436211792549265\n", - "Iter 6 VQE energy: -3.1436161320531255\n", - "Iter 7 VQE energy: -3.1436163145946456\n", - "Iter 8 VQE energy: -3.143610688816215\n", - "Iter 9 VQE energy: -3.143615904093609\n", + "Iter 0 VQE energy: -3.1508416128890313\n", + "Iter 1 VQE energy: -3.1507858838816376\n", + "Iter 2 VQE energy: -3.1508608481716656\n", + "Iter 3 VQE energy: -3.150867173130474\n", + "Iter 4 VQE energy: -3.1507760219657097\n", + "Iter 5 VQE energy: -3.1508712542841204\n", + "Iter 6 VQE energy: -3.1508619663363584\n", + "Iter 7 VQE energy: -3.150862097675895\n", + "Iter 8 VQE energy: -3.1508558599533214\n", + "Iter 9 VQE energy: -3.1508452460745824\n", "g: 1.5, nbas: 8\n", - "Iter 0 VQE energy: -3.143618182488605\n", - "Iter 1 VQE energy: -3.200840457440427\n", - "Iter 2 VQE energy: -3.2122982581916806\n", - "Iter 3 VQE energy: -3.2148415941913107\n", - "Iter 4 VQE energy: -3.214454540682066\n", - "Iter 5 VQE energy: -3.214612010154128\n", - "Iter 6 VQE energy: -3.2147110746262615\n", - "Iter 7 VQE energy: -3.2147665497225395\n", - "Iter 8 VQE energy: -3.2148131940534586\n", - "Iter 9 VQE energy: -3.2154252365889784\n", + "Iter 0 VQE energy: -3.150839580645302\n", + "Iter 1 VQE energy: -3.2066949093848724\n", + "Iter 2 VQE energy: -3.212971955811858\n", + "Iter 3 VQE energy: -3.21359027706454\n", + "Iter 4 VQE energy: -3.213786701570586\n", + "Iter 5 VQE energy: -3.213875852088408\n", + "Iter 6 VQE energy: -3.2139390416159745\n", + "Iter 7 VQE energy: -3.213949104011919\n", + "Iter 8 VQE energy: -3.213987256845763\n", + "Iter 9 VQE energy: -3.2152956996689386\n", "g: 1.5, nbas: 12\n", - "Iter 0 VQE energy: -3.1514261568965116\n", - "Iter 1 VQE energy: -3.207712921399021\n", - "Iter 2 VQE energy: -3.2143507766993564\n", - "Iter 3 VQE energy: -3.2151165867343625\n", - "Iter 4 VQE energy: -3.215551620056812\n", - "Iter 5 VQE energy: -3.21568849222177\n", - "Iter 6 VQE energy: -3.215871719331443\n", - "Iter 7 VQE energy: -3.215941510624362\n", - "Iter 8 VQE energy: -3.2160628060732046\n", - "Iter 9 VQE energy: -3.216149074896171\n", + "Iter 0 VQE energy: -3.1506086065941177\n", + "Iter 1 VQE energy: -3.207291050935305\n", + "Iter 2 VQE energy: -3.2135257229321295\n", + "Iter 3 VQE energy: -3.2141699728510145\n", + "Iter 4 VQE energy: -3.2143365747584576\n", + "Iter 5 VQE energy: -3.214441211557893\n", + "Iter 6 VQE energy: -3.2149215057907408\n", + "Iter 7 VQE energy: -3.215021952188251\n", + "Iter 8 VQE energy: -3.2150830781181865\n", + "Iter 9 VQE energy: -3.2151588242226294\n", "g: 1.5, nbas: 16\n", - "Iter 0 VQE energy: -3.1514406055444124\n", - "Iter 1 VQE energy: -3.2076420281600306\n", - "Iter 2 VQE energy: -3.2142584040499904\n", - "Iter 3 VQE energy: -3.215027472815238\n", - "Iter 4 VQE energy: -3.215298468441994\n", - "Iter 5 VQE energy: -3.215473370191188\n", - "Iter 6 VQE energy: -3.215603547226202\n", - "Iter 7 VQE energy: -3.2157277687243084\n", - "Iter 8 VQE energy: -3.21585866940053\n", - "Iter 9 VQE energy: -3.215945718302776\n", + "Iter 0 VQE energy: -3.151275240878887\n", + "Iter 1 VQE energy: -3.2070935536922067\n", + "Iter 2 VQE energy: -3.2136287739682468\n", + "Iter 3 VQE energy: -3.2143020839991756\n", + "Iter 4 VQE energy: -3.2144651007997775\n", + "Iter 5 VQE energy: -3.2145842050117097\n", + "Iter 6 VQE energy: -3.2146841025772996\n", + "Iter 7 VQE energy: -3.21479318479846\n", + "Iter 8 VQE energy: -3.2148943236005287\n", + "Iter 9 VQE energy: -3.2149540916947945\n", "g: 1.5, nbas: 20\n", - "Iter 0 VQE energy: -3.1514390786099793\n", - "Iter 1 VQE energy: -3.207490813088342\n", - "Iter 2 VQE energy: -3.214102161196929\n", - "Iter 3 VQE energy: -3.2148182787029125\n", - "Iter 4 VQE energy: -3.215041112156586\n", - "Iter 5 VQE energy: -3.2151813495719064\n", - "Iter 6 VQE energy: -3.2153433350190888\n", - "Iter 7 VQE energy: -3.215488882659097\n", - "Iter 8 VQE energy: -3.2156246556276216\n", - "Iter 9 VQE energy: -3.2157174737499026\n", + "Iter 0 VQE energy: -3.151289122850235\n", + "Iter 1 VQE energy: -3.207014859265433\n", + "Iter 2 VQE energy: -3.2132344731718514\n", + "Iter 3 VQE energy: -3.2141907479392553\n", + "Iter 4 VQE energy: -3.2143546694580207\n", + "Iter 5 VQE energy: -3.214450278123804\n", + "Iter 6 VQE energy: -3.2145674514358706\n", + "Iter 7 VQE energy: -3.2146390373914153\n", + "Iter 8 VQE energy: -3.2150470541341685\n", + "Iter 9 VQE energy: -3.215173127034174\n", "g: 1.5, nbas: 24\n", - "Iter 0 VQE energy: -3.1514387774077157\n", - "Iter 1 VQE energy: -3.207367390115564\n", - "Iter 2 VQE energy: -3.2139409419868894\n", - "Iter 3 VQE energy: -3.214681092894311\n", - "Iter 4 VQE energy: -3.2148647347163752\n", - "Iter 5 VQE energy: -3.2149976397508198\n", - "Iter 6 VQE energy: -3.2150898148896068\n", - "Iter 7 VQE energy: -3.215209498240965\n", - "Iter 8 VQE energy: -3.215350330348768\n", - "Iter 9 VQE energy: -3.215489480343017\n", + "Iter 0 VQE energy: -3.150827151041051\n", + "Iter 1 VQE energy: -3.207129572687281\n", + "Iter 2 VQE energy: -3.2137825485777864\n", + "Iter 3 VQE energy: -3.2144545350583797\n", + "Iter 4 VQE energy: -3.214629617805067\n", + "Iter 5 VQE energy: -3.214737029069743\n", + "Iter 6 VQE energy: -3.214830643223987\n", + "Iter 7 VQE energy: -3.2149177270776037\n", + "Iter 8 VQE energy: -3.215007843231478\n", + "Iter 9 VQE energy: -3.2150878222798105\n", "g: 1.5, nbas: 28\n", - "Iter 0 VQE energy: -3.151439525393469\n", - "Iter 1 VQE energy: -3.2073726435058725\n", - "Iter 2 VQE energy: -3.21394347501351\n", - "Iter 3 VQE energy: -3.2146357208139835\n", - "Iter 4 VQE energy: -3.2147953021340396\n", - "Iter 5 VQE energy: -3.2149183613661005\n", - "Iter 6 VQE energy: -3.2150120210391324\n", - "Iter 7 VQE energy: -3.2151326321686358\n", - "Iter 8 VQE energy: -3.2152609684807225\n", - "Iter 9 VQE energy: -3.2153772130446274\n", + "Iter 0 VQE energy: -3.1513226796412654\n", + "Iter 1 VQE energy: -3.206975159802363\n", + "Iter 2 VQE energy: -3.21360025168811\n", + "Iter 3 VQE energy: -3.2143725838746917\n", + "Iter 4 VQE energy: -3.2145131528688684\n", + "Iter 5 VQE energy: -3.214604325896769\n", + "Iter 6 VQE energy: -3.2146927550103013\n", + "Iter 7 VQE energy: -3.214787435576051\n", + "Iter 8 VQE energy: -3.2148807292126254\n", + "Iter 9 VQE energy: -3.214950439086758\n", "g: 1.5, nbas: 32\n", - "Iter 0 VQE energy: -3.1514407536942515\n", - "Iter 1 VQE energy: -3.2073747584311443\n", - "Iter 2 VQE energy: -3.213913960989289\n", - "Iter 3 VQE energy: -3.214575999427622\n", - "Iter 4 VQE energy: -3.2147908760265476\n", - "Iter 5 VQE energy: -3.214908337484859\n", - "Iter 6 VQE energy: -3.214995903540079\n", - "Iter 7 VQE energy: -3.2151048002575178\n", - "Iter 8 VQE energy: -3.2151780903906246\n", - "Iter 9 VQE energy: -3.215267190685132\n", - "[array(-3.1436159), array(-3.21542524), array(-3.21614907), array(-3.21594572), array(-3.21571747), array(-3.21548948), array(-3.21537721), array(-3.21526719)]\n", + "Iter 0 VQE energy: -3.1508096031820507\n", + "Iter 1 VQE energy: -3.206930098390965\n", + "Iter 2 VQE energy: -3.213589086530922\n", + "Iter 3 VQE energy: -3.214254153558814\n", + "Iter 4 VQE energy: -3.2143964407024552\n", + "Iter 5 VQE energy: -3.2144846301084025\n", + "Iter 6 VQE energy: -3.2145623430858894\n", + "Iter 7 VQE energy: -3.214620531205786\n", + "Iter 8 VQE energy: -3.2147225823351513\n", + "Iter 9 VQE energy: -3.2147844815701507\n", + "[-3.1508452460745824, -3.2152956996689386, -3.2151588242226294, -3.2149540916947945, -3.215173127034174, -3.2150878222798105, -3.214950439086758, -3.2147844815701507]\n", "g: 3, nbas: 4\n", - "Iter 0 VQE energy: -5.970388609022889\n", - "Iter 1 VQE energy: -5.970388750660544\n", - "Iter 2 VQE energy: -5.970380747881972\n", - "Iter 3 VQE energy: -5.9703823363984405\n", - "Iter 4 VQE energy: -5.970361506210726\n", - "Iter 5 VQE energy: -5.970387322685639\n", - "Iter 6 VQE energy: -5.970395203902614\n", - "Iter 7 VQE energy: -5.970391647335198\n", - "Iter 8 VQE energy: -5.970399166505385\n", - "Iter 9 VQE energy: -5.970381692433662\n", + "Iter 0 VQE energy: -5.970095373880274\n", + "Iter 1 VQE energy: -5.97011140752757\n", + "Iter 2 VQE energy: -5.970112221832909\n", + "Iter 3 VQE energy: -5.970097206562884\n", + "Iter 4 VQE energy: -5.970097522226955\n", + "Iter 5 VQE energy: -5.970084918795675\n", + "Iter 6 VQE energy: -5.97009612094958\n", + "Iter 7 VQE energy: -5.970090087724759\n", + "Iter 8 VQE energy: -5.970084917787736\n", + "Iter 9 VQE energy: -5.970092472244904\n", "g: 3, nbas: 8\n", - "Iter 0 VQE energy: -5.97038378078057\n", - "Iter 1 VQE energy: -7.5564103165274705\n", - "Iter 2 VQE energy: -7.867598000881585\n", - "Iter 3 VQE energy: -7.886883542215796\n", - "Iter 4 VQE energy: -7.8885422575017525\n", - "Iter 5 VQE energy: -7.88860270448971\n", - "Iter 6 VQE energy: -7.888976697629529\n", - "Iter 7 VQE energy: -7.889032282397925\n", - "Iter 8 VQE energy: -7.87508588628647\n", - "Iter 9 VQE energy: -7.88070265416792\n", + "Iter 0 VQE energy: -5.970078968351394\n", + "Iter 1 VQE energy: -7.563619315159238\n", + "Iter 2 VQE energy: -7.86542656566074\n", + "Iter 3 VQE energy: -7.88623299324116\n", + "Iter 4 VQE energy: -7.8756160081347755\n", + "Iter 5 VQE energy: -7.87669855576027\n", + "Iter 6 VQE energy: -7.8770414783544185\n", + "Iter 7 VQE energy: -7.877214342205345\n", + "Iter 8 VQE energy: -7.877399262407691\n", + "Iter 9 VQE energy: -7.877447749293062\n", "g: 3, nbas: 12\n", - "Iter 0 VQE energy: -5.97067566818566\n", - "Iter 1 VQE energy: -8.243806185428152\n", - "Iter 2 VQE energy: -8.734803721364637\n", - "Iter 3 VQE energy: -8.761741304437681\n", - "Iter 4 VQE energy: -8.763332322992516\n", - "Iter 5 VQE energy: -8.763771458365108\n", - "Iter 6 VQE energy: -8.764185047602272\n", - "Iter 7 VQE energy: -8.764384932213805\n", - "Iter 8 VQE energy: -8.76466850977698\n", - "Iter 9 VQE energy: -8.764911481717341\n", + "Iter 0 VQE energy: -5.970404607808003\n", + "Iter 1 VQE energy: -8.210512264715195\n", + "Iter 2 VQE energy: -8.734258414528332\n", + "Iter 3 VQE energy: -8.761817418245505\n", + "Iter 4 VQE energy: -8.764385439689185\n", + "Iter 5 VQE energy: -8.765150683117824\n", + "Iter 6 VQE energy: -8.765371623528338\n", + "Iter 7 VQE energy: -8.765594133409062\n", + "Iter 8 VQE energy: -8.765731045348685\n", + "Iter 9 VQE energy: -8.765868762122404\n", "g: 3, nbas: 16\n", - "Iter 0 VQE energy: -5.96862038743091\n", - "Iter 1 VQE energy: -8.429794930919833\n", - "Iter 2 VQE energy: -9.026873692202507\n", - "Iter 3 VQE energy: -9.056442107809515\n", - "Iter 4 VQE energy: -9.05694061960338\n", - "Iter 5 VQE energy: -9.057045669005818\n", - "Iter 6 VQE energy: -9.057238086937822\n", - "Iter 7 VQE energy: -9.057282106387905\n", - "Iter 8 VQE energy: -9.057566284361702\n", - "Iter 9 VQE energy: -9.057828042375913\n", + "Iter 0 VQE energy: -5.968823174685871\n", + "Iter 1 VQE energy: -8.433088894554963\n", + "Iter 2 VQE energy: -9.027450708952731\n", + "Iter 3 VQE energy: -9.056048877152831\n", + "Iter 4 VQE energy: -9.057310249886191\n", + "Iter 5 VQE energy: -9.057405427978866\n", + "Iter 6 VQE energy: -9.057711262240172\n", + "Iter 7 VQE energy: -9.057977529966319\n", + "Iter 8 VQE energy: -9.058229991701616\n", + "Iter 9 VQE energy: -9.058429201135686\n", "g: 3, nbas: 20\n", - "Iter 0 VQE energy: -5.970618486961766\n", - "Iter 1 VQE energy: -8.46027786865908\n", - "Iter 2 VQE energy: -9.083147656265663\n", - "Iter 3 VQE energy: -9.114099808352503\n", - "Iter 4 VQE energy: -9.11560775880261\n", - "Iter 5 VQE energy: -9.115877265080734\n", - "Iter 6 VQE energy: -9.116097672280478\n", - "Iter 7 VQE energy: -9.116229576435904\n", - "Iter 8 VQE energy: -9.116393057481334\n", - "Iter 9 VQE energy: -9.116547264265742\n", + "Iter 0 VQE energy: -5.948528657871584\n", + "Iter 1 VQE energy: -8.368829839591752\n", + "Iter 2 VQE energy: -9.083438191408403\n", + "Iter 3 VQE energy: -9.11436452030949\n", + "Iter 4 VQE energy: -9.115669532398497\n", + "Iter 5 VQE energy: -9.115868599561257\n", + "Iter 6 VQE energy: -9.116043601598792\n", + "Iter 7 VQE energy: -9.116167929411532\n", + "Iter 8 VQE energy: -9.11643438333657\n", + "Iter 9 VQE energy: -9.116603277604245\n", "g: 3, nbas: 24\n", - "Iter 0 VQE energy: -5.970625270862546\n", - "Iter 1 VQE energy: -8.45711233270321\n", - "Iter 2 VQE energy: -9.088394950174024\n", - "Iter 3 VQE energy: -9.119585611496353\n", - "Iter 4 VQE energy: -9.120622157156225\n", - "Iter 5 VQE energy: -9.12076874586676\n", - "Iter 6 VQE energy: -9.120868946965105\n", - "Iter 7 VQE energy: -9.120961208842665\n", - "Iter 8 VQE energy: -9.121266704999321\n", - "Iter 9 VQE energy: -9.121400092721187\n", + "Iter 0 VQE energy: -5.947042292691847\n", + "Iter 1 VQE energy: -8.365954455675366\n", + "Iter 2 VQE energy: -9.03656892084732\n", + "Iter 3 VQE energy: -9.11649389980292\n", + "Iter 4 VQE energy: -9.12039969438638\n", + "Iter 5 VQE energy: -9.120853070374695\n", + "Iter 6 VQE energy: -9.121044950929027\n", + "Iter 7 VQE energy: -9.121198735794241\n", + "Iter 8 VQE energy: -9.121394623009978\n", + "Iter 9 VQE energy: -9.12156465701712\n", "g: 3, nbas: 28\n", - "Iter 0 VQE energy: -5.970428599007128\n", - "Iter 1 VQE energy: -8.457873653767907\n", - "Iter 2 VQE energy: -9.080983847442083\n", - "Iter 3 VQE energy: -9.11887015866691\n", - "Iter 4 VQE energy: -9.120581625216305\n", - "Iter 5 VQE energy: -9.120780165844552\n", - "Iter 6 VQE energy: -9.120861448711434\n", - "Iter 7 VQE energy: -9.120944883939789\n", - "Iter 8 VQE energy: -9.121064294222425\n", - "Iter 9 VQE energy: -9.121158073032065\n", + "Iter 0 VQE energy: -5.94852290058614\n", + "Iter 1 VQE energy: -8.373669662264637\n", + "Iter 2 VQE energy: -9.077430296028782\n", + "Iter 3 VQE energy: -9.118353243461202\n", + "Iter 4 VQE energy: -9.120646592845254\n", + "Iter 5 VQE energy: -9.121017986552905\n", + "Iter 6 VQE energy: -9.121200880818158\n", + "Iter 7 VQE energy: -9.121406754497627\n", + "Iter 8 VQE energy: -9.12160334523664\n", + "Iter 9 VQE energy: -9.121785885087258\n", "g: 3, nbas: 32\n", - "Iter 0 VQE energy: -5.969871735326939\n", - "Iter 1 VQE energy: -8.45468700588645\n", - "Iter 2 VQE energy: -9.081070798150298\n", - "Iter 3 VQE energy: -9.11871782591465\n", - "Iter 4 VQE energy: -9.120482174048545\n", - "Iter 5 VQE energy: -9.1206758213174\n", - "Iter 6 VQE energy: -9.12076495864178\n", - "Iter 7 VQE energy: -9.12087305152589\n", - "Iter 8 VQE energy: -9.120974560170358\n", - "Iter 9 VQE energy: -9.121128971234404\n", - "[array(-3.1436159), array(-3.21542524), array(-3.21614907), array(-3.21594572), array(-3.21571747), array(-3.21548948), array(-3.21537721), array(-3.21526719), array(-5.97038169), array(-7.88070265), array(-8.76491148), array(-9.05782804), array(-9.11654726), array(-9.12140009), array(-9.12115807), array(-9.12112897)]\n" + "Iter 0 VQE energy: -5.955856129341857\n", + "Iter 1 VQE energy: -8.411614122038424\n", + "Iter 2 VQE energy: -9.013222667482161\n", + "Iter 3 VQE energy: -9.115359115707335\n", + "Iter 4 VQE energy: -9.120333885780456\n", + "Iter 5 VQE energy: -9.12077712341391\n", + "Iter 6 VQE energy: -9.120890286646729\n", + "Iter 7 VQE energy: -9.120977919424327\n", + "Iter 8 VQE energy: -9.121046355348854\n", + "Iter 9 VQE energy: -9.121145181818363\n", + "[-3.1508452460745824, -3.2152956996689386, -3.2151588242226294, -3.2149540916947945, -3.215173127034174, -3.2150878222798105, -3.214950439086758, -3.2147844815701507, -5.970092472244904, -7.877447749293062, -8.765868762122404, -9.058429201135686, -9.116603277604245, -9.12156465701712, -9.121785885087258, -9.121145181818363]\n" ] } ], "source": [ "vqe_e = []\n", - "thetas = np.zeros((max(param_ids) + 1) * n_layers)\n", + "thetas = np.zeros(len(ansatz_terms) * n_layers)\n", "\n", "for g in [1.5, 3]:\n", " for nbas in [4, 8, 12, 16, 20, 24, 28, 32]:\n", @@ -595,7 +590,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "a1f91b3b", "metadata": {}, "outputs": [ @@ -605,13 +600,13 @@ "Text(0, 0.5, 'Energy')" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -634,9 +629,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "tcc-pip", "language": "python", - "name": "python3" + "name": "tcc-pip" }, "language_info": { "codemirror_mode": { @@ -648,9 +643,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.13" + "version": "3.9.20" } }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/tests/static/test_static.py b/tests/static/test_static.py index cc0f38e..a080530 100644 --- a/tests/static/test_static.py +++ b/tests/static/test_static.py @@ -124,12 +124,12 @@ def test_mf_input(): hf = RHF(m) hf.kernel() dm, _, stable, _ = hf.stability(return_status=True) - if not stable: + while not stable: print("Instability detected in RHF") hf.kernel(dm) dm, _, stable, _ = hf.stability(return_status=True) - if not stable: - print("RHF is unstable") + if stable: + break ucc = UCCSD(hf, active_space=(4, 4)) e = ucc.kernel() np.testing.assert_allclose(ucc.e_hf, -153.603405, atol=1e-4)