Tangelo v0.4.3 is here

Howdy, Tangelo users !

It's been a few months since the last release and things have been a little quiet on the repository: this was only temporary !

A bit before Christmas last year, Good Chemistry Company was acquired by SandboxAQ, and we're excited to take this project and its community to the next level as part of SandboxAQ. Since the beginning of the year, we already got to participate in QHack, the NYUAD hackathon, the BIG quantum hackathon, the UnitaryHACK, and we’ll be at QCE24 (IEEE quantum week) in September for our tutorial "Exploring Chemistry Workflows for Current and Future Quantum Computers with Tangelo".

SandboxAQ will make a more complete official announcement about Tangelo in the near future, and move the project to SandboxAQ's Github. This should not change anything for our users in practice: we'll try to make sure there are no broken hyperlinks in our documentation and tutorials ;)

We're seeing a lot of interest in Tangelo for applications in materials design and drug discovery: as always, we welcome your feedback, questions, bug reports, feature suggestions, and contributions of any kind to the project. Don't be shy ! This is your chance to steer the developments in a direction that better supports your interests and propels your research.

🎉 A Tangelo user recently got his first publication as first author in a journal: Simulating Vibronic Spectra by Direct Application of Doktorov Formulas on a Superconducting Quantum Simulator. What will you do with Tangelo ? 🍊

Credits

This release was possible thanks to the contributions of @cburdine, @king-p3nguin, @golanor, @anushkrishnav, @alexfleury-sb and @ValentinS4t1qbit, as well as the feedback of researchers from various institutions that suggested features and fixes !

Highlights of this release

New features

• DMET users can now specify a callable (function) to define an active space for fragments. See short example here.
• DMET now works with Hartree-Fock and MP2 solvers. We do not support the UHF mean field yet, but it should be available soon.
• The Rotoselect optimizer is now available and Rotosolver now requires 1 less energy evaluation, thanks to @cburdine.
• Multi-controlled rotations and phase gates (CRX, CRY, CRZ and CPHASE) are now supported when converting a circuit to Qiskit format with tangelo.linq.translate_circuit (@golanor).
• A quantum circuit can now be provided as a reference state in order to create a variational ansatz and the new method Circuit.fix_variational_parameters can cleanly make all gates in a circuit non-variational (@cburdine)

Fixes and updates

• Tangelo was modified to support Qiskit v1.0 and more recent versions of qiskit-ibm-runtime for hardware experiments.
• Tangelo has added support for PySCF v2.5.0+, thanks to @anushkrishnav
• The Circuit.draw method can now properly print variational gates whose parameters are strings (@anushkrishnav)

Tutorials and examples

• A new example notebook was contributed by @alexfleury-sb , intended to accompany his publication on ArXiv: “Non-unitary Coupled Cluster on Gate-based Quantum Computers”.

Deprecated

• The semi-empirical solver MINDO3 from PySCF is no longer supported and was removed from the dependencies.

Misc

• Python 3.8 is no longer supported in our automated tests and was replaced by Python 3.12. We let you refer to the respective installation requirements for dependencies (Psi4, etc) if necessary.
• Our Sphinx documentation is now part of our automated workflow and deployed on Github-pages ! It will thus always be in sync with the main branch from now on. Thanks a lot, @king-p3nguin !

Tangelo v0.4.2 available

Hello, Tangelo users !

Holiday season is in full swing, and our modest present to you is that Tangelo v0.4.2 is now available. We thank authors who cited this project in their recent publications and provided us with feedback to further improve Tangelo. We strive to develop an engine to accelerate research in our field and help researchers leverage the best of what the quantum community has to offer.

Your feedback, bug reports, feature requests and overall contributions are instrumental in this process, and are the cornerstone of successful open-source software. We encourage you to reach out whenever you cannot find the tools you need, face performance issues or come across unexpected errors in your code. Not only it may steer the development of Tangelo in the direction your research needs, but it may also save you significant time and effort that would be spent writing and maintaining your own code otherwise.

In the meantime, we hope you enjoy the changes brought by this new release. Happy holidays !

Credits

This release was possible thanks to the contributions of @JamesB-1qbit @AlexandreF-1qbit @ValentinS4t1qbit and the feedback from Tangelo users. Thank you !

Highlights of this release:

QM/MM notebook

