QILaplace.jl - Quantum-Inspired Fourier and Laplace transforms with tensor networks

Package Announcements
,
1

Hi all,
A few months ago, I posted on Julia Discourse asking for feedback on my first-ever Julia package (link). Thanks to the lovely feedback from the community and those who reached out to me personally, QILaplace.jl is now a registered Julia package.

This package provides a tensor-network-based approach to certain signal transforms. The main idea is that some large structured signals can be efficiently represented as Matrix Product States (MPS), while their transforms can be applied as Matrix Product Operators (MPO). In particular, this package implements the Quantum Fourier Transform and the non-unitary Laplace transform using MPS/MPO framework.

For compressible signals, this allows one to work with very large effective signal spaces without explicitly storing all entries. For example, the package can inspect transformed signals with effective output spaces as large as 2^{60} points on a desktop computer, provided the relevant tensor-network representations remain compressible. In particular, for the Discrete Laplace transform, this package offers a competitive runtime compared to currently available methods. The underlying algorithms are mainly based on the paper by Noufal et al. and Chen et al..

Some things the package currently offers:

  • Quantum-inspired Fourier transforms using MPS/MPO representations.
  • Laplace (Complex Laplace) and damped (Real Laplace) transforms implemented as non-unitary MPO transforms.
  • SVD/RSVD-based signal compression.
  • Examples reproducing key figures from the reference paper.
  • Benchmarking utilities and documentation explaining when this approach is useful.
  • Integration with ITensors.jl.

Here is a small example of what the API looks like:

using QILaplace

n = 10                       # log2 signal length -> 1024 time samples
signal = generate_signal(n; kind=:sin_decay,
                         freq=[1.0, 2.5], decay_rate=[0.08, 0.03])

ψ = signal_mps(signal; method=:rsvd, cutoff=1e-9, maxdim=64)
compress!(ψ; maxdim=64)

Wqft = build_qft_mpo(ψ; cutoff=1e-12, maxdim=128)
spectrum = Wqft * ψ                               # Apply MPO to MPS

# Extract physical-scale amplitude at frequency bin (bit-reversed order)
amplitude = spectrum[0,1,0,1,0,1,0,1,1,0]

From some of your suggestions, I have spent a fair amount of time writing the documentation, since I wanted the package to be accessible to a general audience, and not necessarily ones having a tensor-network background. So I have included some basic overviews, tutorials for each signal transform, and benchmark scripts that reproduce the main paper’s results that you can run on your local machine. Since this is my first time developing and documenting a package, I would really appreciate any feedback on the documentation (and also if the animations helped you understand the concepts).

Thanks again to everyone who helped me turn this from a rough first package into something much closer to a proper Julia package release!

DTCircuitCompression

2 Likes