Small fixes for InfiniteSquareNetwork and InfinitePartitionFunction (#306)

* Fix `TensorKit.spacetype` and `TensorKit.sectortype` for `InfiniteSquareNetwork`

* Fix random `InfinitePartitionFunction` constructor

* Set up test stubs for types and add some coverage already

* Add a few more small tests

* Fix typo

Author: leburgel

.github/workflows/Tests.yml

@@ -26,6 +26,7 @@ jobs:
           - 'lts' # minimal supported version
           - '1'
         group:
+          - types
           - ctmrg
           - boundarymps
           - gradients

src/networks/infinitesquarenetwork.jl

@@ -55,6 +55,7 @@ end
 
 ## Spaces
 
+TensorKit.spacetype(::Type{T}) where {T <: InfiniteSquareNetwork} = spacetype(eltype(T))
 function virtualspace(n::InfiniteSquareNetwork, r::Int, c::Int, dir)
     Nr, Nc = size(n)
     return virtualspace(n[mod1(r, Nr), mod1(c, Nc)], dir)
@@ -98,7 +99,7 @@ function Base.:(==)(A₁::InfiniteSquareNetwork, A₂::InfiniteSquareNetwork)
 end
 function Base.isapprox(A₁::InfiniteSquareNetwork, A₂::InfiniteSquareNetwork; kwargs...)
     return all(zip(unitcell(A₁), unitcell(A₂))) do (p₁, p₂)
-        return isapprox(p₁, p₂; kwargs...)
+        return _isapprox_localsandwich(p₁, p₂; kwargs...)
     end
 end
 

src/networks/local_sandwich.jl

@@ -31,6 +31,7 @@ _rot180_localsandwich(O) = rot180.(O)
 _add_localsandwich(O1, O2) = O1 .+ O2
 _subtract_localsandwich(O1, O2) = O1 .- O2
 _mul_localsandwich(α::Number, O) = α .* O
+_isapprox_localsandwich(O1, O2; kwargs...) = all(isapprox.(O1, O2; kwargs...))
 
 ## PartitionFunction
 
@@ -43,6 +44,7 @@ _rot180_localsandwich(O::PFTensor) = rot180(O)
 _add_localsandwich(O1::PFTensor, O2::PFTensor) = O1 + O2
 _subtract_localsandwich(O1::PFTensor, O2::PFTensor) = O1 - O2
 _mul_localsandwich(α::Number, O::PFTensor) = α * O
+_isapprox_localsandwich(O1::PFTensor, O2::PFTensor; kwargs...) = isapprox(O1, O2; kwargs...)
 
 ## PEPS
 
@@ -55,6 +57,8 @@ function virtualspace(O::PEPSSandwich, dir)
     return virtualspace(ket(O), dir) ⊗ virtualspace(bra(O), dir)'
 end
 
+TensorKit.spacetype(::Type{P}) where {P <: PEPSSandwich} = spacetype(eltype(P))
+
 # not overloading MPOTensor because that defines AbstractTensorMap{<:Any,S,2,2}(::PEPSTensor, ::PEPSTensor)
 # ie type piracy
 mpotensor(top::PEPSTensor) = mpotensor((top, top))
@@ -106,3 +110,5 @@ function virtualspace(O::PEPOSandwich, dir)
         ]
     )
 end
+
+TensorKit.spacetype(::Type{P}) where {P <: PEPOSandwich} = spacetype(eltype(P))

src/networks/tensors.jl

@@ -22,6 +22,20 @@ and west spaces, respectively.
 const PartitionFunctionTensor{S <: ElementarySpace} = AbstractTensorMap{<:Any, S, 2, 2}
 const PFTensor = PartitionFunctionTensor
 
+"""
+    PartitionFunctionTensor(f, ::Type{T}, Pspace::S, Nspace::S,
+               [Espace::S], [Sspace::S], [Wspace::S]) where {T,S<:Union{Int,ElementarySpace}}
+                
+Construct a PartitionFunctionTensor tensor based on the north, east, west and south spaces.
+The tensor elements are generated based on `f` and the element type is specified in `T`.
+"""
+function PartitionFunctionTensor(
+        f, ::Type{T},
+        Nspace::S, Espace::S = Nspace, Sspace::S = Nspace, Wspace::S = Espace,
+    ) where {T, S <: ElementarySpace}
+    return f(T, Wspace ⊗ Sspace ← Nspace ⊗ Espace)
+end
+
 Base.rotl90(t::PFTensor) = permute(t, ((3, 1), (4, 2)))
 Base.rotr90(t::PFTensor) = permute(t, ((2, 4), (1, 3)))
 Base.rot180(t::PFTensor) = permute(t, ((4, 3), (2, 1)))

src/states/infinitepartitionfunction.jl