Our previous release included an implementation of Quantum Mechanics / Molecular Mechanics (QM/MM), a computational technique that enables the treatment of a region of a molecular system at a given level of quantum chemistry, while the remainder is modeled with force fields. One of the key and useful applications of this framework is to consider chemical environmental effects, such as explicit solvent molecules, with a negligible computational overhead. It is now illustrated in this tutorial notebook.

iFCI fragment import

In 2022, the incremental Full Configuration Interaction (iFCI) method was massively scaled on QEMIST Cloud to deliver record-breaking results on the simulation of PFAS molecules, known as “the forever chemicals” since they do not generally biodegrade in the environment. This achievement was reported on the AWS HPC blog and Wired, among others platforms.

Tangelo now supports the import of iFCI fragments resulting from a QEMIST Cloud calculation, so that users can explore the potential of quantum computing in conjunction with methods designed to scale to more industrially-relevant use cases. Find more about it in this tutorial notebook.

Improved support for active space selection

Active space selection is a process in chemical modeling that reduces computational requirements while retaining accuracy, by strategically choosing the molecular orbitals that contribute to calculations. On top of the built-in frozen core method and the ability for users to manually specify a frozen orbital list, Tangelo now supports:

• Frozen Natural Orbitals (FNO) as a built-in method
• Active space computed by tools such as SCINE autoCAS, as shown in this example

Check out our updated tutorial.

iQPE Solver and measurement-controlled gates

Tangelo users are now able to simulate adaptive circuits with measurement-controlled gates. This opens up a class of algorithms that can implement processes that can not be done using only unitary gates. It is another useful building block for those of you researching fault-tolerant approaches, among others we had highlighted in one of our hands-on tutorials. We used this feature to expand our Quantum Phase Estimation (QPE) framework and provide an implementation of iQPE (named IterativeQPESolver).

DMET and VQE performance optimizations (part 1)

Quite a few of you have used DMET and VQE approaches in your recent work. Your feedback allowed us to provide significant performance improvements to these workflows, mostly based on cacheing and reusing previous calculations.

• Significant performance improvements in VQESolver.get_rdm method, used in DMET + VQE.
• In the near future, we'll push performance improvements for VQE to speedup updates in the variational ansatz quantum circuit (way less time spent in circuit translation and UCC-like ansatz updates).

Misc

• Feature: UHF symmetry reference labels
• Feature: IBMConnection now supports target instance
• Feature: trim qubits flag for circuit.split
• Bugfix: adapt to new qiskit version for noisy simulation
• Bugfix: DMET fix for solvers and fragment object initialization with options
• Bugfix: trim_trivial_qubits

Tangelo v0.4.1 is here !

Greetings, Tangelians.

Tangelo v0.4.1 is here ! It has been a little bit since the latest release: we’ll be attempting to make more frequent releases and updates to our main branch in order to make sure everyone is able to leverage the latest developments. We have a few cool things coming up, which will be rolled into version 0.4.2, scheduled for late November 2023.

Please cite this project if you happen to use it in your research: it means a lot to us and helps the community see what has been achieved with these tools. The BibTeX citation snippet is available at the bottom of the README, and any mention of Tangelo during your talks is deeply appreciated.

Credits

This release was possible thanks to the contributions of @AlexandreF-1qbit @JamesB-1qbit @ccoulombe and @ValentinS4t1qbit.

Highlights of this release:

Tutorials & Hands-on

It has never been easier to get started with Tangelo ! Every single attendee at our IEEE Quantum tutorial went to the Tangelo-Examples repository and got started within a minute without any install on their laptop (or even their tablet !) using .

The Tangelo team put together simple hands-ons that both let users get started with Tangelo and get a good overview of what it can do in a short amount of time. We strongly recommend them for both newcomers and experienced users ! They are rather simple exercises, and refer you to additional resources (Tangelo notebook tutorials, blog posts, publications, …) to learn what you need, and more if you choose to!

Your feedback pushed us to implement a tagging system for tutorial notebooks, which lets users find at a glance what tutorials are relevant to their interests ! Trying to find a feature or learn about a specific topic ? Here's a glimpse of what you will see:

QM/MM problem decomposition method

Quantum Mechanics / Molecular Mechanics, also known as QM/MM, is a computational technique that enables the treatment of a region of a molecular system at a given level of quantum chemistry, while the remainder is modeled with force fields. One of the main applications of this framework is to consider solvent molecules explicitly, with a negligible computational overhead.

