.github/workflows/ci.yml

@@ -6,7 +6,7 @@ jobs:
     name: test
     strategy:
       matrix:
-        os: [ubuntu-20.04] # macos-latest disabled as one test randomly fails
+        os: [ubuntu-22.04] # macos-latest disabled as one test randomly fails
         python-version: ["3.10"]
       fail-fast: false
     steps:

.github/workflows/nightly_release.yml

@@ -7,7 +7,7 @@ on:
     - cron: "0 12 * * *"
 jobs:
   tests:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     name: test
     strategy:
       fail-fast: false

README.md

@@ -25,19 +25,19 @@
 
 <p align="center"> English | <a href="README_cn.md"> 简体中文 </a></p>
 
-TensorCircuit-NG is an open-source high-performance quantum software framework, supporting for automatic differentiation, just-in-time compiling, hardware acceleration, and vectorized parallelism, providing unified infrastructures and interfaces for quantum programming. It can compose quantum circuits, neural networks and tensor networks seamlessly with high simulation efficiency and flexibility.
+TensorCircuit-NG is the next-generation open-source high-performance quantum software framework, built upon tensornetwork engines, supporting for automatic differentiation, just-in-time compiling, hardware acceleration, and vectorized parallelism, providing unified infrastructures and interfaces for quantum programming. It can compose quantum circuits, neural networks and tensor networks seamlessly with high simulation efficiency and flexibility.
 
 TensorCircuit-NG is built on top of modern machine learning frameworks: Jax, TensorFlow, and PyTorch. It is specifically suitable for large-scale simulations of quantum-classical hybrid paradigm and variational quantum algorithms in ideal, noisy, Clifford, approximate and analog cases. It also supports quantum hardware access and provides CPU/GPU/QPU hybrid deployment solutions.
 
