Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/tencent-quantum-lab/tensorcircuit

Tensor network based quantum software framework for the NISQ era
https://github.com/tencent-quantum-lab/tensorcircuit

automatic-differentiation jax machine-learning matrix-product-states neural-network nisq open-quantum-systems pytorch quantum quantum-algorithms quantum-circuit quantum-computing quantum-dynamics quantum-error-mitigation quantum-machine-learning quantum-noise quantum-simulation tensor-network tensorflow variational-quantum-algorithms

Last synced: 3 months ago
JSON representation

Tensor network based quantum software framework for the NISQ era

Host: GitHub
URL: https://github.com/tencent-quantum-lab/tensorcircuit
Owner: tencent-quantum-lab
License: apache-2.0
Created: 2022-05-16T02:31:33.000Z (over 2 years ago)
Default Branch: master
Last Pushed: 2024-04-10T06:24:33.000Z (7 months ago)
Last Synced: 2024-05-10T15:02:59.482Z (6 months ago)
Topics: automatic-differentiation, jax, machine-learning, matrix-product-states, neural-network, nisq, open-quantum-systems, pytorch, quantum, quantum-algorithms, quantum-circuit, quantum-computing, quantum-dynamics, quantum-error-mitigation, quantum-machine-learning, quantum-noise, quantum-simulation, tensor-network, tensorflow, variational-quantum-algorithms
Language: Python
Homepage: https://tensorcircuit.readthedocs.io
Size: 13 MB
Stars: 243
Watchers: 7
Forks: 70
Open Issues: 20
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
- Citation: CITATION.cff

Awesome Lists containing this project

awesome-quantum-software - TensorCircuit - Tensor network based quantum software framework for the NISQ era. (Quantum full-stack libraries)

README

        


  

    

  





  

  

    

  

  

  

    

  

  

  

    

  

  

  

    

  

  

  

    

  



 English |  简体中文 


TensorCircuit is the next generation of quantum software framework with support for automatic differentiation, just-in-time compiling, hardware acceleration, and vectorized parallelism.

TensorCircuit is built on top of modern machine learning frameworks: Jax, TensorFlow, and PyTorch. It is specifically suitable for highly efficient simulations of quantum-classical hybrid paradigm and variational quantum algorithms in ideal, noisy and approximate cases. It also supports real quantum hardware access and provides CPU/GPU/QPU hybrid deployment solutions since v0.9.

## Getting Started

