module TensorKit

export Sector, AbstractIrrep, Irrep, GroupElement

export FusionStyle, UniqueFusion, MultipleFusion, MultiplicityFreeFusion, SimpleFusion, GenericFusion

export UnitStyle, SimpleUnit, GenericUnit

export BraidingStyle, SymmetricBraiding, Bosonic, Fermionic, Anyonic, NoBraiding, HasBraiding

export Trivial, Z2Irrep, Z3Irrep, Z4Irrep, ZNIrrep, LargeZNIrrep

export ZNElement, Z2Element, Z3Element, Z4Element, DNIrrep, A4Irrep, U1Irrep, SU2Irrep, CU1Irrep

export ProductSector, NamedSector, @NamedSector, TimeReversed

export FermionParity, FermionNumber, FermionSpin

export FibonacciAnyon, IsingAnyon, IsingBimodule

export VectorSpace, Field, ElementarySpace # abstract vector spaces

export InnerProductStyle, NoInnerProduct, HasInnerProduct, EuclideanInnerProduct

export ComplexSpace, CartesianSpace, GeneralSpace, GradedSpace # concrete spaces

export ZNSpace, Z2Space, Z3Space, Z4Space, U1Space, CU1Space, SU2Space

export Vect, Rep # space constructors

export CompositeSpace, ProductSpace # composite spaces

export FusionTree

export IndexSpace, HomSpace, TensorSpace, TensorMapSpace

export AbstractTensorMap, AbstractTensor, TensorMap, Tensor # tensors and tensor properties

export DiagonalTensorMap, BraidingTensor

export SpaceMismatch, SectorMismatch, IndexError # error types

export space, field, dual, dim, reduceddim, dims, fuse, flip, isdual

export unitspace, zerospace, oplus, ominus

export leftunitspace, rightunitspace, isunitspace

export insertleftunit, insertrightunit, removeunit

export infimum, supremum, isisomorphic, ismonomorphic, isepimorphic

export sectortype, sectors, hassector

export unit, rightunit, leftunit, allunits, isunit, otimes, deligneproduct, timereversed

export Nsymbol, Fsymbol, Rsymbol, Bsymbol, frobenius_schur_phase, frobenius_schur_indicator, twist, fusiontensor

export sectorscalartype, fusionscalartype, braidingscalartype, dimscalartype

export fusiontrees, braid, permute, transpose

export ⊕, ⊗, ⊖, ×, ⊠, ℂ, ℝ, ℤ, ←, →, ≾, ≿, ≅, ≺, ≻

export ℤ₂, ℤ₃, ℤ₄, D₃, D₄, A₄, U₁, SU, SU₂, CU₁

export fℤ₂, fU₁, fSU₂

export ℤ₂Space, ℤ₃Space, ℤ₄Space, U₁Space, CU₁Space, SU₂Space

export domain, codomain, numind, numout, numin, domainind, codomainind, allind

export spacetype, storagetype, scalartype, tensormaptype

export blocksectors, blockdim, block, blocks, subblocks, subblock

export randisometry, randisometry!, rand, rand!, randn, randn!

export zero, one, one!, id, id!, isomorphism, isomorphism!, unitary, unitary!, isometry,

isometry!

export zerovector, zerovector!, zerovector!!, scale, scale!, scale!!, add, add!, add!!

export inner, dot, norm, normalize, normalize!, tr

export mul!, lmul!, rmul!, adjoint!, pinv, axpy!, axpby!

export left_orth, right_orth, left_null, right_null,

left_orth!, right_orth!, left_null!, right_null!,

left_polar, left_polar!, right_polar, right_polar!,

qr_full, qr_compact, qr_null, lq_full, lq_compact, lq_null,

qr_full!, qr_compact!, qr_null!, lq_full!, lq_compact!, lq_null!,

svd_compact!, svd_full!, svd_trunc!, svd_compact, svd_full, svd_trunc, svd_vals, svd_vals!,

exp, exp!, exponential, exponential!,

eigh_full!, eigh_full, eigh_trunc!, eigh_trunc, eigh_vals!, eigh_vals,

eig_full!, eig_full, eig_trunc!, eig_trunc, eig_vals!, eig_vals,

eigen, eigen!,

ishermitian, project_hermitian, project_hermitian!,

isantihermitian, project_antihermitian, project_antihermitian!,

isisometric, isunitary, project_isometric, project_isometric!,

isposdef, isposdef!, sylvester, rank, cond

export braid, braid!, permute, permute!, transpose, transpose!, twist, twist!, repartition, repartition!

export catdomain, catcodomain, absorb, absorb!

export @tensor, @tensoropt, @ncon, ncon, @planar, @plansor

export scalar, add!, contract!

export notrunc, truncrank, trunctol, truncfilter, truncspace, truncerror

export empty_globalcaches!

using TupleTools

using Strided

using VectorInterface

using TensorOperations: TensorOperations, @tensor, @tensoropt, @ncon, ncon

using TensorOperations: IndexTuple, Index2Tuple, linearize, AbstractBackend