-TensorCircuit-NG is [fully compatible](https://tensorcircuit-ng.readthedocs.io/en/latest/faq.html#what-is-the-relation-between-tensorcircuit-and-tensorcircuit-ng) with TensorCircuit with more new features and bug fixes (support latest `numpy>2` and `qiskit>1`).
+TensorCircuit-NG is the actively maintained official version and a [fully compatible](https://tensorcircuit-ng.readthedocs.io/en/latest/faq.html#what-is-the-relation-between-tensorcircuit-and-tensorcircuit-ng) successor to TensorCircuit with more new features (stabilizer circuit and distributed simulation) and bug fixes (support latest `numpy>2` and `qiskit>1`).
 
 ## Getting Started
 
 Please begin with [Quick Start](/docs/source/quickstart.rst) in the [full documentation](https://tensorcircuit-ng.readthedocs.io/).
 
 For more information on software usage, sota algorithm implementation and engineer paradigm demonstration, please refer to 80+ [example scripts](/examples) and 30+ [tutorial notebooks](https://tensorcircuit-ng.readthedocs.io/en/latest/#tutorials). API docstrings and test cases in [tests](/tests) are also informative.
 
-For beginners, please refer to [quantum computing lectures with TC-NG](https://github.com/sxzgroup/qc_lecture) to learn both quantum computing basis and representative usage of TensorCircuit-NG.
+For beginners, please refer to [quantum computing lectures with TC-NG](https://github.com/sxzgroup/qc_lecture) to learn both quantum computing basics and representative usage of TensorCircuit-NG.
 
 The following are some minimal demos.
 
@@ -157,7 +157,7 @@ We also have [Docker support](/docker).
 
 - JIT, AD, vectorized parallelism compatible
 
-- GPU support, quantum device access support, hybrid deployment support
+- GPU support, QPU access support, hybrid deployment support
 
 - HPC native, distributed simulation enabled, multiple devices/hosts support
 
@@ -322,6 +322,8 @@ TensorCircuit-NG is open source, released under the Apache License, Version 2.0.
 
 ## Research and Applications
 
+TensorCircuit-NG is a powerful framework for driving research and applications in quantum computing. Below are examples of published academic works and open-source projects that utilize TensorCircuit-NG.
+
 ### DQAS
 
 For the application of Differentiable Quantum Architecture Search, see [applications](/tensorcircuit/applications).
@@ -370,12 +372,18 @@ For the setup and simulation code of neural network encoded variational quantum
 
 Reference paper: https://arxiv.org/abs/2308.01068 (published in PRApplied).
 
-### Effective temperature in approximate ansatzes
+### Effective temperature in ansatzes
 
 For the simulation implementation of quantum states based on neural networks, tensor networs and quantum circuits using TensorCircuit-NG, see the [project repo](https://github.com/sxzgroup/et).
 
 Reference paper: https://arxiv.org/abs/2411.18921.
 
+### A Unified Variational Framework for Quantum Excited States
+
+For the simulation code and data for variational optimization of simutaneous excited states, see the [project repo](https://github.com/sxzgroup/quantum_excited_state).
+
+Reference paper: https://arxiv.org/abs/2504.21459.
+
 ### More works
 
 <details>
@@ -419,7 +427,7 @@ Reference paper: https://arxiv.org/abs/2411.18921.
 
 - Non-Markovianity benefits quantum dynamics simulation: https://arxiv.org/abs/2311.17622.
 
-- Variational post-selection for ground states and thermal states simulation: https://arxiv.org/abs/2402.07605 (published in PRB).
+- Variational post-selection for ground states and thermal states simulation: https://arxiv.org/abs/2402.07605 (published in QST).
 
 - Subsystem information capacity in random circuits and Hamiltonian dynamics: https://arxiv.org/abs/2405.05076.
 

examples/vqe2d_gpu.py

@@ -0,0 +1,80 @@
+import time
+import optax
+import tensorcircuit as tc
+
+tc.set_dtype("complex64")
+K = tc.set_backend("jax")
+# jax is more GPU friendly for this task,
+# while tf is more CPU efficient for this task
+tc.set_contractor("cotengra-8192-8192")
+# more trials for better contraction path
+
+n, m, nlayers = 4, 4, 6
+coord = tc.templates.graphs.Grid2DCoord(n, m)
+h = tc.quantum.heisenberg_hamiltonian(
+    coord.lattice_graph(), hzz=0.8, hxx=1.0, hyy=1.0, sparse=True
+)
+
+
+def singlet_init(circuit):  # assert n % 2 == 0
+    nq = circuit._nqubits
+    for i in range(0, nq - 1, 2):
+        j = (i + 1) % nq
+        circuit.X(i)
+        circuit.H(i)
+        circuit.cnot(i, j)
+        circuit.X(j)
+    return circuit
+
+
+def vqe_forward(param):
+    c = tc.Circuit(n * m)
+    c = singlet_init(c)
+    for i in range(nlayers):
+        c = tc.templates.blocks.Grid2D_entangling(
+            c, coord, tc.gates._zz_matrix, param[i, 0]
+        )
+        c = tc.templates.blocks.Grid2D_entangling(
+            c, coord, tc.gates._xx_matrix, param[i, 1]
+        )
+        c = tc.templates.blocks.Grid2D_entangling(
+            c, coord, tc.gates._yy_matrix, param[i, 2]
+        )
+    loss = tc.templates.measurements.operator_expectation(c, h)
+    return loss
+
+
+# vgf = tc.backend.jit(
+#     tc.backend.value_and_grad(vqe_forward),
+# )
+# param = tc.backend.implicit_randn(stddev=0.1, shape=[nlayers, 3, 2 * n * m])
+
+
+# for _ in range(5):
+#     time0 = time.time()
+#     loss, gr = vgf(param)
+#     print(loss)
+#     print(time.time()-time0)
+
+vvgf = K.jit(
+    K.vectorized_value_and_grad(vqe_forward),
+)
+param = tc.backend.implicit_randn(stddev=0.02, shape=[10, nlayers, 3, 2 * n * m])
+
+optimizer = optax.adam(learning_rate=3e-3)
+opt_state = optimizer.init(param)
+
+
+@K.jit
+def train_step(param, opt_state):
+    # always using jitted optax paradigm when running on GPU!
+    loss_val, grads = vvgf(param)
+    updates, opt_state = optimizer.update(grads, opt_state, param)
+    param = optax.apply_updates(param, updates)
+    return param, opt_state, loss_val
+
+
+for _ in range(1000):
+    time0 = time.time()
+    param, opt_state, losses = train_step(param, opt_state)
+    print(K.mean(losses), time.time() - time0)

tensorcircuit/basecircuit.py

@@ -796,8 +796,10 @@ def readouterror_bs(
         """
         # if isinstance(readout_error, tuple):
         #     readout_error = list[readout_error]  # type: ignore
-
-        nqubit = len(readout_error)  # type: ignore
+        try:
+            nqubit = int(readout_error.shape[0])  # type: ignore
+        except AttributeError:
+            nqubit = len(readout_error)  # type: ignore
         readoutlist = []
         for i in range(nqubit):
             readoutlist.append(

tensorcircuit/results/readout_mitigation.py

@@ -723,7 +723,10 @@ def _matvec_solver(  # type: ignore
         cals = self._form_cals(qubits)
         M = M3MatVec(dict(counts), cals, distance)
         L = spla.LinearOperator(
-            (M.num_elems, M.num_elems), matvec=M.matvec, rmatvec=M.rmatvec
+            (M.num_elems, M.num_elems),
+            matvec=M.matvec,
+            rmatvec=M.rmatvec,
+            dtype=np.float64,
         )
         diags = M.get_diagonal()
 

tensorcircuit/translation.py

@@ -45,7 +45,6 @@
 
 
 def get_qiskit_qasm(qc: Any) -> str:
-
     try:
         qasm_str = qc.qasm()  # type: ignore
     except AttributeError:  # qiskit 1.0

tests/test_interfaces.py

@@ -431,7 +431,6 @@ def g(a, b, c):
 
 
 def test_jax_interface_basic(tfb):
-
     def f(params):
         c = tc.Circuit(1)
         c.rx(0, theta=params[0])
@@ -453,7 +452,6 @@ def f(params):
 
 
 def test_jax_interface_multiple_inputs(tfb):
-
     def f(params1, params2):
         c = tc.Circuit(2)
         c.rx(0, theta=params1[0])
@@ -481,7 +479,6 @@ def f(params1, params2):
     reason="might fail when testing with other function",
 )
 def test_jax_interface_jit_dlpack(tfb):
-
     def f(params):
         c = tc.Circuit(2)
         c.rx(range(2), theta=params)
@@ -502,7 +499,6 @@ def f(params):
 
 
 def test_jax_interface_pure_callback(tfb):
-
     def f(params):
         # Use TF operation to test pure_callback
         return tf.square(params)
@@ -531,7 +527,6 @@ def f_jax2(params):
 
 
 def test_jax_interface_multiple_outputs(tfb):
-
     def f(params):
         # Use TF operation to test pure_callback
         return tf.square(params), params

tests/test_results.py

@@ -16,7 +16,6 @@ def test_marginal_count():
 
 
 def test_merge_count():
-
     c1 = {"00": 10, "01": 20, "11": 30}
     c2 = {"00": 5, "10": 15, "11": 25}
     c3 = {"01": 10, "10": 20}