Quantum 1+1D Ising chain (#189)

* Quantum 1+1D Ising chain

* Fix variable name

* Docs on quantum partition function construction

* Improve docs

* Mention translation symmetry in docs [skip ci]

* Rename to `quantum_ising_chain` [skip ci]

---------

Co-authored-by: Victor Vanthilt <73738005+VictorVanthilt@users.noreply.github.com>

Author: Yue-Zhengyuan

Project.toml

@@ -20,6 +20,7 @@ SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3"
 TensorKit = "07d1fe3e-3e46-537d-9eac-e9e13d0d4cec"
 TensorKitSectors = "13a9c161-d5da-41f0-bcbd-e1a08ae0647f"
+TensorKitTensors = "41b62e7d-e9d1-4e23-942c-79a97adf954b"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [compat]
@@ -37,6 +38,7 @@ SpecialFunctions = "2.6.1"
 StableRNGs = "1.0.4"
 TensorKit = "0.16.2"
 TensorKitSectors = "0.3.7"
+TensorKitTensors = "0.2.5"
 Zygote = "0.7.7"
 julia = "1.11"
 

docs/make.jl

@@ -10,6 +10,7 @@ makedocs(;
     pages = [
         "Home" => "index.md"
         "Library" => "lib/lib.md"
+        "Quantum 1+1D" => "quantum_1D.md"
         "CFT Data" => "cft.md"
         "Finalizers" => "finalizers.md"
         "References" => "references.md"

docs/src/quantum_1D.md

@@ -0,0 +1,49 @@
+# 1+1D Quantum Models
+
+TNRKit provides tools to construct partition function tensors for $(1+1)$-dimensional quantum lattice models with translation symmetry (currently only nearest-neighbor Hamiltonians are supported). These tensors can then be studied with any of the 2D tensor network renormalization schemes (TRG, HOTRG, LoopTNR, etc.).
+
+## Quantum Partition Functions
+
+A $(1+1)$D quantum system at inverse temperature $\beta$ has partition function
+
+```math
+\mathcal{Z} = \mathrm{Tr}\, e^{-\beta H}
+```
+
+where $H$ is the Hamiltonian. By discretizing the imaginary-time direction into $N$ steps of size $\delta\tau = \beta / N$ and applying a Trotter–Suzuki decomposition, the partition function becomes a contraction of a 2D tensor network. Each time step is represented by a Trotter gate acting on nearest-neighbor pairs.
+
+## Tensor Network Representation of $\mathcal{Z}$
+
+When $H = \sum_i h_{i,i+1}$, where $h_{i,i+1} = h$ (due to translation symmetry) is a nearest-neighbor term, the Trotter gate network naturally forms a square lattice. Each Trotter gate $g = \exp(-\delta\tau \, h)$ connects two spatial sites (horizontal direction in the gate diagram) and advances by one imaginary-time step $\delta\tau$ (vertical direction in the gate diagram). However, the gate network is **rotated by 45 degrees** relative to the standard upright orientation.
+
+`gate_to_tensor` transforms the rotated gate network into an **upright** square tensor network. The resulting tensor $T$ is the elementary cell of this upright network, and follows the standard TNRKit leg convention:
+
+```
+    3
+    ↓
+1 ← T ← 4
+    ↓
+    2
+```
+
+The horizontal direction (legs 1 ↔ 4) corresponds to the spatial dimension of the quantum chain, and the vertical direction (legs 2 ↔ 3) corresponds to imaginary time. The imaginary-time step represented by one $T$ tensor is the **same** $\delta\tau$ as one Trotter gate — the transformation does not coarse-grain in time. In the spatial direction, however, the transformation does renormalize: each $T$ represents **two** original lattice sites.
+
+## Vertical Stacking
+
+To build up the imaginary-time direction, multiple copies of $T$ are stacked vertically. As the stack grows, the bond dimension in the spatial direction would grow exponentially if left unchecked. TNRKit provides two stacking strategies that use HOTRG-style compression to keep the bond dimension under control.
+
+- `vertical_stack_exp` stacks $2^{\text{nfold}}$ copies of $T$ by repeatedly doubling the current stack. Each iteration takes the current stack (representing $2^k$ Trotter steps) and compresses it on top of itself, yielding a stack of $2^{k+1}$ steps. After `nfold` iterations, the result represents $2^{\text{nfold}}$ Trotter steps. This is expected to be the more accurate approach, since only $m$ iterations are needed to reach $2^m$ steps.
+
+- `vertical_stack_linear` stacks exactly $n$ copies of $T$ linearly (as opposed to a power of 2). Each iteration adds one more copy of the original tensor $T$ on top of the current stack. This is useful when you need a specific number of Trotter steps rather than a power of 2.
+
+## Implementing Custom Quantum Models
+
+To construct the partition function of a custom $(1+1)$D quantum Hamiltonian with nearest-neighbor interactions, follow this recipe:
+
+1. **Construct the Trotter gate**: Build a 4-leg tensor representing $\exp(-\delta\tau \, h_{i,i+1})$ where $h_{i,i+1}$ is the nearest-neighbor Hamiltonian term. The gate should live in $V \otimes V \leftarrow V \otimes V$, where $V$ is the local Hilbert space.
+
+2. **Convert to partition function tensor**: Call `gate_to_tensor(gate; trunc=...)` to obtain the elementary tensor $T$.
+
+3. **Stack in the time direction**: Use `vertical_stack_exp` or `vertical_stack_linear` to build up the desired number of Trotter steps.
+
+Now you are ready to feed the resulting 2D tensor network into any of TNRKit's 2D schemes (TRG, HOTRG, LoopTNR, etc.).

src/TNRKit.jl

@@ -14,6 +14,7 @@ using Roots
 using NonlinearSolve
 using Base.Threads
 using Combinatorics: permutations
+import TensorKitTensors.SpinOperators as SO
 
 # stop criteria
 include("utility/stopping.jl")
@@ -122,6 +123,10 @@ export phi4_real, phi4_real_imp1, phi4_real_imp2
 include("models/phi4_complex.jl")
 export phi4_complex, phi4_complex_impϕ, phi4_complex_impϕdag, phi4_complex_impϕabs, phi4_complex_impϕ2, phi4_complex_all
 
+include("models/quantum_1D.jl")
+export gate_to_tensor, vertical_stack_exp, vertical_stack_linear
+export quantum_ising_chain
+
 # utility functions
 include("utility/free_energy.jl")
 export free_energy

src/models/quantum_1D.jl

@@ -0,0 +1,97 @@
+"""
+Construct partition function tensor from nearest neighbor
+Trotter gate of (1 + 1)D quantum models with translation symmetry.
+```
+                                                2       3
+                                                  ↘   ↙
+                                                    S4
+    3      4        2                  3            ↓
+      ↘︎  ↙︎            ↘              ↙              1
+      gate      =      S1 ← 3   1 ← S3     or
+      ↙︎  ↘︎            ↙              ↘              3
+    1      2        1                  2            ↓
+                                                    S2
+                                                  ↙   ↘
+                                                1       2
+```
+The partition function tensor is
+```
+                3'
+                ↓
+                S2
+              ↙   ↘
+            b       c                   3'
+          ↙           ↘                 ↓
+    1'← S3            S1 ← 4' --->  1'← T ← 4'
+          ↘           ↙                 ↓
+            a       d                   2'
+              ↘   ↙
+                S4
+                ↓
+                2'
+```
+"""
+function gate_to_tensor(
+        gate::AbstractTensorMap{E, S, 2, 2}; trunc = truncerror(; rtol = 1.0e-8)
+    ) where {E, S}
+    s1, s3 = SVD12(permute(gate, ((1, 3), (2, 4))), trunc)
+    s2, s4 = SVD12(gate, trunc)
+    @tensor T[-1 -2; -3 -4] := s3[-1 a b] * s4[-2 a d] * s2[b c -3] * s1[d c -4]
+    return T
+end
+
+"""
+Exponentially stack `2^nfold` copies of `T` in vertical direction using HOTRG.
+"""
+function vertical_stack_exp(
+        T::AbstractTensorMap{E, S, 2, 2}, nfold::Integer, trunc::TruncationStrategy
+    ) where {E, S}
+    @assert nfold >= 1
+    T2 = copy(T)
+    for _ in 1:nfold
+        Ux, = _get_hotrg_xproj(T2, T2, trunc)
+        T2 = _step_hotrg_y(T2, T2, Ux)
+    end
+    return T2
+end
+
+"""
+Linearly stack `n` copies of `T` in vertical direction using HOTRG.
+"""
+function vertical_stack_linear(
+        T::AbstractTensorMap{E, S, 2, 2}, n::Integer, trunc::TruncationStrategy
+    ) where {E, S}
+    @assert n >= 1
+    T2 = copy(T)
+    for _ in 1:(n - 1)
+        Ux, = _get_hotrg_xproj(T, T2, trunc)
+        T2 = _step_hotrg_y(T, T2, Ux)
+    end
+    return T2
+end
+
+# Nearest neighbor (1+1)D quantum Hamiltonian gates
+# =================================================
+
+"""
+Partition function tensor for 1D transverse field Ising chain
+```
+    H(PBC) = -J ∑_i (σz_i σz_{i+1} + g σx_i)
+```
+Allowed `symm`: Trivial, Z2Irrep.
+"""
+function quantum_ising_chain(
+        elt::Type{<:Number}, symm::Type{<:Sector}, dt::Float64;
+        J::Float64 = 1.0, g::Float64 = 0.0
+    )
+    ZZ = 4 * SO.S_z_S_z(elt, symm)
+    X = SO.σˣ(elt, symm)
+    unit = TensorKit.id(codomain(X))
+    gate = ZZ + (g / 2) * (X ⊗ unit + unit ⊗ X)
+    gate = exp(dt * J * gate)
+    return gate_to_tensor(gate)
+end
+quantum_ising_chain(elt::Type{<:Number}, dt::Float64; kwargs...) =
+    quantum_ising_chain(elt, Trivial, dt; kwargs...)
+quantum_ising_chain(symm::Type{<:Sector}, dt::Float64; kwargs...) =
+    quantum_ising_chain(ComplexF64, symm, dt; kwargs...)

test/models/models.jl

@@ -175,3 +175,25 @@ end
     order_para = data[end][4] / data[end][1]
     @test order_para ≈ 0.0 atol = 1.0e-3
 end
+
+# (1 + 1)D quantum chains
+@testset "Quantum Ising chain: $stack_alg stacking" for stack_alg in (:exponential, :linear)
+    trunc_stack = truncerror(; rtol = 1.0e-9) & truncrank(16)
+    if stack_alg == :exponential
+        nfold = 7
+        dt = 1 / (2^nfold)
+        T = quantum_ising_chain(Float64, Z2Irrep, dt; J = 1.0, g = 1.0)
+        T = vertical_stack_exp(T, nfold, trunc_stack)
+    else
+        n = 100
+        dt = 1 / n
+        T = quantum_ising_chain(Float64, Z2Irrep, dt; J = 1.0, g = 1.0)
+        T = vertical_stack_linear(T, n, trunc_stack)
+    end
+    scheme = LoopTNR(T)
+    data = run!(scheme, truncrank(16), maxiter(16))
+    cft = CFTData(scheme)
+    central_charge = cft.central_charge
+    @test central_charge ≈ 0.5 atol = 1.0e-2
+    @info "Obtained central charge:\n$central_charge."
+end