Merge branch 'main' of github.com:Qiaoyi-Li/FiniteMPS.jl

Author: qyli

src/IntrTree/IntrIterator.jl

@@ -1,13 +1,13 @@
-""" 
-     abstract type AbstractInteractionIterator{L} 
-The abstract type for the iterator of interaction terms. All the concrete subtypes should implement the `iterate` method so that the following usages are both valid where 
+"""
+     abstract type AbstractInteractionIterator{L}
+The abstract type for the iterator of interaction terms. All the concrete subtypes should implement the `iterate` method so that the following usages are both valid where
 `Ops` is an instance of `AbstractInteractionIterator`.
 ```julia
 for O in Ops
      # the i-th loop will give the i-th LocalOperator
 end
 
-collect(Ops) # return the vector of all LocalOperators 
+collect(Ops) # return the vector of all LocalOperators
 ```
 """
 abstract type AbstractInteractionIterator{L} end
@@ -21,14 +21,14 @@ length(::AbstractInteractionIterator{L}) where L = L
           Op::AbstractLocalOperator
           Z::T
      end
-     
+
 The iterator for on-site terms such as bosonic `n_i` or fermionic `c_i` together with its Jordan-Wigner string`Z_{i+1} Z_{i+2} ... Z_{L}`.
 
 # Fields
      Op::AbstractLocalOperator
 The local operator which tells both the operator and its site index.
 
-     Z::Nothing 
+     Z::Nothing
 For bosonic operators.
      Z::AbstractTensorMap
 For fermionic operators. Assume all sites are fermionic therefore each site after `Op` will give `Z` operator.
@@ -44,7 +44,7 @@ Direct constructor.
           si::Int64;
           swap::Bool=false,
           Z=nothing)
-Generate the `LocalOperator` object with `Op`, `name`, `si` and kwarg `swap`, details please see the constructors of `LocalOperator`. 
+Generate the `LocalOperator` object with `Op`, `name`, `si` and kwarg `swap`, details please see the constructors of `LocalOperator`.
 """
 struct OnSiteInteractionIterator{L, T} <: AbstractInteractionIterator{L}
      Op::AbstractLocalOperator
@@ -66,7 +66,7 @@ struct OnSiteInteractionIterator{L, T} <: AbstractInteractionIterator{L}
           return OnSiteInteractionIterator{L}(LocalOperator(Op, name, si, !isnothing(Z); swap=swap), Z)
      end
 end
-function iterate(iter::OnSiteInteractionIterator{L, Nothing}, i::Int64 = 1) where {L} 
+function iterate(iter::OnSiteInteractionIterator{L, Nothing}, i::Int64 = 1) where {L}
      i > L && return nothing
      if i == iter.Op.si
           Op_wrap = iter.Op
@@ -76,7 +76,7 @@ function iterate(iter::OnSiteInteractionIterator{L, Nothing}, i::Int64 = 1) wher
      end
      return Op_wrap, i + 1
 end
-function iterate(iter::OnSiteInteractionIterator{L, <:AbstractTensorMap}, i::Int64 = 1) where {L} 
+function iterate(iter::OnSiteInteractionIterator{L, <:AbstractTensorMap}, i::Int64 = 1) where {L}
      i > L && return nothing
      if i == iter.Op.si
           Op_wrap = iter.Op
@@ -111,7 +111,7 @@ end
      end
 
 The iterator for two-site terms such as bosonic `n_i n_j` or fermionic `c_i c_j` together with its Jordan-Wigner string `Z_{i+1} Z_{i+2} ... Z_{j}`.
-     
+
 Note the two site indices can be in both ascending and descending order but should not be the same. For the latter case, please use `OnSiteInteractionIterator` to get an on-site term instead.
 
 # Fields
@@ -123,7 +123,7 @@ The local operators.
 For bosonic operators.
      Z::AbstractTensorMap
 For fermionic operators. Note we assume both `O₁` and `O₂` are fermionic operators if `Z ≠ nothing`. 
-     Z::AbstractVector
+     Z::AbstractVector{<:AbstractTensorMap}
 Directly give the `Z` operator for each site to deal with the systems mixed with bosons and fermions.
 
 # Constructors
@@ -135,7 +135,7 @@ Direct constructor.
           si::NTuple{2, Int64};
           convertRight::Bool=false,
           Z=nothing)