const TO = TensorOperations

using MatrixAlgebraKit

using Dictionaries: Dictionaries, Dictionary, Indices, gettoken, gettokenvalue

using LRUCache

using OhMyThreads

using ScopedValues

using TimerOutputs: TimerOutputs, TimerOutput, @timeit_debug

using TensorKitSectors

import TensorKitSectors: dim, BraidingStyle, FusionStyle, ⊠, ⊗, ×

import TensorKitSectors: dual, type_repr, fusiontensor

import TensorKitSectors: twist

using Base: @boundscheck, @propagate_inbounds, @constprop,

OneTo, tail, front,

tuple_type_head, tuple_type_tail, tuple_type_cons,

SizeUnknown, HasLength, HasShape, IsInfinite, EltypeUnknown, HasEltype

using Base.Iterators: product, filter

using Printf: @sprintf, @printf

using LinearAlgebra: LinearAlgebra, BlasFloat

using LinearAlgebra: norm, dot, normalize, normalize!, tr,

axpy!, axpby!, lmul!, rmul!, mul!, ldiv!, rdiv!,

adjoint, adjoint!, transpose, transpose!,

lu, pinv, sylvester,

eigen, eigen!, svd, svd!,

isposdef, isposdef!, rank, cond,

Diagonal, Hermitian

import Base.Meta

using Random: Random, rand!, randn!

using Adapt: Adapt

include("auxiliary/timers.jl")

include("auxiliary/auxiliary.jl")

include("auxiliary/caches.jl")

include("auxiliary/dicts.jl")

include("auxiliary/iterators.jl")

include("auxiliary/random.jl")

const SectorDict{K, V} = SortedVectorDict{K, V}

const FusionTreeDict{K, V} = Dict{K, V}

abstract type TensorException <: Exception end

struct SectorMismatch{S <: Union{Nothing, AbstractString}} <: TensorException

message::S

SectorMismatch() = SectorMismatch{Nothing}(nothing)

Base.showerror(io::IO, ::SectorMismatch{Nothing}) = print(io, "SectorMismatch()")

Base.showerror(io::IO, e::SectorMismatch) = print(io, "SectorMismatch(\"", e.message, "\")")

struct SpaceMismatch{S <: Union{Nothing, AbstractString}} <: TensorException

message::S

SpaceMismatch() = SpaceMismatch{Nothing}(nothing)

function Base.showerror(io::IO, err::SpaceMismatch)

print(io, "SpaceMismatch: ")

isnothing(err.message) || print(io, err.message)

return nothing

struct IndexError{S <: Union{Nothing, AbstractString}} <: TensorException

message::S

IndexError() = IndexError{Nothing}(nothing)

Base.showerror(io::IO, ::IndexError{Nothing}) = print(io, "IndexError()")

Base.showerror(io::IO, e::IndexError) = print(io, "IndexError(", e.message, ")")

include("fusiontrees/fusiontrees.jl")

include("spaces/vectorspaces.jl")

include("spaces/cartesianspace.jl")

include("spaces/complexspace.jl")

include("spaces/generalspace.jl")

include("spaces/gradedspace.jl")

include("spaces/planarspace.jl")

include("spaces/productspace.jl")

include("spaces/deligne.jl")

include("spaces/homspace.jl")

include("spaces/structure.jl")

const TRANSFORMER_THREADS = Ref(1)

get_num_transformer_threads() = timers_enabled() ? 1 : TRANSFORMER_THREADS[]

function set_num_transformer_threads(n::Int)

N = Base.Threads.nthreads()

if n > N

n = N

Strided._set_num_threads_warn(n)

end

return TRANSFORMER_THREADS[] = n

const TREEMANIPULATION_THREADS = Ref(1)

get_num_manipulation_threads() = timers_enabled() ? 1 : TREEMANIPULATION_THREADS[]

function set_num_manipulation_threads(n::Int)

N = Base.Threads.nthreads()

if n > N

n = N

Strided._set_num_threads_warn(n)

end

return TREEMANIPULATION_THREADS[] = n

include("tensors/abstracttensor.jl")

include("tensors/backends.jl")

include("tensors/blockiterators.jl")

include("tensors/sectorvector.jl")

include("tensors/tensor.jl")

include("tensors/adjoint.jl")

include("tensors/linalg.jl")

include("tensors/vectorinterface.jl")

include("tensors/tensoroperations.jl")

include("tensors/treetransformers.jl")

include("tensors/indexmanipulations.jl")

include("tensors/diagonal.jl")

include("tensors/braidingtensor.jl")

include("factorizations/factorizations.jl")

using .Factorizations

using Base.Meta: isexpr

include("planar/analyzers.jl")

include("planar/preprocessors.jl")

include("planar/postprocessors.jl")

include("planar/macros.jl")

include("planar/planaroperations.jl")

include("auxiliary/ad.jl")

include("pullbacks/tensoroperations.jl")

include("pullbacks/indexmanipulations.jl")

include("precompile/precompile.jl")