This comes handy in situations where the environmental effect is important, such as in the simulation of biochemical systems with solvent molecules or chemical reactions in amorphous materials. Our implementation currently supports electrostatic embedding and can be paired with both our quantum and classical solvers, using an interface similar to our ONIOM solver. A QM/MM tutorial will be released in November.

from tangelo.problem_decomposition.qmmm.qmmm_problem_decomposition import QMMMProblemDecomposition
from tangelo.problem_decomposition.oniom._helpers.helper_classes import Fragment
from tangelo.toolboxes.molecular_computation.molecule import get_default_integral_solver

# The fragment object includes the 33 atoms from the Ala-Ala-Ala polypeptide, here defined in a PDB file.
frag = Fragment(solver_high="hf", selected_atoms=list(range(33), options_high={"basis": "sto-3g"})
qmmm = QMMMProblemDecomposition({"geometry": "AAA_solvated.pdb", "qmfragment": frag, "mmpackage": "openmm",
                                 "integral_solver": get_default_integral_solver(qmmm=True)})
energy = qmmm.simulate()

Note: some features may require you to install packages such as rdkit or openbabel-wheel through pip or conda.

QPESolver (Quantum Phase Estimation framework)

This summer, a user mentioned to us that they felt there was an overall lack of user-friendly QPE code in the community. Tangelo now provides a QPE framework which allows users to perform Quantum Phase Estimation on the desired molecule (or qubit operator) with a number of built-in options related to the time-evolution algorithm used in the controlled unitaries.

The interface of QPESolver is very similar to VQESolver, and should come very naturally to experienced users:

from tangelo.algorithms.projective.qpe import QPESolver

qpe_solver = QPESolver({"qubit_hamiltonian": qu_op, "size_qpe_register": 3, 
                        "ref_state": hf_circuit, "backend_options": {"target": "cirq"},
                	"unitary_options": {"time": -2*np.pi, "n_trotter_steps": 12, "n_steps_method": "time", "trotter_order": 4}})
qpe_solver.build()
energy = qpe_solver.simulate()

Users can even implement a custom Unitary object to define their own controlled time-evolution protocol and pass it to QPESolver as a black box ! Feel free to draw from our circuit toolbox to leverage other readily-available approaches such as multiproduct, quantum signal processing or truncated taylor series.

Check out our hands-on on fault-tolerant building blocks to see how to use QPE and some of the fault-tolerant building blocks in Tangelo (block encodings, amplitude amplification, time-evolution…).

This is only the beginning: this framework will be soon extended to support Iterative QPE, and can go even further with your contributions.

Circuit simplification

Simplify your quantum circuits by removing redundant gates, combining parametrized gates and removing those that are close to Identity. Combined with the function trim_trivial_qubits, you may be able to easily trim off qubits from both your circuits and qubit operators.

Did you know that quite a few parameters in VQE-UCC approaches are optimized to a value that is indistinguishable from zero for current quantum devices ? Therefore, many gates can be removed with little impact on the theoretical result. The example below shows how a pre-optimized VQE-UCCSD 12-qubit circuit for the $H_2O$ molecule can be simplified, taking down the number of gates from roughly 19K to 9K in under 3s on a laptop. The impact on the expectation value was only about $5 \times 10^{-5}$ Hartrees, well below chemical accuracy.

c = H2O_UCCSD_circuit   #gates = 19104 #qubits = 12
c.simplify()            #gates =  9324 #qubits = 12

Pytket users can use the translate_circuit function to convert their Tangelo circuit to the openQASM format, which can then be read in by pytket. See the example here.

With your help, Tangelo could support broader gate sets and more gate identities. This will help with compiling efficient circuits for various architectures.

Misc

• Automated testing currently covering python 3.8, 3.9, 3.10, 3.11 (#333)
• Installation: pyscf removed from requirements
• Performance improvement: combinatorial mapping
• Feature: ILC iteration now implements exact expansion / parameters
• Feature: VQE-like algorithms verbose mode now prints and tracks energies, for users interested in the convergence of the algorithm.
• Feature: Updates in IBMConnection to keep up with changes in qiskit-runtime, support for batch submission of circuits for sampler primitive.
• Feature: function returning qubits used for truncated taylor series (#339)
• Bugfix: Combinatorial mapping now handles spin != 0 (#330)
• Bugfix: get_expectation_value takes into account n_shots for all backends supporting the option.
• Bugfix: Fix corner case of FCI and CCSD solvers calculations (mo coefficients were occasionally recomputed differently).

Tangelo v0.4.0 is here !

Dear Tangeloids: we are pleased to present you with 🍊 Tangelo v0.4.0 🍊.

It took us a bit longer than anticipated: significant work has been put towards this release, always with the goal to empower researchers to go further and faster.

Please kindly credit this project if it helps seeing your work coming to fruition: we would find it very rewarding. In the meantime, you can support this project by clicking the ⭐ in Github, or even better: give Tangelo a shot, mention it to your network.

Feedback, feature requests, bug reports and contributions are appreciated and help move the field forward: that includes -your- research !

Credits

This release was possible thanks to the contributions of @elloyd-1qbit @JamesB-1qbit @AlexandreF-1qbit @ValentinS4t1qbit @jjgoings and the help of quite a few others outside of Github. Thank you all for your contributions, whether code, tutorials, or feedback of any kind.

Highlights of this release

Classical chemistry backends for electronic calculations (pyscf, psi4, etc) are now optional dependencies

This should greatly help people who had trouble installing pyscf, or prefer using other packages such as Psi4. We wanted to make sure people could use Tangelo alongside whichever classical chemistry backend they were accustomed to. Tangelo no longer installs pyscf automatically: both pyscf and psi4 are now optional dependencies. Most features and algorithms now support Psi4.

On top of that, users can now define their own electronic integral solver or directly provide electronic integrals computed with their tool of choice as input to algorithms , as long as they fit the expected format.

Thank you @JamesB-1qbit for making all of this possible !

Open-shell DMET, with Unrestricted Hartree-Fock (UHF) mean-fields

Interested in modeling chemical reactions, or maybe battery chemistry ? DMET can now be applied more accurately to open-shell systems, now that our implementation supports UHF mean fields. Check out our notebook.

To our knowledge, nothing so far has been published about combining UHF-DMET and quantum algorithms.
You could be the first. Wouldn’t that be neat ?

Symbolic Simulator

Courtesy of @AlexandreF-1qbit , this backend performs symbolic simulation of quantum circuits and returns algebraic expressions for quasi-probability histograms and expectation values.

This powerful tool can help you design better quantum circuits, establish matrix identities between various gate sets, efficiently explore landscapes created by parameters in your circuits after just a single simulation, and more ! Both an asset for research and educational purposes. This simulator relies on the python package sympy, which enables you to do a lot of cool things (calculus, mon amour).

Check out this beautiful notebook to see it in action across a few different use cases, from chemistry or even amplitude amplification in Grover’s algorithm !

Fast Clifford simulator integration, with Stim

This “stimulator” is now available as a built-in backend in Tangelo thanks to @elloyd-1qbit . Circuits made out of clifford gates are efficient to simulate classically, and appropriately designed simulators can scale to large circuits depths on many qubits, beyond what is possible on a typical statevector simulator. We have been using the package Stim in our research to design clifford versions of existing variational quantum algorithms (https://arxiv.org/abs/2211.10501). This exploration has allowed us to generate ansatze for systems of much larger size (~40 qubits on a laptop), which can be further optimized on a quantum computer.

Hardware experiments with Braket

We were way overdue for that one, but the BraketConnection is now available for those of you who like to use Braket for their experiments.

Early May, we released a blog post with a companion notebook on AWS quantum blog, which covers all the steps of designing and running a non-trivial hardware experiment, and showed some fault-tolerant methods in action as a bonus. The QEMIST Cloud integration was conveniently used to provide a cost estimate and submit the quantum circuits to Braket, but now you can directly use the BraketConnection and your own Braket credentials if your organization has AWS all figured out for you.

We refreshed our “QPU connection” notebook to provide a better overview of the different ways Tangelo supports you in taking your research to quantum processors, between convenience and fine-control. If you’d like us to prioritize building a connection for Azure Quantum, please open a feature request. The translation functions make it however already pretty straightforward.

Combinatorial qubit mapping

There’s more to life than the Jordan-Wigner and Bravyi-Kitaev mappings, for the crucial task of encoding our problems into qubits. You’ll find in Tangelo the JKMN mapping, Hardcore-Bosonic mapping and now the combinatorial mapping.

On LiH in cc-pvdz basis with frozen-core approximation, we observed that the combinatorial mapping only needed 9 qubits to encode our qubit Hamiltonian instead of a whooping 34 qubits for Jordan-Wigner ! This mapping may unlock some new use cases for your developments. The encoding itself is quite compute-intensive and we’re looking into bringing faster implementations to address this challenge.

Algorithms

• Most algorithms now support psi4 as a classical chemistry calculation backend.
• New: MP2Solver (Uses the Second-order Moller-Plesset perturbation theory method to solve the electronic structure problem)

Tutorials

• The notebooks in the Tangelo-Examples repo are now rendered with Github-Pages
• Problem Decomposition: UHF-DMET
• Linq: Symbolic backend
• Hardware experiments: Umbrella inversion notebook, QPU connection notebook.

Misc

• Feature: qubit trimming in quantum circuits and qubit Hamiltonians, to avoid simulating trivial qubits.
• Feature: conversion methods between Tangelo and Openfermion QubitOperator objects.
• Feature: support for MP2 parameters with UHF mean field.
• Feature: DMET virtual orbital truncation threshold visible to user
• Feature: Checkfile for IntegralSolverPySCF
• Deprecated: Simulator class (now get_backend), former translation functions (now under translate_circuit)
• Bug fix: DMET with frozen orbitals for fragments
• Bug fix: DMET with Effective Core Potential
• Bug fix: Gate.inverse method (S and T)
• Performance: Circuit.depth method performance increase (much faster)

Tangelo v0.3.4 is here

Howdy’ Tangelites ! v0.3.4 is now available.

If you think this project is a good idea, please click right now on the ⭐ button on the top-right corner of your screen, and consider downloading Tangelo. It helps us make this project more visible and to understand how relevant it is to the community. Seriously, it’s small but it means a bunch to us right now :)

Credits

Cheers to @JamesB-1qbit, @AlexandreF-1qbit, @KrzysztofB-1qbit and @ValentinS4t1qbit for contributions to the codebase, and to @chrislzhao for his feature request and feedback, integrated in time for this release. Bug reports and feature suggestions are super useful: this is what helps our community make tools that really help people. And that’s what this project is all about.

Highlights of this release:

Python version bump to 3.8+

Python 3.7 is no longer maintained by the Python team: Tangelo now requires you to have Python 3.8 or more in your environment. The latest version of Python is currently 3.11; if you happen to have issues with any of the newer versions please let us know. We’ll try to extend our testing and make things work for you.

You don't have to choose between quantum frameworks. Use all of them.

It’s now really easy to convert existing projects between Tangelo and your favorite frameworks; now both quantum circuits and qubit operators can be converted in a single line of code, in either direction. There are so many platforms with unique features and cool backends to explore: we think that freedom is essential to the research in our field. Two simple functions allow you to convert your quantum circuits and qubit operators between a variety of popular formats, including the recently-added Pennylane.

You have an existing project in Qiskit, want to use Tangelo to explore some workflows and then take this to a quantum device available on Amazon Braket ? Go for it. Neither the source or target format need to be "tangelo", but the conversion uses it as an intermediary format under the hood.

from tangelo.linq import translate_circuit, translate_operator

qiskit_circ = translate_circuit(tangelo_circ, target="qiskit")
tangelo_op = translate_operator(qiskit_op, source="qiskit", target="tangelo")

If you can’t find the format you need, we’d love you to submit a feature request, or even better: try to contribute it to the codebase and let your peers benefit from it. We’re here to support you with the process, may you be a seasoned developer or not.

More to do with mid-circuit measurements

Additional features are now available for simulating circuits with mid-circuit measurements. The simulate method can now save mid-circuit measurements. You can also explore the statevector resulting from a set of mid-circuit measurements, or retrieve the deterministic state corresponding to a desired mid-circuit measurement result. These features are implemented as optional arguments to simulate (see small example below).

Many algorithms depend on a certain measurement result to signify a successful quantum circuit run. These algorithms include Linear Combination of Unitaries (LCU), Quantum Signal Processing (QSP), symmetry projection, Rodeo Algorithm, probabilistic imaginary time evolution, quantum Lanczos, and more ! It is now possible to link these algorithms with further quantum operations intrinsically in Tangelo.

c = Circuit([Gate("H", 0), Gate("MEASURE", 0), Gate("CNOT", 1, 0)])
sim = get_backend()
sim.simulate(c, desired_meas_result="0")[0])      # Output:  {'00': 1.0}
sim.simulate(c, desired_meas_result="1")[0])      # Output:  {'11': 1.0}     

UHF mean-field reference: towards better modeling of open-shell systems

The unrestricted Hartree-Fock mean field is now supported in Tangelo, during the instantiation of the SecondQuantizedMolecule. This mean-field method gives a better starting state for the search of the ground state for open-shell chemical systems, i.e. molecules with different numbers of electrons of each spin. A given algorithm would then give a better representation of the state, thus improving the chemical properties computed from this numerical representation.

Those systems are important to study chemical kinetics, where elementary reactions are primordial. In other words, there is a high probability that high-energy intermediate molecules could either be charged or a radical: UHF is generally a better mean-field description of the latter. The Tangelo team has been working towards supporting UHF mean-field with some variational algorithms and problem decomposition techniques, and will disclose more about their ongoing research later this year.

Algorithms

• You can now create time-evolution circuits for time-dependant Hamiltonians efficiently using the discrete clock construction (https://arxiv.org/abs/2203.11353) and the multiproduct trotter evolution (https://arxiv.org/abs/1907.11679). #257

• Grid-like basis functions are hypothesized to be the most efficient for fault-tolerant quantum computers. Tangelo now has functions (#257) that generate the time-evolution for the kinetic energy operator and potentials of the form

$$a+b*x+c*x^2$$

• The pUCCD ansatz is now available for VQE-based solvers. This chemistry-inspired ansatz implements the hard-core boson Hamiltonian approximation and thus requires only 3 measurement bases, at the cost of a potentially reduced energy / state accuracy (https://arxiv.org/abs/2002.00035). #251

Tutorials

There is now a dedicated Github repository, that you can explore directly through Github or Github pages. This space welcomes tutorials and scripts from all, and is an opportunity to showcase your Tangelo projects: we’re happy to list projects involving Tangelo there as well. Don’t be shy :)

We tried to sort things to help you find what’s relevant to you, and added a few new things there:

• Alexandre Fleury came across a recent publication about Graph |Q><C| and wanted to put Tangelo to the test. With a simple script (~60 lines of actual code), he drew what he needed from the toolboxes in Tangelo and reproduced some of the results - he even pushed a bit further with very little effort, by looking at different ansatze -. A pleasant experience suggesting that Tangelo can help people keep up with state-of-the-art and accelerate research.

• James Brown uploaded a notebook showing how he easily integrated the Clifford simulator from Cirq as a custom backend (it is not supported as a built-in in Tangelo) to his Tangelo workflows. This integration enabled research that led to the manuscript posted on arXiv titled Iterative Qubit Coupled Cluster using only Clifford circuits.

• Check out the notebook behind the demo we realized for the IBM Quantum Summit in October 2022. It shows how Tangelo seamlessly integrates with IBM Quantum, on a simple use case leveraging the error-mitigation techniques of both Tangelo and IBM’s technology. You can just zoom to the last section if what’s relevant to you is how the qiskit-runtime integration works, the gist of it is very simple and just 3-4 lines of code.

Misc

• Tangelo circuits now have a built-in draw method, for convenience. Otherwise you can always convert your circuit into a different format with a single line of code, and use the drawing features of your favorite framework (we love using Qiskit for drawing circuits, it’s very pretty). #266
• Compute_rdm function can now handle string and openfermion-style tuple formats #269
• Auto threshold cutoff for small coefficients in LCU #261
• DMET + frozen orbitals for each fragment #276
• allow single flip index dis for qcc #247
• Error estimation (standard deviation) available for Richardson extrapolation #252
• Bugfix: DMET - QCC

New release: version 0.3.3

You're all awesome

Greetings, Tangelites ! (Tangelians? Tangelies? Tangeloids ? Tangelords ? You decide.)

This release comes with a number of existing features and improvements over the past version of Tangelo, as detailed in the release notes below. A big thank-you to our code contributors: @JamesB-1qbit, @AlexandreF-1qbit, @KrzysztofB-1qbit, @MPCoons, @ValentinS4t1qbit and @jjgoings (first contribution to this project!) but also to everyone who engaged in feedback, raised issues or joined discussions on Github or through other channels: your input is invaluable.

What's Changed

Enhanced integration with other platforms

The translation and simulation in linq is now more modular, and provides a better integration with other platforms through streamlined processes. In particular, all circuit format conversion can be done through the translate_circuit function. The list of the available source and target formats is available here. The translate_operator function provides an equivalent for qubit / Pauli operators.

The Simulator class has been deprecated in favor of the get_backend function, and Tangelo now supports user-defined backend: all algorithms should be able to run on user-defined simulators or QPU backend. (#196, #203, #212, #213, #223, #245, #246)

Better streamlining of quantum experiments

We recently ran a few quantum experiments, and learnt that there are features and steps that could be better streamlined in Tangelo. As a result, we added a few features for post-processing and error-mitigation. The Histogram class enables renormalization, post-selection and aggregation of experimental data. A compute_rdms function now facilitates the recomputation of RDMs from experimental results. Computing the variance / standard deviation of an expectation value is now possible using the backend methods, thanks to @jjgoings. (#238, #217, #232)

We have streamlined the submission of experiments to IBM Quantum with the new IBMConnection class. A quantum experiment demonstrating how QEMIST Cloud, Tangelo and IBM Quantum can work together was featured at the IBM Quantum Summit: the corresponding notebook will be available shortly. We also improved the experience for IonQ and QEMIST Cloud connections. (#222, #225, #207)

Tutorials and notebooks

Most tutorials are now available in a “no local install” mode for everyone who has access to services such as Google Collab. We also added a few pretty nifty tutorials for our fellow chemists and end-users with interests in excited states. The qchem modeling notebook provides great insight about what matters when throwing a molecule to quantum computers, while the excited states notebook recaps what approaches are available to compute excited states, and even implements a few extras ones on the spot ! (#197, #198, #199)

New algorithms and features

• iqcc-ilc solver fork by @MPCoons in #179
• Quantum Signal Processing time-evolution by @JamesB-1qbit in #204
• even Trotter order > 2 by @JamesB-1qbit in #210
• trotter order and active electrons for QCC/iQCC by @JamesB-1qbit in #234
• TETRIS-ADAPT-VQE by @AlexandreF-1qbit in #241
• Multi-control support for trotterization by @JamesB-1qbit in #244

Install, documentation and developer tools

The Docker image has been fixed, a release guide is available for project maintainers in the dev_tools folder,, and automated tests now export coverage file: over 90% of our code is currently covered by tests (#158, #195, #200).

Miscellaneous

• Bug fix: VQE.operator_expectation by @AlexandreF-1qbit in #191
• Simplifying formula for n_measurement estimation by @AlexandreF-1qbit in #192
• c2v axis definition change by @JamesB-1qbit in #205
• Add n_qubits option to MultiformOperator compress function by @JamesB-1qbit in #209
• Remove superfluous qubits with scBK in ADAPTSolver by @AlexandreF-1qbit in #214
• Remove the n_min_orbitals attribute by @AlexandreF-1qbit in #218
• JKMN vector prep should return an array of int by @AlexandreF-1qbit in #215
• Change JKMN Majorana definition so mapped Hamiltonian is real by @JamesB-1qbit in #219
• Relaxing iqcc_ilc_h4_cation test by @AlexandreF-1qbit in #221
• Compute energy from RDMs with FermionOperator by @AlexandreF-1qbit in #220
• Circuit is now iterable (traverse gate list) by @AlexandreF-1qbit in #194
• add repr method to Gate by @JamesB-1qbit in #229
• Add circuit.depth() in get_resources methods by @KrzysztofB-1qbit in #235
• copy + get_resources + invertible swap gate fix by @JamesB-1qbit in #193

Full Changelog: v0.3.2...v0.3.3

Version 0.3.2 release

Hello Tangelo users (Tangelites? Tangelians ? Tangeloers? Tangelies? Tangeloids? Tangelords? We will decide later.)
We're gonna try to make a release every 1-1.5 months to make sure we gradually refresh the pip release with bug fixes and features, or ensure installation remains... as painless as possible.

A quick peek at the CHANGELOGS:

Added

Linear Combination of Unitaries (LCU)
QEMIST Cloud MI-FNO innregration: interface adjustments
iQCC ansatz for VQE
IonQConnection class and notebook, to facilitate experiments through IonQ's API
FCISolver active space selection / frozen orbitals: restrictions for half-empty orbitals

Changed

QEMIST Cloud MI-FNO innregration: interface adjustments
ADAPT-VQE interface: spin only required when needed
VQE returns warning or error if no variational parameters are in the ansatz circuit
Bug fix: scBK reference state, HEA ansatz initialization
Check for valid number of target qubits for common gates
Documentation, README

Thank you @AlexandreF-1qbit, @JamesB-1qbit @elloyd-1qbit @KrzysztofB-1qbit @MPCoons @RudiP4t1qbit for your contributions !
If you want to contribute to this project, please consider opening issues or discussions in Github, or reach out directly, to help us stir the developments in the direction that helps you :)

v0.3.1

What's Changed

• Bump develop to v0.3.0 (#127) by @ValentinS4t1qbit in #128
• Recomputing MF when working with atom indices by @AlexandreF-1qbit in #130
• More gates for openqasm translator by @AlexandreF-1qbit in #129
• fixed return for return_phase=False in trotterize by @JamesB-1qbit in #133
• ONIOM problem reformulation by @AlexandreF-1qbit in #119
• QubitHamiltonian get_operators bug by @AlexandreF-1qbit in #131
• Measurement map by @ValentinS4t1qbit in #134
• Givens gate by @JamesB-1qbit in #135
• Notebook classical shadow by @AlexandreF-1qbit in #123
• added class to prepare or decompute an arbitrary statevector by @JamesB-1qbit in #137
• Many small todos by @AlexandreF-1qbit in #138
• Diag coulomb by @JamesB-1qbit in #136
• improvements to jkmn leaf->majorana selection by @JamesB-1qbit in #139
• permit all active orbitals partially occupied by @JamesB-1qbit in #146
• ONIOM capping with chemical groups by @AlexandreF-1qbit in #141
• split uccgd files by @JamesB-1qbit in #144
• call pyscf directly, symmetry now supported by @JamesB-1qbit in #147
• Rotosolve implementation as an optimizer for parameterized circuits by @elloyd-1qbit in #142
• ONIOM multisolvers by @AlexandreF-1qbit in #143
• support for reading in xyz files by @JamesB-1qbit in #151
• State-Averaged Orbital Optimized VQE solver by @JamesB-1qbit in #148
• Qubit tapering by @AlexandreF-1qbit in #145
• Ilc ansatz by @MPCoons in #132
• README update (Windows install, Jupiter notebooks help) by @ValentinS4t1qbit in #155
• Quantum deflation by @JamesB-1qbit in #152
• changed default basis, added ecp option by @JamesB-1qbit in #156
• Cancel redundant gates by @AlexandreF-1qbit in #153
• Circuit depth by @ValentinS4t1qbit in #159
• MI-FNO link by @AlexandreF-1qbit in #157
• Iqcc solver by @MPCoons in #154
• MIFNO notebook by @AlexandreF-1qbit in #161
• Docs fix by @ValentinS4t1qbit in #162
• readme upgrade by @ValentinS4t1qbit in #164
• Fixes for docs and readme, files for Pypi by @ValentinS4t1qbit in #166
• Update to release/v0.3.1 by @ValentinS4t1qbit in #167

Full Changelog: v0.3.0...v0.3.1

Thank you @AlexandreF-1qbit, @JamesB-1qbit @elloyd-1qbit @KrzysztofB-1qbit @MPCoons for your contributions !

version 0.3.0

Highlights

• Circuit operators and methods (repetition, equality, trim, split, stack...)
• Support for Classical Shadows ((de)randomized, adaptative)
• Sphinx documentation generator script in dev_tools
• JKMN qubit mapping
• QMF, QCC and VSQS ansatze for VQE
• Controlled-time evolution, Richardson extrapolation method

Changed

• Naming (Good Chemistry, Tangelo, linq)

Bug fixes

• Fixed some issues in DMET (recomputation of mean-field when re-ordering atoms)

Contributors

@ValentinS4t1qbit @AlexandreF-1qbit @JamesB-1qbit

Special thanks and congratulations for getting your first PRs merged,
@elloyd-1qbit @KrzysztofB-1qbit @MPCoons @RudiP4t1qbit !

v.0.2.0

Highlights

qSDK has been reorganized and the installation simplified, it seems to work seamlessly on both MacOS and Linux. Simulators are now optional dependencies that can be installed separately.

Breaking changes

The agnostic_simulator package no longer exists, and its functionality is now implemented in qsdk.backendbuddy.
electronic_structure_solvers folder has been renamed algorithms and subdivided further.

Bug fixes

Minor tests improvements (test failures due to finite precision error)

Change of behaviour

Verbose behaviour of PD techniques (DMET and ONIOM) changed.

Thank you @AlexandreF-1qbit and @JamesB-1qbit for your contributions !