DOCS and bug fixes

SymPT v1.2.1 Release Notes

We're excited to announce that SymPT now has official documentation! 🎉 You can access it here: SymPT Documentation.

This release also includes minor fixes to the .get_U(), .get_S(), and .rotate() methods of EffectiveFrame, improving their reliability and consistency.

As always, let us know if you run into any issues or have feedback! 🚀

Release 1.2.0: Additional Return Formats

Release Notes

Version 1.2.0

This release introduces new features for handling the results of the frame transformations. The major changes include enhanced conversion functionality, new return types, improved caching, and additional helper imports.

---

New Features

• Bugs in get_H method were fixed.

• New Return Formats:
  Methods get_U, and get_S were implemented to allow the user to access the unitary transformation $U$ and its generator $S$. These methods support the following return formats: 'operator', 'matrix', 'dict', 'dict_operator', and 'dict_matrix'.

Working Example

Rabi Model

# sympt imports
from sympt import *
# Import sympy
import sympy as sp

# ---------------- Defining the symbols ------------------
# Order 0
omega = RDSymbol('omega', order=0, positive=True, real=True)
Omega_z = RDSymbol('Omega_z', order=0, positive=True, real=True)
# Order 1
g = RDSymbol('g', order=1, positive=True, real=True)
  
# ----------------- Defining the basis -------------------
# Spin basis: Finite 2x2 Hilbert space
Spin = RDBasis('sigma', dim=2)
s0, sx, sy, sz = Spin.basis # Pauli Operators
# Boson basis: Infinite bosonic Hilbert space
a = BosonOp('a')
ad = Dagger(a)

# -------------- Defining the Hamiltonian ----------------
# Unperturbed Hamiltonian H0
H0 = omega * ad * a + sp.Rational(1,2) * Omega_z * sz

# Interaction Hamiltonian V
V = g * (ad + a) * sx

Eff_frame = EffectiveFrame(H0, V, subspaces=[Spin], verbose = False)
# Calculate the effective model using the Schrieffer-Wolff transformation up to the second order

Eff_frame.solve(max_order=2, method='SW')
# Obtaining the result in the operator form
H_eff_SWT = Eff_frame.get_H(return_form='matrix')

U = Eff_frame.get_U(return_form='operator')
U_corrections = Eff_frame.U_corrections
S = Eff_frame.get_S(return_form='operator')
S_corrections = Eff_frame.S_corrections

Minor bug fixes

Fixed minor issue with performing matrix level full diagonalization transformations.

Minor bug fixes

• Fix rotate
• Fix README example

Minor Optimization Tweaks

This update introduces a few under-the-hood tweaks to further optimize computations. By leveraging the commutativity of operators where applicable, calculations are now faster and more efficient.

New year release

Release v1.1.0 - Optimizations, API Refinements, and Enhanced Output

🎉 New Year, New SymPT! We're excited to kick off 2025 with the release of SymPT v1.1.0, featuring significant updates to improve performance, usability, and functionality. Here's what's new:

🚀 Performance Optimization

• Faster Calculations: Inspired by this paper, we've streamlined the calculation process by reducing the number of commutators required for each perturbation order. This optimization ensures a more efficient and scalable workflow for your transformations.

🔧 API Updates

• Method Consolidation: The "LA" (Least Action) method has been integrated with the "ACE" (Arbitrary Coupling Elimination) method. Now, ACE automatically incorporates least-action transformations, simplifying the method selection process while providing advanced functionality for all use cases.
• This update ensures that least-action principles are seamlessly applied across all transformations supported by the ACE method.

🎨 Enhanced Output

• Simplified Effective Hamiltonians: The output of effective Hamiltonians has been improved to provide a cleaner, more intuitive form, making results easier to interpret and utilize in subsequent analysis.

📚 Documentation Updates

• The documentation and examples have been updated to reflect the API changes and enhancements in this version.

As always, we’d love to hear your feedback! If you have any questions, comments, or suggestions, don’t hesitate to reach out or submit an issue on the GitHub repository.

Thank you for your continued support, and we look forward to seeing how you leverage SymPT in your projects.

— The SymPT Team

minor name changes

changed name of get_structure() to get_block_mask()

Publication

Release Notes: SymPT v1.0.0 🎉

We're thrilled to announce the first official release of SymPT: Symbolic Perturbation Theory! This Python package is designed to streamline symbolic perturbative transformations in quantum mechanics, offering powerful tools for researchers and developers working on effective Hamiltonians and related problems.

---

🚀 Key Features

• Comprehensive Transformation Methods:

  • Schrieffer-Wolff Transformation (SWT) for block-diagonalization.
  • Full-Diagonalization (FD) for eliminating all off-diagonal elements.
  • Arbitrary Coupling Elimination (ACE) for targeted transformations.
  • Least-Action Multi-Block Transformations for advanced multi-block diagonalizations.

• Symbolic Computation: Built on sympy, providing exact symbolic results for quantum systems.

• Customizable & Intuitive:

  • Easily define Hamiltonians, operators, and transformations with symbolic expressions.
  • Flexible output options: matrix, operator, or dictionary forms.
  • Easily integratable with sympy and other python libraries.

• Time-Dependent & Independent Support: Apply transformations to both static and dynamic quantum systems.

---

📚 Documentation

Visit the README for a detailed guide, including:

• Installation instructions.
• Example workflows (e.g., performing SWT or ACE transformations).
• Core classes and their functionalities.
• Algorithms and use cases.

---

💻 Installation

Get started quickly:

git clone https://github.com/qcode-uni-a/sympt.git
cd SymPT
pip install .

Dependencies:

• Python 3.8+
• sympy, numpy (required)
• matplotlib (optional, for visualizations)

---

🌟 What’s Included

1. Core Modules: Classes like RDSymbol, RDBasis, and EffectiveFrame for constructing and solving quantum transformations.
2. Algorithmic Suite: A versatile set of routines for symbolic perturbative calculations.
3. Example Code: Illustrative scripts demonstrating SWT, ACE, and more.

---

📬 Feedback & Contributions

We’re eager to hear from you! Whether it’s a bug report, feature request, or code contribution, your input is invaluable:

1. Fork the repo.
2. Create a feature branch.
3. Submit a pull request.

---

🔗 License

SymPT is open-source and released under the MIT License. See the LICENSE file for details.

---

Thank you for trying out SymPT! We look forward to your feedback and contributions as we continue to improve and expand this toolbox for the quantum research community.