@@ -55,10 +55,10 @@ function InfinitePartitionFunction(
     size(Nspaces) == size(Espaces) ||
         throw(ArgumentError("Input spaces should have equal sizes."))
 
-    Sspaces = adjoint.(circshift(Nspaces, (-1, 0)))
-    Wspaces = adjoint.(circshift(Espaces, (0, 1)))
+    Sspaces = circshift(Nspaces, (-1, 0))
+    Wspaces = circshift(Espaces, (0, 1))
 
-    A = map(Nspaces, Espaces, Sspaces, Wspaces) do P, N, E, S, W
+    A = map(Nspaces, Espaces, Sspaces, Wspaces) do N, E, S, W
         return PartitionFunctionTensor(f, T, N, E, S, W)
     end
 

test/runtests.jl

@@ -10,6 +10,20 @@ else
 end
 
 @time begin
+    if GROUP == "ALL" || GROUP == "TYPES"
+        @time @safetestset "InfiniteSquareNetwork" begin
+            include("types/infinitesquarenetwork.jl")
+        end
+        @time @safetestset "InfinitePartitionFunction" begin
+            include("types/infinitepartitionfunction.jl")
+        end
+        @time @safetestset "SUWeight" begin
+            include("types/suweight.jl")
+        end
+        @time @safetestset "LocalOperator" begin
+            include("types/localoperator.jl")
+        end
+    end
     if GROUP == "ALL" || GROUP == "CTMRG"
         @time @safetestset "Gauge Fixing" begin
             include("ctmrg/gaugefix.jl")
@@ -77,9 +91,6 @@ end
         end
     end
     if GROUP == "ALL" || GROUP == "UTILITY"
-        @time @safetestset "LocalOperator" begin
-            include("utility/localoperator.jl")
-        end
         @time @safetestset "SVD wrapper" begin
             include("utility/svd_wrapper.jl")
         end
@@ -92,9 +103,6 @@ end
         @time @safetestset "Norm-preserving retractions" begin
             include("utility/retractions.jl")
         end
-        @time @safetestset "Rotation of SUWeight" begin
-            include("utility/suweight_rotation.jl")
-        end
         @time @safetestset "Correlators" begin
             include("utility/correlator.jl")
         end

test/types/infinitepartitionfunction.jl

@@ -0,0 +1,27 @@
+using Test
+using TensorKit
+using PEPSKit
+using PEPSKit: PFTensor
+
+T = ComplexF64
+Ss = [Trivial, U1Irrep]
+Vs = [ComplexSpace(3), U1Space(0 => 2, -1 => 1, 1 => 1)]
+
+sizes = [(1, 1), (3, 3)]
+
+@testset "$(sz) InfinitePartitionFunction with $(Ss[i]) symmetry" for (i, sz) in
+    Iterators.product(eachindex(Ss), sizes)
+
+    S = Ss[i]
+    V = Vs[i]
+
+    pf = InfinitePartitionFunction(randn, T, V; unitcell = sz)
+
+    @test scalartype(pf) == T
+    @test eltype(pf) <: PFTensor{typeof(V)}
+    @test spacetype(pf) == typeof(V)
+
+    @test (rotl90 ∘ rotl90)(pf) ≈ rot180(pf)
+    @test (rotr90 ∘ rotr90 ∘ rotr90)(pf) ≈ rotl90(pf)
+    @test length(pf) == prod(sz)
+end

test/types/infinitesquarenetwork.jl

@@ -0,0 +1,55 @@
+using Test
+using TensorKit
+using PEPSKit
+using PEPSKit: PEPSTensor, PFTensor, PEPSSandwich, PEPOSandwich
+
+T = ComplexF64
+Ss = [Trivial, U1Irrep]
+Ps = [ComplexSpace(2), U1Space(0 => 1, 1 => 1)]
+Vs = [ComplexSpace(3), U1Space(0 => 2, -1 => 1, 1 => 1)]
+
+sizes = [(1, 1), (3, 3)]
+
+@testset "$(sz) InfiniteSquareNetwork with $(Ss[i]) symmetry" for (i, sz) in
+    Iterators.product(eachindex(Ss), sizes)
+
+    S = Ss[i]
+    P = Ps[i]
+    V = Vs[i]
+
+    peps_tensor = PEPSTensor(randn, T, P, V)
+    pf_tensor = PFTensor(randn, T, V)
+    pepo_tensor = randn(T, P ⊗ P' ← V ⊗ V ⊗ V' ⊗ V')
+
+    peps = InfinitePEPS(peps_tensor; unitcell = sz)
+    pf = InfinitePartitionFunction(pf_tensor; unitcell = sz)
+    pepo = InfinitePEPO(pepo_tensor; unitcell = (sz..., 2))
+
+    peps_n = InfiniteSquareNetwork(peps)
+    pf_n = InfiniteSquareNetwork(pf)
+    pepo_n = InfiniteSquareNetwork(peps, pepo)
+
+    @test scalartype(peps_n) == T
+    @test eltype(peps_n) == PEPSSandwich{typeof(peps_tensor)}
+    @test spacetype(peps_n) == typeof(P)
+    @test sectortype(peps_n) == S
+
+    @test scalartype(pf_n) == T
+    @test eltype(pf_n) == typeof(pf_tensor)
+    @test spacetype(pf_n) == typeof(V)
+    @test sectortype(pf_n) == S
+
+    @test scalartype(pepo_n) == T
+    @test eltype(pepo_n) == PEPOSandwich{2, typeof(peps_tensor), typeof(pepo_tensor)}
+    @test spacetype(pepo_n) == typeof(P)
+    @test sectortype(pepo_n) == S
+
+    @test peps_n + peps_n ≈ 2 * peps_n
+    @test repeat(InfiniteSquareNetwork(InfinitePEPS(peps_tensor)), sz...) == peps_n
+    @test (rotl90 ∘ rotl90)(peps_n) ≈ rot180(peps_n)
+
+    @test pf_n + pf_n ≈ 2 * pf_n
+    @test (rotr90 ∘ rotr90)(pf_n) ≈ rot180(pf_n)
+
+    @test length(peps_n) == prod(sz)
+end