Please begin with [Quick Start](/docs/source/quickstart.rst) in the [full documentation](https://tensorcircuit.readthedocs.io/).

For more information on software usage, sota algorithm implementation and engineer paradigm demonstration, please refer to 70+ [example scripts](/examples) and 30+ [tutorial notebooks](https://tensorcircuit.readthedocs.io/en/latest/#tutorials). API docstrings and test cases in [tests](/tests) are also informative.

The following are some minimal demos.

- Circuit manipulation:

```python

import tensorcircuit as tc

c = tc.Circuit(2)

c.H(0)

c.CNOT(0,1)

c.rx(1, theta=0.2)

print(c.wavefunction())

print(c.expectation_ps(z=[0, 1]))

print(c.sample(allow_state=True, batch=1024, format="count_dict_bin"))

```

- Runtime behavior customization:

```python

tc.set_backend("tensorflow")

tc.set_dtype("complex128")

tc.set_contractor("greedy")

```

- Automatic differentiations with jit:

```python

def forward(theta):

    c = tc.Circuit(2)

    c.R(0, theta=theta, alpha=0.5, phi=0.8)

    return tc.backend.real(c.expectation((tc.gates.z(), [0])))

g = tc.backend.grad(forward)

g = tc.backend.jit(g)

theta = tc.array_to_tensor(1.0)

print(g(theta))

```

   More highlight features for TensorCircuit (click for details) 

- Sparse Hamiltonian generation and expectation evaluation:

```python

n = 6

pauli_structures = []

weights = []

for i in range(n):

    pauli_structures.append(tc.quantum.xyz2ps({"z": [i, (i + 1) % n]}, n=n))

    weights.append(1.0)

for i in range(n):

    pauli_structures.append(tc.quantum.xyz2ps({"x": [i]}, n=n))

    weights.append(-1.0)

h = tc.quantum.PauliStringSum2COO(pauli_structures, weights)

print(h)

# BCOO(complex64[64, 64], nse=448)

c = tc.Circuit(n)

c.h(range(n))

energy = tc.templates.measurements.operator_expectation(c, h)

# -6

```

- Large-scale simulation with tensor network engine

```python

# tc.set_contractor("cotengra-30-10")

n=500

c = tc.Circuit(n)

c.h(0)

c.cx(range(n-1), range(1, n))

c.expectation_ps(z=[0, n-1], reuse=False)

```

- Density matrix simulator and quantum info quantities

```python

c = tc.DMCircuit(2)

c.h(0)

c.cx(0, 1)

c.depolarizing(1, px=0.1, py=0.1, pz=0.1)

dm = c.state()

print(tc.quantum.entropy(dm))

print(tc.quantum.entanglement_entropy(dm, [0]))

print(tc.quantum.entanglement_negativity(dm, [0]))

print(tc.quantum.log_negativity(dm, [0]))

```

## Install

The package is written in pure Python and can be obtained via pip as:

```python

pip install tensorcircuit

```

We recommend you install this package with tensorflow also installed as:

```python

pip install tensorcircuit[tensorflow]

```

Other optional dependencies include `[torch]`, `[jax]`, `[qiskit]` and `[cloud]`.

We also have [Docker support](/docker).

## Advantages

- Tensor network simulation engine based

- JIT, AD, vectorized parallelism compatible

- GPU support, quantum device access support, hybrid deployment support

- Efficiency

  - Time: 10 to 10^6+ times acceleration compared to TensorFlow Quantum, Pennylane or Qiskit

  - Space: 600+ qubits 1D VQE workflow (converged energy inaccuracy: < 1%)

- Elegance

  - Flexibility: customized contraction, multiple ML backend/interface choices, multiple dtype precisions, multiple QPU providers

  - API design: quantum for humans, less code, more power

- Batteries included

  

   Tons of amazing features and built in tools for research (click for details) 

  - Support **super large circuit simulation** using tensor network engine.

  - Support **noisy simulation** with both Monte Carlo and density matrix (tensor network powered) modes.

  - Support **approximate simulation** with MPS-TEBD modes.

  - Support **analog/digital hybrid simulation** (time dependent Hamiltonian evolution, **pulse** level simulation) with neural ode modes.

  - Support **Fermion Gaussian state** simulation with expectation, entanglement, measurement, ground state, real and imaginary time evolution.

  - Support **qudits simulation**.

  - Support **parallel** quantum circuit evaluation across **multiple GPUs**.

  - Highly customizable **noise model** with gate error and scalable readout error.

  - Support for **non-unitary** gate and post-selection simulation.

  - Support **real quantum devices access** from different providers.

  - **Scalable readout error mitigation** native to both bitstring and expectation level with automatic qubit mapping consideration.

  - **Advanced quantum error mitigation methods** and pipelines such as ZNE, DD, RC, etc.

  - Support **MPS/MPO** as representations for input states, quantum gates and observables to be measured.

  - Support **vectorized parallelism** on circuit inputs, circuit parameters, circuit structures, circuit measurements and these vectorization can be nested.

  - Gradients can be obtained with both **automatic differenation** and parameter shift (vmap accelerated) modes.

  - **Machine learning interface/layer/model** abstraction in both TensorFlow and PyTorch for both numerical simulation and real QPU experiments.

  - Circuit sampling supports both final state sampling and perfect sampling from tensor networks.

  - Light cone reduction support for local expectation calculation.

  - Highly customizable tensor network contraction path finder with opteinsum interface.

  - Observables are supported in measurement, sparse matrix, dense matrix and MPO format.

  - Super fast weighted sum Pauli string Hamiltonian matrix generation.

  - Reusable common circuit/measurement/problem templates and patterns.

  - Jittable classical shadow infrastructures.

  - SOTA quantum algorithm and model implementations.

  - Support hybrid workflows and pipelines with CPU/GPU/QPU hardware from local/cloud/hpc resources using tf/torch/jax/cupy/numpy frameworks all at the same time.

  

## Contributing

### Status

This project is created and maintained by [Shi-Xin Zhang](https://github.com/refraction-ray) with current core authors [Shi-Xin Zhang](https://github.com/refraction-ray) and [Yu-Qin Chen](https://github.com/yutuer21). We also thank [contributions](https://github.com/tencent-quantum-lab/tensorcircuit/graphs/contributors) from the open source community.

### Citation

If this project helps in your research, please cite our software whitepaper to acknowledge the work put into the development of TensorCircuit.

[TensorCircuit: a Quantum Software Framework for the NISQ Era](https://quantum-journal.org/papers/q-2023-02-02-912/) (published in Quantum)

which is also a good introduction to the software.

Research works citing TensorCircuit can be highlighted in [Research and Applications section](https://github.com/tencent-quantum-lab/tensorcircuit#research-and-applications).

### Guidelines

For contribution guidelines and notes, see [CONTRIBUTING](/CONTRIBUTING.md).

We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues), [PRs](https://github.com/tencent-quantum-lab/tensorcircuit/pulls), and [discussions](https://github.com/tencent-quantum-lab/tensorcircuit/discussions) from everyone, and these are all hosted on GitHub.

### License

TensorCircuit is open source, released under the Apache License, Version 2.0.

### Contributors

  

    

      
_{Shixin Zhang}
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢 💬

      
_{Yuqin Chen}
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢

      
_{Jiezhong Qiu}
💻 💡 🤔 🔬

      
_{Weitang Li}
💻 📖 🤔 🔬 ⚠️ 📢

      
_{Jiace Sun}
💻 📖 💡 🤔 🔬 ⚠️

      
_{Zhouquan Wan}
💻 📖 💡 🤔 🔬 ⚠️ ✅

    

    

      
_{Shuo Liu}
💡 🔬 ✅

      
_{Hao Yu}
💻 📖 🚇 ⚠️ ✅

      
_{Xinghan Yang}
📖 🌍 ✅

      
_JachyMeow
✅ 🌍

      
_{Zhaofeng Ye}
🎨

      
_erertertet
💻 📖 ⚠️

    

    

      
_{Yicong Zheng}
✅

      
_{Zixuan Song}
📖 🌍 💻 ⚠️

      
_{Hao Xie}
📖

      
_{Pramit Singh}
⚠️

      
_{Jonathan Allcock}
📖 🤔 📢

      
_nealchen2003
📖

    

    

      
_隐公观鱼
💻 ⚠️

      
_WiuYuan
💡

      
_{Felix Xu}
✅ 💻 ⚠️

      
_{Hong-Ye Hu}
📖

      
_peilin
✅ 💻 ⚠️ 📖

      
_{Cristian Emiliano Godinez Ramirez}
💻 ⚠️

    

    

      
_ztzhu
💻

      
_Rabqubit
💡

      
_{Kazuki Tsuoka}
💻 ⚠️ 📖 💡

      
_{Gopal Ramesh Dahale}
💡

      
_{Chanandellar Bong}
💡

    

  

## Research and Applications

### DQAS

For the application of Differentiable Quantum Architecture Search, see [applications](/tensorcircuit/applications).

Reference paper: https://arxiv.org/abs/2010.08561 (published in QST).

### VQNHE

For the application of Variational Quantum-Neural Hybrid Eigensolver, see [applications](/tensorcircuit/applications).

Reference paper: https://arxiv.org/abs/2106.05105 (published in PRL) and https://arxiv.org/abs/2112.10380 (published in AQT).

### VQEX-MBL

For the application of VQEX on MBL phase identification, see the [tutorial](/docs/source/tutorials/vqex_mbl.ipynb).

Reference paper: https://arxiv.org/abs/2111.13719 (published in PRB).

### Stark-DTC

For the numerical demosntration of discrete time crystal enabled by Stark many-body localization, see the Floquet simulation [demo](/examples/timeevolution_trotter.py).

Reference paper: https://arxiv.org/abs/2208.02866 (published in PRL).

### RA-Training

For the numerical simulation of variational quantum algorithm training using random gate activation strategy by us, see the [project repo](https://github.com/ls-iastu/RAtraining).

Reference paper: https://arxiv.org/abs/2303.08154 (published in PRR as a Letter).

### TenCirChem

[TenCirChem](https://github.com/tencent-quantum-lab/TenCirChem) is an efficient and versatile quantum computation package for molecular properties. TenCirChem is based on TensorCircuit and is optimized for chemistry applications.

Reference paper: https://arxiv.org/abs/2303.10825 (published in JCTC).

### EMQAOA-DARBO

For the numerical simulation and hardware experiments with error mitigation on QAOA, see the [project repo](https://github.com/sherrylixuecheng/EMQAOA-DARBO).

Reference paper: https://arxiv.org/abs/2303.14877 (published in Communications Physics).

### NN-VQA

For the setup and simulation code of neural network encoded variational quantum eigensolver, see the [demo](/docs/source/tutorials/nnvqe.ipynb).

Reference paper: https://arxiv.org/abs/2308.01068 (published in PRApplied).

### More works

 

   More research works and code projects using TensorCircuit (click for details) 

- Neural Predictor based Quantum Architecture Search: https://arxiv.org/abs/2103.06524 (published in Machine Learning: Science and Technology).

- Quantum imaginary-time control for accelerating the ground-state preparation: https://arxiv.org/abs/2112.11782 (published in PRR).

- Efficient Quantum Simulation of Electron-Phonon Systems by Variational Basis State Encoder: https://arxiv.org/abs/2301.01442 (published in PRR).

- Variational Quantum Simulations of Finite-Temperature Dynamical Properties via Thermofield Dynamics: https://arxiv.org/abs/2206.05571.

- Understanding quantum machine learning also requires rethinking generalization: https://arxiv.org/abs/2306.13461 (published in Nature Communications).

- Decentralized Quantum Federated Learning for Metaverse: Analysis, Design and Implementation: https://arxiv.org/abs/2306.11297. Code: https://github.com/s222416822/BQFL.

- Non-IID quantum federated learning with one-shot communication complexity: https://arxiv.org/abs/2209.00768 (published in Quantum Machine Intelligence). Code: https://github.com/JasonZHM/quantum-fed-infer.

- Quantum generative adversarial imitation learning: https://doi.org/10.1088/1367-2630/acc605 (published in New Journal of Physics).

- GSQAS: Graph Self-supervised Quantum Architecture Search: https://arxiv.org/abs/2303.12381 (published in Physica A: Statistical Mechanics and its Applications).

- Practical advantage of quantum machine learning in ghost imaging: https://www.nature.com/articles/s42005-023-01290-1 (published in Communications Physics).

- Zero and Finite Temperature Quantum Simulations Powered by Quantum Magic: https://arxiv.org/abs/2308.11616.

- Comparison of Quantum Simulators for Variational Quantum Search: A Benchmark Study: https://arxiv.org/abs/2309.05924.

- Statistical analysis of quantum state learning process in quantum neural networks: https://arxiv.org/abs/2309.14980 (published in NeurIPS).

- Generative quantum machine learning via denoising diffusion probabilistic models: https://arxiv.org/abs/2310.05866 (published in PRL).

- Quantum imaginary time evolution and quantum annealing meet topological sector optimization: https://arxiv.org/abs/2310.04291.

- Google Summer of Code 2023 Projects (QML4HEP): https://github.com/ML4SCI/QMLHEP, https://github.com/Gopal-Dahale/qgnn-hep, https://github.com/salcc/QuantumTransformers.

- Absence of barren plateaus in finite local-depth circuits with long-range entanglement: https://arxiv.org/abs/2311.01393 (published in PRL).

- Non-Markovianity benefits quantum dynamics simulation: https://arxiv.org/abs/2311.17622.

  

If you want to highlight your research work or projects here, feel free to add by opening PR.