quantum optics engineers

Abstract: Greenberger-Horne-Zeilinger (GHZ) states are multipartite entangled quantum states that play a central role in quantum information theory, with applications in quantum communication, cryptography, and distributed quantum computing. A major experimental goal is to create high-dimensional GHZ states using multiple entangled parties. Krenn, Gu and Zeilinger discovered a surprising bridge between these quantum-optical experiments and graph theory: certain photonic experiments can be represented by edge-coloured, edge-weighted graphs, and the dimension of the produced GHZ state equals the number of feasible monochromatic inherited vertex colourings. This led Krenn and Gu to conjecture that every GHZ graph with more than four vertices has dimension at most $2$. A counterexample would give a new high-dimensional multipartite GHZ construction, while a proof would clarify fundamental resource limitations in quantum optics. It is known that the conjecture holds for graphs of vertex connectivity at most $2$ [MFCS 2024], and that simple GHZ graphs with $n>4$ vertices have dimension less than $n/\sqrt{2}$ [Quantum 2024]. However, no general upper bound depending only on vertex connectivity was known. We prove that every simple connected GHZ graph $G$ with at least four vertices has dimension at most $2^{κ(G)-1}+\binom{κ(G)}{2}$, where $κ(G)$ is the vertex connectivity of $G$. We also prove new bounds in terms of edge connectivity and maximum degree.

Abstract: A quantum orthogonal polynomial transform (QOPT) is an algorithmic primitive that maps a superposition of standard basis states $\sum_k α_{k} \ket{k}$ coherently to a basis of normalized univariate polynomials orthogonal with respect to a probability measure $μ(x)$. We provide new discrete and continuous QOPTs for polynomial families in the Askey scheme extending the results for the quantum Hermite transform (Jain et al., STOC'26). Our efficient QOPT algorithms require time $O(\text{polylog}(N, 1/ε))$, where $N$ is the grid size and $ε$ is the error, for the discrete Charlier, Meixner and Krawtchouk transforms and for the integer-order Laguerre transform in the continuous setting. The efficient QOPTs are obtained by uncovering the links between Askey scheme polynomials and Gaussian quantum optical gates and developing a compilation framework for $SU(2)$ and $SU(1,1)$ optical gates on Cartesian grids extending the framework developed by Iyer et al. (arXiv:2602.15180). Further, we reduce the continuous Jacobi transform to the discrete Hahn transform and provide an $O\!\left(N\operatorname{polylog}((N+α+β+1)/ε)\right)$-time Hahn transform, a quadratic speedup over the naive implementation. This is based on a more efficient compilation of the Clebsch--Gordan transform for coupling $\mathrm{SU}(2)$ representations with spins $(j_{1}, j_{2})$. Finally, we develop a new framework for Laguerre transforms for all orders $ν>0$ by fast-forwarding the corresponding radial oscillator using a 3-term chirp decomposition and an efficient algorithm for the Quantum Hankel Transform on a logarithmic grid.

Abstract: PQLS (Parallel Quantum Liouvillian Solver) is a high-performance Python library for computing steady-state solutions of the Lindblad master equation. It provides a layered user-facing API with three levels of abstraction. The high-level API accepts physical descriptions of atomic ladder systems and automatically determines the required model parameters; the mid- level API accepts quantities such as Rabi frequencies, detunings, decay rates, and network topology; finally the low-level API allows users to directly specify the Hamiltonian and collapse operators. This layered design enables users to choose between physical convenience and direct numerical control depending on the application. PQLS is built on JAX and XLA to enable vectorized and hardware-accelerated computation of large parameter sweeps. Rather than solving the steady-state problem sequentially for each parameter configuration, PQLS represents multiple Hamiltonians as batched tensors and processes them through a JAX-compiled solver, reducing Python-level overhead and improving hardware utilization. This is particularly useful for applications requiring large or multidimensional parameter sweeps, such as computing frequency spectra, evaluating field-dependent responses, and performing Doppler averaging over atomic velocity distributions. PQLS has been benchmarked against QuTiP, QuTiP-JAX, and RydIQule on CPU and GPU platforms, demonstrating substantial computational speedups across the tested configurations.