-Generate the `LocalOperator` objects with 2-tuples `Op`, `name` and `si`. If `convertRight == true`, convert the the second operator (with larger site index, can be `O₁` or `O₂`) to a right one (i.e. only have left horizontal leg), which is used to uniquely determine the contraction when calculating ITP. 
+Generate the `LocalOperator` objects with 2-tuples `Op`, `name` and `si`. If `convertRight == true`, convert the the second operator (with larger site index, can be `O₁` or `O₂`) to a right one (i.e. only have left horizontal leg), which is used to uniquely determine the contraction when calculating ITP.
 """
 struct TwoSiteInteractionIterator{L, T} <: AbstractInteractionIterator{L}
      O₁::AbstractLocalOperator
@@ -157,7 +157,7 @@ struct TwoSiteInteractionIterator{L, T} <: AbstractInteractionIterator{L}
           Z=nothing
           ) where {L}
           @assert 1 ≤ si[1] ≤ L && 1 ≤ si[2] ≤ L && si[1] ≠ si[2]
-          
+
           Zflag = !isnothing(Z)
 
           O₁ = LocalOperator(Op[1], name[1], si[1], Zflag)
@@ -175,28 +175,28 @@ struct TwoSiteInteractionIterator{L, T} <: AbstractInteractionIterator{L}
           return TwoSiteInteractionIterator{L}(O₁, O₂, Z)
      end
 end
-function iterate(iter::TwoSiteInteractionIterator{L, Nothing}, st::Tuple{Int64, VectorSpace} = (1, getLeftSpace(iter.O₁))) where {L} 
+function iterate(iter::TwoSiteInteractionIterator{L, Nothing}, st::Tuple{Int64, VectorSpace} = (1, getLeftSpace(iter.O₁))) where {L}
      i, aspace = st
      i > L && return nothing
      if i == iter.O₁.si
           Op_wrap = iter.O₁
      elseif i == iter.O₂.si
           Op_wrap = iter.O₂
      else
-          # deduce pspace 
+          # deduce pspace
           pspace = domain(iter.O₁)[1]
           Op_wrap = IdentityOperator(pspace, aspace, i)
      end
      return Op_wrap, (i + 1, getRightSpace(Op_wrap))
 end
-function iterate(iter::TwoSiteInteractionIterator{L, <:AbstractTensorMap}, st::Tuple{Int64, VectorSpace} = (1, getLeftSpace(iter.O₁))) where {L} 
+function iterate(iter::TwoSiteInteractionIterator{L, <:AbstractTensorMap}, st::Tuple{Int64, VectorSpace} = (1, getLeftSpace(iter.O₁))) where {L}
      i, aspace = st
      i > L && return nothing
      if i == iter.O₁.si
           Op_wrap = iter.O₁
      elseif i == iter.O₂.si
-          # add Z here 
-          Op_wrap = _addZ!(iter.O₂, iter.Z) 
+          # add Z here
+          Op_wrap = _addZ!(iter.O₂, iter.Z)
      elseif i > iter.O₁.si && i < iter.O₂.si
           Op_wrap = LocalOperator(iter.Z, :Z, i, false; aspace = (aspace, aspace))
      else
@@ -233,21 +233,21 @@ end
           pspace::Union{Nothing, VectorSpace, Vector{<:VectorSpace}}
      end
 
-The iterator for an arbitrary interaction term. 
+The iterator for an arbitrary interaction term.
 
 # Fields
      Ops::Vector{<:AbstractLocalOperator}
 A vector to store the local operators, `length(Ops) == N` means a `N`-site interaction term.
 
      Z::Union{Nothing, AbstractTensorMap, AbstractVector}
      pspace::Union{Nothing, VectorSpace, Vector{<:VectorSpace}}
-Provide the fermion parity operator `Z` and the local physical space `pspace`. Assume a site-independent `Z` or `pspace` if a single object is provided, otherwise, a length-`L` vector is expected to deal with the site-dependent cases.  
+Provide the fermion parity operator `Z` and the local physical space `pspace`. Assume a site-independent `Z` or `pspace` if a single object is provided, otherwise, a length-`L` vector is expected to deal with the site-dependent cases.
 
 # Constructors
      ArbitraryInteractionIterator{L}(Ops::Vector{<:AbstractLocalOperator},
           Z::Union{Nothing, AbstractTensorMap, AbstractVector},
           pspace::Union{Nothing, VectorSpace, Vector{<:VectorSpace}} = nothing)
-The direct constructor. 
+The direct constructor.
 """
 struct ArbitraryInteractionIterator{L} <: AbstractInteractionIterator{L}
      Ops::Vector{<:AbstractLocalOperator}
@@ -266,18 +266,18 @@ function iterate(iter::ArbitraryInteractionIterator{L}, st::Tuple{Int64, Int64,
           end
      else
           Op_i = deepcopy(iter.Ops[idx])
-          # add Z if necessary 
+          # add Z if necessary
           flag && _addZ!(Op_i, _getZ(iter.Z, i))
           return Op_i, (i + 1, idx + 1, xor(flag, isfermionic(Op_i)), getRightSpace(Op_i))
      end
 end
 
 _getZ(::Nothing, ::Int64) = nothing
 _getZ(Z::AbstractTensorMap, ::Int64) = Z
-_getZ(Z::Vector, i::Int64) = Z[i]
+_getZ(Z::Vector{<:AbstractTensorMap}, i::Int64) = Z[i]
 _getpspace(::Nothing, ::Int64) = nothing
 _getpspace(pspace::VectorSpace, ::Int64) = pspace
-_getpspace(pspace::AbstractVector{<:VectorSpace}, i::Int64) = pspace[i]
+_getpspace(pspace::Vector{<:VectorSpace}, i::Int64) = pspace[i]
 
 _addZ!(O::LocalOperator, ::Nothing) = O
 function _addZ!(OR::LocalOperator{1, 1}, Z::AbstractTensorMap)
@@ -318,4 +318,3 @@ function _addZ!(OR::LocalOperator{2, 2}, Z::AbstractTensorMap)
 	end
 	return OR
 end
-

src/LocalSpace/Spin.jl

@@ -77,6 +77,19 @@ const S₋₊ = let
      S₋, S₊
 end
 
+const S₊₊₋₋ = let
+    A = S₊₋[1]
+    B = S₊₋[1]
+    aspace_A = Rep[U₁](1 => 1)
+    aspace_B = Rep[U₁](1 => 1)
+    aspace2 = Rep[U₁](2 => 1)
+    iso = isometry(aspace_A ⊗ aspace_B, aspace2)
+    @tensor B[d a; b e] := B[a b c] * iso[d c e]
+    C = permute(B', ((2, 1), (4, 3)))
+    D = permute(A', ((2, 1), (3,)))
+    A, B, C, D
+end
+
 end
 
 const U1Spin = U₁Spin