Theory of hypergraph categories

Hypergraph categories are also known as "well-supported compact closed categories" and "spidered/dungeon categories", among other things.

FIXME: Should also inherit ThClosedMonoidalCategory and ThDaggerCategory, but multiple inheritance is not yet supported.

ThHypergraphCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:178 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:180 =#
      (compose(mcopy(A), otimes(mcopy(A), id(A))) == compose(mcopy(A), otimes(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), braid(A, A)) == mcopy(A)) ⊣ [A::Ob]
      (mcopy(otimes(A, B)) == compose(otimes(mcopy(A), mcopy(B)), otimes(otimes(id(A), braid(A, B)), id(B)))) ⊣ [A::Ob, B::Ob]
      (delete(otimes(A, B)) == otimes(delete(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (mcopy(munit()) == id(munit())) ⊣ []
      (delete(munit()) == id(munit())) ⊣ []
      
      mmerge(A)::Hom(otimes(A, A), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:248 =#
      create(A)::Hom(munit(), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:250 =#
      
      dunit(A)::Hom(munit(), otimes(A, A)) ⊣ [A::Ob]
      dcounit(A)::Hom(otimes(A, A), munit()) ⊣ [A::Ob]
      dagger(f)::Hom(B, A) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (dunit(A) == compose(create(A), mcopy(A))) ⊣ [A::Ob]
      (dcounit(A) == compose(mmerge(A), delete(A))) ⊣ [A::Ob]
      (dagger(f) == compose(compose(otimes(id(B), dunit(A)), otimes(otimes(id(B), f), id(A))), otimes(dcounit(B), id(A)))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Theory of (strict) symmetric monoidal categories

ThSymmetricMonoidalCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]

Convert wiring diagrams to and from syntactic expressions.

Wiring diagrams are a graphical syntax for morphisms in a monoidal category. As mathematical objects, they are intermediate between the morphisms themselves and expressions in the textual syntax: a single morphism may correspond to many wiring diagrams, and a single wiring diagram may correspond to many syntactic expressions.

It is trivial to convert a morphism expression to a wiring diagram, but not to go the other way around.

Compose morphism expressions, eliminating identities.

Find one-sided parallel compositions in a directed graph.

Finds either input-sided or output-sided compositions. This weaker notion of parallel composition seems to be nonstandard.

Find parallel compositions in a directed graph.

This two-sided notion of parallel composition is standard in the literature on series-parallel digraphs.

Find series compositions in a directed graph.

Morphism expression for wires between two boxes.

Assumes that the wires form a permutation morphism.

Input-sided parallel reduction of a wiring diagram.

Because these reductions are not necessarily unique, only one is performed, the first one in topological sort order.

Convert a junction node to a morphism expression.

Output-sided parallel reduction of a wiring diagram.

Because these reductions are not necessarily unique, only one is performed, the last one in topological sort order.

All possible parallel reductions of a wiring diagram.

All possible series reductions of a wiring diagram.

Convert a wiring diagram into a morphism expression.

Convert a port value into an object expression.

Convert a morphism expression into an undirected wiring diagram.

Returns a HomUWD, or a UWD with outer ports partitioned domain and codomain.

Convert a morphism expression into a wiring diagram.

All possible transitive reductions of a wiring diagram.

Theory of bi-Heyting algebra of subobjects in a bi-Heyting topos, such as a presheaf topos.

ThSubobjectBiHeytingAlgebra

      Ob::TYPE ⊣ []
      Sub(ob)::TYPE ⊣ [ob::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      meet(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      join(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      top(X)::Sub(X) ⊣ [X::Ob]
      bottom(X)::Sub(X) ⊣ [X::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:54 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:54 =#
      implies(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      negate(A)::Sub(X) ⊣ [X::Ob, A::Sub(X)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:67 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:67 =#
      subtract(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      non(A)::Sub(X) ⊣ [X::Ob, A::Sub(X)]

Theory of a double category with tabulators

A tabulator of a proarrow is a double-categorical limit. It is a certain cell with identity domain to the given proarrow that is universal among all cells of that form. A double category "has tabulators" if the external identity functor has a right adjoint. The values of this right adjoint are the apex objects of its tabulators. The counit of the adjunction provides the universal cells. Tabulators figure in the double-categorical limit construction theorem of Grandis-Pare 1999. In the case where the double category is actually a 2-category, tabulators specialize to cotensors, a more familiar 2-categorical limit.

ThDoubleCategoryWithTabulators

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Pro(src, tgt)::TYPE ⊣ [src::Ob, tgt::Ob]
      Cell(dom, codom, src, tgt)::TYPE ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, dom::Pro(A, B), codom::Pro(C, D), src::Hom(A, C), tgt::Hom(B, D)]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      compose(α, β)::Cell(m, p, compose(f, h), compose(g, k)) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z), f::Hom(A, B), g::Hom(X, Y), h::Hom(B, C), k::Hom(Y, Z), α::Cell(m, n, f, g), β::Cell(n, p, h, k)]
      id(m)::Cell(m, m, id(A), id(B)) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (compose(compose(α, β), γ) == compose(α, compose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, W), n::Pro(B, X), p::Pro(C, Y), q::Pro(D, Z), f::Hom(A, B), g::Hom(B, C), h::Hom(C, D), i::Hom(W, X), j::Hom(X, Y), k::Hom(Y, Z), α::Cell(m, n, f, i), β::Cell(n, p, g, j), γ::Cell(p, q, h, k)]
      (compose(α, id(n)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (compose(id(m), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      pcompose(m, n)::Pro(A, C) ⊣ [A::Ob, B::Ob, C::Ob, m::Pro(A, B), n::Pro(B, C)]
      pid(A)::Pro(A, A) ⊣ [A::Ob]
      pcompose(α, β)::Cell(pcompose(m, n), pcompose(p, q), f, h) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(X, Y), q::Pro(Y, Z), f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z), α::Cell(m, p, f, g), β::Cell(n, q, g, h)]
      pid(f)::Cell(pid(A), pid(B), f, f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (pcompose(pcompose(m, n), p) == pcompose(m, pcompose(n, p))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D)]
      (pcompose(m, pid(B)) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pid(A), m) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pcompose(α, β), γ) == pcompose(α, pcompose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D), u::Pro(W, X), v::Pro(X, Y), w::Pro(Y, Z), f::Hom(A, W), g::Hom(B, X), h::Hom(C, Y), k::Hom(D, Z), α::Cell(m, u, f, g), β::Cell(n, v, g, h), γ::Cell(p, w, h, k)]
      (pcompose(α, pid(g)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (pcompose(pid(f), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      
      Tab(proarrow)::TYPE ⊣ [A::Ob, B::Ob, proarrow::Pro(A, B)]
      tabulator(p)::Tab(p) ⊣ [A::Ob, B::Ob, p::Pro(A, B)]
      ob(τ)::Ob ⊣ [A::Ob, B::Ob, p::Pro(A, B), τ::Tab(p)]
      proj1(τ)::Hom(ob(τ), A) ⊣ [A::Ob, B::Ob, p::Pro(A, B), τ::Tab(p)]
      proj2(τ)::Hom(ob(τ), B) ⊣ [A::Ob, B::Ob, p::Pro(A, B), τ::Tab(p)]
      cell(τ)::Cell(pid(ob(τ)), p, proj1(τ), proj2(τ)) ⊣ [A::Ob, B::Ob, p::Pro(A, B), τ::Tab(p)]
      universal(τ, θ)::Hom(X, ob(τ)) ⊣ [A::Ob, B::Ob, X::Ob, p::Pro(A, B), f::Hom(X, A), g::Hom(X, B), τ::Tab(p), θ::Cell(pid(X), p, f, g)]
      (compose(universal(τ, θ), proj1(τ)) == f) ⊣ [A::Ob, B::Ob, X::Ob, p::Pro(A, B), f::Hom(X, A), g::Hom(X, B), τ::Tab(p), θ::Cell(pid(X), p, f, g)]
      (compose(universal(τ, θ), proj2(τ)) == g) ⊣ [A::Ob, B::Ob, X::Ob, p::Pro(A, B), f::Hom(X, A), g::Hom(X, B), τ::Tab(p), θ::Cell(pid(X), p, f, g)]
      (compose(pid(universal(τ, θ)), cell(τ)) == θ) ⊣ [A::Ob, B::Ob, X::Ob, p::Pro(A, B), f::Hom(X, A), g::Hom(X, B), τ::Tab(p), θ::Cell(pid(X), p, f, g)]
      (universal(τ, compose(pid(h), cell(τ))) == h) ⊣ [A::Ob, B::Ob, X::Ob, p::Pro(A, B), τ::Tab(p), h::Hom(X, ob(τ))]

Theory of a category with (finite) coproducts

Finite coproducts are presented in biased style, via the nullary case (initial objects) and the binary case (binary coproducts). The axioms are dual to those of ThCategoryWithProducts.

For a monoidal category axiomatization of finite coproducts, see ThCocartesianCategory.

ThCategoryWithCoproducts

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Initial::TYPE ⊣ []
      Coproduct(foot1, foot2)::TYPE ⊣ [foot1::Ob, foot2::Ob]
      initial()::Initial ⊣ []
      ob(⊥)::Ob ⊣ [⊥::Initial]
      create(⊥, C)::Hom(ob(⊥), C) ⊣ [⊥::Initial, C::Ob]
      coproduct(A, B)::Coproduct(A, B) ⊣ [A::Ob, B::Ob]
      ob(⨆)::Ob ⊣ [A::Ob, B::Ob, ⨆::Coproduct(A, B)]
      coproj1(⨆)::Hom(A, ob(⨆)) ⊣ [A::Ob, B::Ob, ⨆::Coproduct(A, B)]
      coproj2(⨆)::Hom(B, ob(⨆)) ⊣ [A::Ob, B::Ob, ⨆::Coproduct(A, B)]
      copair(⨆, f, g)::Hom(ob(⨆), C) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), f::Hom(A, C), g::Hom(B, C)]
      (compose(coproj1(⨆), copair(⨆, f, g)) == f) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), f::Hom(A, C), g::Hom(B, C)]
      (compose(coproj2(⨆), copair(⨆, f, g)) == g) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), f::Hom(A, C), g::Hom(B, C)]
      (f == g) ⊣ [C::Ob, ⊥::Initial, f::Hom(ob(⊥), C), g::Hom(ob(⊥), C)]
      (copair(⨆, compose(coproj1(⨆), h), compose(coproj2(⨆), h)) == h) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), h::Hom(ob(⨆), C)]

Bipartite graphs, directed and undirected, as C-sets.

A graph theorist might call these "bipartitioned graphs," as in a graph equipped with a bipartition, as opposed to "bipartite graphs," as in a graph that can be bipartitioned. Here we use the former notion, which is more natural from the structuralist perspective, but the latter terminology, which is shorter and more familiar.

Abstract type for bipartite graphs.

Abstract type for undirected bipartite graphs.

A bipartite graph, better known as a bipartite directed multigraph.

Directed bipartite graphs are isomorphic to port hypergraphs and to whole grain Petri nets.

Abstract type for C-sets that contain a (directed) bipartite graph.

Abstract type for C-sets that contain a bipartition of vertices.

An undirected bipartite graph.

It is a matter of perspective whether to consider such graphs "undirected," in the sense that the edges have no orientation, or "unidirected," in the sense that all edges go from vertices of type 1 to vertices of type 2.

Add edges from V₁ to V₂ in a bipartite graph.

Add edges from V₂ to V₁ in a bipartite graph.

Add edge from V₁ to V₂ in a bipartite graph.

Add edge from V₂ to V₁ in a bipartite graph.

Add a vertex of type 1 to a bipartite graph.

Add a vertex of type 2 to a bipartite graph.

Add vertices of type 1 to a bipartite graph.

Add vertices of type 2 to a bipartite graph.

Edges from V₁ to V₂ in a bipartite graph.

Edges from V₂ to V₁ in a bipartite graph.

Number of edges from V₁ to V₂ in a bipartite graph.

Number of edges from V₂ to V₁ in a bipartite graph.

Number of vertices of type 1 in a bipartite graph.

Number of vertices of type 2 in a bipartite graph.

Remove edges from V₁ to V₂ in a bipartite graph.

Remove edges from V₂ to V₁ in a bipartite graph.

Remove edge from V₁ to V₂ in a bipartite graph.

Remove edge from V₁ to V₂ in a bipartite graph.

Remove vertex of type 1 from a bipartite graph.

Remove vertex of type 2 from a bipartite graph.

Remove vertices of type 1 from a bipartite graph.

Remove vertices of type 2 from a bipartite graph.

Source vertex of edge from V₁ to V₂ in a bipartite graph.

Source vertex of edge from V₂ to V₁ in a bipartite graph.

Target vertex of edge from V₂ to V₁ in a bipartite graph.

Target vertex of edge from V₁ to V₂ in a bipartite graph.

Vertices of type 1 in a bipartite graph.

Vertices of type 2 in a bipartite graph.

Theory of cocartesian (monoidal) categories

For the traditional axiomatization of coproducts, see ThCategoryWithCoproducts.

ThCocartesianCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      (compose(oplus(plus(A), id(A)), plus(A)) == compose(oplus(id(A), plus(A)), plus(A))) ⊣ [A::Ob]
      (compose(oplus(zero(A), id(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (compose(oplus(id(A), zero(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (plus(A) == compose(swap(A, A), plus(A))) ⊣ [A::Ob]
      (plus(oplus(A, B)) == compose(oplus(oplus(id(A), swap(B, A)), id(B)), oplus(plus(A), plus(B)))) ⊣ [A::Ob, B::Ob]
      (zero(oplus(A, B)) == oplus(zero(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (plus(mzero()) == id(mzero())) ⊣ []
      (zero(mzero()) == id(mzero())) ⊣ []
      
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      (copair(f, g) == compose(oplus(f, g), plus(C))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      (coproj1(A, B) == oplus(id(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (coproj2(A, B) == oplus(zero(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Parse relation expressions in Julia syntax into undirected wiring diagrams.

Abstract type for UWDs created by @relation macro.

Typed UWD created by @relation macro.

Untyped UWD created by @relation macro.

Parse an undirected wiring diagram from a relation expression.

For more information, see the corresponding macro @relation.

Construct an undirected wiring diagram using relation notation.

Unlike the @program macro for directed wiring diagrams, this macro departs significantly from the usual semantics of the Julia programming language. Function calls with $n$ arguments are now interpreted as assertions that an $n$-ary relation holds at a particular point. For example, the composite of binary relations $R ⊆ X × Y$ and $S ⊆ Y × Z$ can be represented as an undirected wiring diagram by the macro call

@relation (x,z) where (x::X, y::Y, z::Z) begin
  R(x,y)
  S(y,z)
end

In general, the context in the where clause defines the set of junctions in the diagram and variable sharing defines the wiring of ports to junctions. If the where clause is omitted, the set of junctions is inferred from the variables used in the macro call.

The ports and junctions of the diagram may be typed or untyped, and the ports may be named or unnamed. Thus, four possible types of undirected wiring diagrams may be returned, with the type determined by the form of relation header:

1. Untyped, unnamed: @relation (x,z) where (x,y,z) ...
2. Typed, unnamed: @relation (x,z) where (x::X, y::Y, z::Z) ...
3. Untyped, named: @relation (out1=x, out2=z) where (x,y,z) ...
4. Typed, named: @relation (out=1, out2=z) where (x::X, y::Y, z::Z) ...

All four types of diagram are subtypes of RelationDiagram.

Undirected wiring diagrams as SMCs and hypergraph categories.

Undirected wiring diagram with specified domain and codomain.

The outer ports of the undirected wiring diagram are partitioned into domain and codomain by masks (bit vectors).

Diagram to represent morphisms in hypergraph categories.

An undirected wiring diagram where the ports and junctions are typed and the boxes have names identifying the morphisms.

List of port types representing outer boundary of undirected wiring diagram.

Diagram to represent morphisms in single-sorted hypergraph categories.

By "single-sorted", we mean that the monoid of objects is free on one generator. See HypergraphDiagram for the more standard case.

Undirected wiring diagrams as a hypergraph category.

The objects are lists of port types and morphisms are undirected wiring diagrams whose outer ports are partitioned into domain and codomain.

Act on undirected wiring diagram with a cospan, as in a cospan algebra.

A cospan algebra is a lax monoidal functor from a category of (typed) cospans (Cospan,⊕) to (Set,×) (Fong & Spivak, 2019, Hypergraph categories, §2.1: Cospans and cospan-algebras). Undirected wiring diagrams are a cospan algebra in essentially the same way that any hypergraph category is (Fong & Spivak, 2019, §4.1: Cospan-algebras and hypergraph categories are equivalent). In fact, we use this action to implement the hypergraph category structure, particularly composition, on undirected wiring diagrams.

Theory of abelian bicategories of relations

Unlike ThBicategoryRelations, this theory uses additive notation.

References:

• Carboni & Walters, 1987, "Cartesian bicategories I", Sec. 5
• Baez & Erbele, 2015, "Categories in control"

ThAbelianBicategoryRelations

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      mcopy(A)::Hom(A, oplus(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:223 =#
      delete(A)::Hom(A, mzero()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:225 =#
      mmerge(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:227 =#
      create(A)::Hom(mzero(), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:229 =#
      dunit(A)::Hom(mzero(), oplus(A, A)) ⊣ [A::Ob]
      dcounit(A)::Hom(oplus(A, A), mzero()) ⊣ [A::Ob]
      dagger(f)::Hom(B, A) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      coplus(A)::Hom(A, oplus(A, A)) ⊣ [A::Ob]
      cozero(A)::Hom(A, mzero()) ⊣ [A::Ob]
      meet(R, S)::Hom(A, B) ⊣ [A::Ob, B::Ob, R::Hom(A, B), S::Hom(A, B)]
      top(A, B)::Hom(A, B) ⊣ [A::Ob, B::Ob]
      join(R, S)::Hom(A, B) ⊣ [A::Ob, B::Ob, R::Hom(A, B), S::Hom(A, B)]
      bottom(A, B)::Hom(A, B) ⊣ [A::Ob, B::Ob]

2-category of categories, functors, and natural transformations.

Categories in mathematics appear in the large, often as categories of sets with extra structure, and in the small, as algebraic structures that generalize groups, monoids, preorders, and graphs. This division manifests in Catlab as well. Large categories (in spirit, if not in the technical sense) occur throughout Catlab as @instances of the theory of categories. For computational reasons, small categories are usually presented by generators and relations.

This module provides a minimal interface to accomodate both situations. Category instances are supported through the wrapper type TypeCat. Finitely presented categories are provided by another module, FinCats.

Alias for Category.

Size of a category, used for dispatch and subtyping purposes.

A Category type having a particular CatSize means that categories of that type are at most that large.

Abstract base type for a category.

The objects and morphisms in the category have Julia types Ob and Hom, respectively. Note that these types do not necessarily form an @instance of the theory of categories, as they may not meaningfully form a category outside the context of this object. For example, a finite category regarded as a reflexive graph with a composition operation might have type Cat{Int,Int}, where the objects and morphisms are numerical identifiers for vertices and edges in the graph.

The basic operations available in any category are: dom, codom, id, compose.

Composite of functors.

Abstract base type for a functor between categories.

A functor has a domain and a codomain (dom and codom), which are categories, and object and morphism maps, which can be evaluated using ob_map and hom_map. The functor object can also be called directly when the objects and morphisms have distinct Julia types. This is sometimes but not always the case (see Category), so when writing generic code one should prefer the ob_map and hom_map functions.

Functor defined by two Julia callables, an object map and a morphism map.

Identity functor on a category.

Size of a large category, such as Set.

To the extent that they form a category, we regard Julia types and functions (TypeCat) as forming a large category.

Opposite category, where morphism are reversed.

Call op(::Cat) instead of directly instantiating this type.

Opposite functor, given by the same mapping between opposite categories.

Call op(::Functor) instead of directly instantiating this type.

Abstract base type for a natural transformation between functors.

A natural transformation $α: F ⇒ G$ has a domain $F$ and codomain $G$ (dom and codom), which are functors $F,G: C → D$ having the same domain $C$ and codomain $D$. The transformation consists of a component $αₓ: Fx → Gx$ in $D$ for each object $x ∈ C$, accessible using component or indexing notation (Base.getindex).

Pair of Julia types regarded as a category.

The Julia types should form an @instance of the theory of categories (Theories.Category).

Codomain of morphism in category.

Compose morphisms in a category.

Domain of morphism in category.

Coerce or look up morphism in category.

See also: ob.

Identity morphism on object in category.

Coerce or look up object in category.

Converts the input to an object in the category, which should be of type Ob in a category of type Cat{Ob,Hom}. How this works depends on the category, but a common case is to look up objects, which might be integers or GAT expressions, by their human-readable name, usually a symbol.

See also: hom.

2-cell dual of a 2-category.

Codomain object of natural transformation.

Given $α: F ⇒ G: C → D$, this function returns $D$.

Component of natural transformation.

Domain object of natural transformation.

Given $α: F ⇒ G: C → D$, this function returns $C$.

Evaluate functor on morphism.

Are two morphisms in a category equal?

By default, just checks for equality of Julia objects using $==$. In some categories, checking equality of morphisms may involve nontrivial reasoning.

Evaluate functor on object.

Oppositization 2-functor.

The oppositization endo-2-functor on Cat, sending a category to its opposite, is covariant on objects and morphisms and contravariant on 2-morphisms, i.e., is a 2-functor $op: Catᶜᵒ → Cat$. For more explanation, see the nLab.

Structured cospans.

This module provides a generic interface for structured cospans with a concrete implementation for attributed C-sets.

Abstract type for functor L: A → X giving a discrete attribute C-set.

A functor L: C₀-Set → C-Set giving the discrete C-set for C₀.

Unlike FinSetDiscreteACSet, this type supports data attributes. In addition, the sub-schema C₀ may contain more than one object. In all cases, the inclusion of schemas $C₀ → C$ must satisfy the property described in OpenACSetTypes.

A functor L: FinSet → C-Set giving the discrete C-set wrt an object in C.

This functor has a right adjoint R: C-Set → FinSet giving the underlying set at that object.

Leg of a structured (multi)cospan of acsets in R-form.

A convenience type that contains the data of an acset transformation, except for the codomain, since that data is already given by the decoration of the R-form structured cospan.

Structured cospan.

The first type parameter L encodes a functor L: A → X from the base category A, often FinSet, to a category X with "extra structure." An L-structured cospan is then a cospan in X whose feet are images under L of objects in A. The category X is assumed to have pushouts.

Structured cospans form a double category with no further assumptions on the functor L. To obtain a symmetric monoidal double category, L must preserve finite coproducts. In practice, L usually has a right adjoint R: X → A, which implies that L preserves all finite colimits. It also allows structured cospans to be constructed more conveniently from an object x in X plus a cospan in A with apex R(x).

See also: StructuredMulticospan.

Construct structured cospan in R-form.

Construct structured cospan in L-form.

Object in the category of L-structured cospans.

Structured multicospan.

A structured multicospan is like a structured cospan except that it may have a number of legs different than two.

See also: StructuredCospan.

Construct structured multicospan in R-form.

Apply left adjoint L: C₀-Set → C-Set to morphism.

Apply left adjoint L: FinSet → C-Set to object.

Apply left adjoint L: FinSet → C-Set to morphism.

Apply left adjoint L: C₀-Set → C-Set to object.

Create types for open attributed C-sets from an attributed C-set type.

The type parameters of the given acset type should not be instantiated with specific Julia types. This function returns a pair of types, one for objects, a subtype of StructuredCospanOb, and one for morphisms, a subtype of StructuredMulticospan. Both types will have the same type parameters for attribute types as the given acset type.

Mathematically speaking, this function sets up structured (multi)cospans with a functor $L: A → X$ between categories of acsets that creates "discrete acsets." Such a "discrete acset functor" is a functor that is left adjoint to a certain kind of forgetful functor between categories of acsets, namely one that is a pullback along an inclusion of schemas such that the image of inclusion has no outgoing arrows. For example, the schema inclusion ${V} ↪ {E ⇉ V}$ has this property but ${E} ↪ {E ⇉ V}$ does not.

See also: OpenCSetTypes.

Create types for open C-sets from a C-set type.

A special case of OpenACSetTypes. See there for details.

C-set transformation b → a induced by function f into parts of a.

Convert morphism a → R(x) to morphism L(a) → x using discrete-forgetful adjunction L ⊣ R: A ↔ X.

Theory of 2-categories

ThCategory2

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Hom2(dom, codom)::TYPE ⊣ [A::Ob, B::Ob, dom::Hom(A, B), codom::Hom(A, B)]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:26 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:26 =#
      id(f)::Hom2(f, f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      compose(α, β)::Hom2(f, h) ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B), h::Hom(A, B), α::Hom2(f, g), β::Hom2(g, h)]
      composeH(α, β)::Hom2(compose(f, h), compose(g, k)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, B), h::Hom(B, C), k::Hom(B, C), α::Hom2(f, g), β::Hom2(h, k)]
      composeH(α, h)::Hom2(compose(f, h), compose(g, h)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, B), α::Hom2(f, g), h::Hom(B, C)]
      composeH(f, β)::Hom2(compose(f, g), compose(f, h)) ⊣ [A::Ob, B::Ob, C::Ob, g::Hom(B, C), h::Hom(B, C), f::Hom(A, B), β::Hom2(g, h)]

Theory of partial orders (posets)

ThPoset

      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:46 =#
      El::TYPE ⊣ []
      Leq(lhs, rhs)::TYPE ⊣ [lhs::El, rhs::El]
      reflexive(A)::Leq(A, A) ⊣ [A::El]
      transitive(f, g)::Leq(A, C) ⊣ [A::El, B::El, C::El, f::Leq(A, B), g::Leq(B, C)]
      (f == g) ⊣ [A::El, B::El, f::Leq(A, B), g::Leq(A, B)]
      
      (A == B) ⊣ [A::El, B::El, f::Leq(A, B), g::Leq(B, A)]

Theory of a distributive semiadditive category

This terminology is not standard but the concept occurs frequently. A distributive semiadditive category is a semiadditive category (or biproduct) category, written additively, with a tensor product that distributes over the biproduct.

FIXME: Should also inherit ThSemiadditiveCategory

ThDistributiveSemiadditiveCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:33 =#
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      (copair(f, g) == compose(oplus(f, g), plus(C))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      (coproj1(A, B) == oplus(id(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (coproj2(A, B) == oplus(zero(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      
      mcopy(A)::Hom(A, oplus(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:84 =#
      delete(A)::Hom(A, mzero()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:86 =#
      plus(f, g)::Hom(A, B) ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B)]
      pair(f, g)::Hom(A, oplus(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      proj1(A, B)::Hom(oplus(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(oplus(A, B), B) ⊣ [A::Ob, B::Ob]
      (compose(f, mcopy(B)) == compose(mcopy(A), oplus(f, f))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(f, delete(B)) == delete(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Commutative diagrams in a category.

Note: This module is at an early stage of construction. For now, only commutative squares are implemented.

Commutative square in a category.

Commutative squares in a category $C$ form the cells of a strict double category, the arrow double category or double category of squares in $C$, with composition in both directions given by pasting of commutative squares.

In this data structure, the four morphisms comprising the square are stored as a static vector of length 4, ordered as domain (top), codomain (bottom), source (left), and target (right). This convention agrees with the GAT for double categories (ThDoubleCategory).

Arrow or proarrow in the double category of squares.

See also: SquareDiagram.

Object in the double category of squares.

See also: SquareDiagram.

The category of finite sets and relations, and its skeleton.

The rig of booleans.

This struct is needed because in base Julia, the product of booleans is another boolean, but the sum of booleans is coerced to an integer: true + true == 2.

Object in the category of finite sets and relations.

See also: FinSet.

Binary relation between finite sets.

A morphism in the category of finite sets and relations. The relation can be represented implicitly by an arbitrary Julia function mapping pairs of elements to booleans or explicitly by a matrix (dense or sparse) taking values in the rig of booleans (BoolRig).

Relation in FinRel defined by a callable Julia object.

Relation in FinRel represented by a boolean matrix.

Boolean matrices are also known as logical matrices or relation matrices.

FinRel as a distributive bicategory of relations.

FIXME: Many methods only work for FinRel{Int}. The default methods should assume FinRel{<:AbstractSet} and the case FinRel{Int} should be handled specially.

Theory of a cartesian double category

Loosely speaking, a cartesian double category is a double category $D$ such that the underlying catgories $D₀$ and $D₁$ are both cartesian categories, in a compatible way.

Reference: Aleiferi 2018, PhD thesis.

ThCartesianDoubleCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Pro(src, tgt)::TYPE ⊣ [src::Ob, tgt::Ob]
      Cell(dom, codom, src, tgt)::TYPE ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, dom::Pro(A, B), codom::Pro(C, D), src::Hom(A, C), tgt::Hom(B, D)]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      compose(α, β)::Cell(m, p, compose(f, h), compose(g, k)) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z), f::Hom(A, B), g::Hom(X, Y), h::Hom(B, C), k::Hom(Y, Z), α::Cell(m, n, f, g), β::Cell(n, p, h, k)]
      id(m)::Cell(m, m, id(A), id(B)) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (compose(compose(α, β), γ) == compose(α, compose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, W), n::Pro(B, X), p::Pro(C, Y), q::Pro(D, Z), f::Hom(A, B), g::Hom(B, C), h::Hom(C, D), i::Hom(W, X), j::Hom(X, Y), k::Hom(Y, Z), α::Cell(m, n, f, i), β::Cell(n, p, g, j), γ::Cell(p, q, h, k)]
      (compose(α, id(n)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (compose(id(m), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      pcompose(m, n)::Pro(A, C) ⊣ [A::Ob, B::Ob, C::Ob, m::Pro(A, B), n::Pro(B, C)]
      pid(A)::Pro(A, A) ⊣ [A::Ob]
      pcompose(α, β)::Cell(pcompose(m, n), pcompose(p, q), f, h) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(X, Y), q::Pro(Y, Z), f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z), α::Cell(m, p, f, g), β::Cell(n, q, g, h)]
      pid(f)::Cell(pid(A), pid(B), f, f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (pcompose(pcompose(m, n), p) == pcompose(m, pcompose(n, p))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D)]
      (pcompose(m, pid(B)) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pid(A), m) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pcompose(α, β), γ) == pcompose(α, pcompose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D), u::Pro(W, X), v::Pro(X, Y), w::Pro(Y, Z), f::Hom(A, W), g::Hom(B, X), h::Hom(C, Y), k::Hom(D, Z), α::Cell(m, u, f, g), β::Cell(n, v, g, h), γ::Cell(p, w, h, k)]
      (pcompose(α, pid(g)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (pcompose(pid(f), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:273 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      otimes(m, n)::Pro(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D)]
      otimes(α, β)::Cell(otimes(m, m′), otimes(n, n′), otimes(f, f′), otimes(g, g′)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, A′::Ob, B′::Ob, C′::Ob, D′::Ob, f::Hom(A, C), g::Hom(B, D), f′::Hom(A′, C′), g′::Hom(B′, D′), m::Pro(A, B), n::Pro(C, D), m′::Pro(A′, B′), n′::Pro(C′, D′), α::Cell(m, n, f, g), β::Cell(m′, n′, f′, g′)]
      (otimes(otimes(m, n), p) == otimes(m, otimes(n, p))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z)]
      (otimes(m, pid(munit())) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (otimes(pid(munit()), m) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (otimes(otimes(α, β), γ) == otimes(α, otimes(β, γ))) ⊣ [A₁::Ob, A₂::Ob, A₃::Ob, B₁::Ob, B₂::Ob, B₃::Ob, C₁::Ob, C₂::Ob, C₃::Ob, D₁::Ob, D₂::Ob, D₃::Ob, f₁::Hom(A₁, C₁), f₂::Hom(A₂, C₂), f₃::Hom(A₃, C₃), g₁::Hom(B₁, D₁), g₂::Hom(B₂, D₂), g₃::Hom(B₃, D₃), m₁::Pro(A₁, B₁), m₂::Pro(A₂, B₂), m₃::Pro(A₃, B₃), n₁::Pro(C₁, D₁), n₂::Pro(C₂, D₂), n₃::Pro(C₃, D₃), α::Cell(m₁, n₁, f₁, g₁), β::Cell(m₂, n₂, f₂, g₂), γ::Cell(m₃, m₃, f₃, g₃)]
      (compose(otimes(α, α′), otimes(β, β′)) == otimes(compose(α, β), compose(α′, β′))) ⊣ [A::Ob, B::Ob, C::Ob, A′::Ob, B′::Ob, C′::Ob, X::Ob, Y::Ob, Z::Ob, X′::Ob, Y′::Ob, Z′::Ob, f::Hom(A, B), g::Hom(X, Y), f′::Hom(A′, B′), g′::Hom(X′, Y′), h::Hom(B, C), k::Hom(Y, Z), h′::Hom(B′, C′), k′::Hom(Y′, Z′), m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z), m′::Pro(A′, X′), n′::Pro(B′, Y′), p′::Pro(C′, Z′), α::Cell(m, n, f, g), α′::Cell(m′, n′, f′, g′), β::Cell(n, p, h, k), β′::Cell(n′, p′, h′, k′)]
      (id(otimes(m, n)) == otimes(id(m), id(n))) ⊣ [A::Ob, B::Ob, X::Ob, Y::Ob, m::Pro(A, X), n::Pro(B, Y)]
      (pcompose(otimes(m, n), otimes(p, q)) == otimes(pcompose(m, p), pcompose(n, q))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), p::Pro(B, C), n::Pro(X, Y), q::Pro(Y, Z)]
      (pid(otimes(A, B)) == otimes(pid(A), pid(B))) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:345 =#
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      braid(m, n)::Cell(otimes(m, n), otimes(n, m), braid(A, B), braid(C, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, C), n::Pro(B, D)]
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (compose(braid(m, n), braid(n, m)) == id(otimes(m, n))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, C), n::Pro(B, D)]
      (compose(otimes(f, g), braid(C, D)) == compose(braid(A, B), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, C), g::Hom(B, D)]
      (compose(otimes(α, β), braid(m′, n′)) == compose(braid(m, n), otimes(β, α))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, A′::Ob, B′::Ob, C′::Ob, D′::Ob, f::Hom(A, C), g::Hom(B, D), f′::Hom(A′, C′), g′::Hom(B′, D′), m::Pro(A, B), n::Pro(C, D), m′::Pro(A′, B′), n′::Pro(C′, D′), α::Cell(m, n, f, g), β::Cell(m′, n′, f′, g′)]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(m, otimes(n, p)) == compose(otimes(braid(m, n), id(p)), otimes(id(n), braid(m, p)))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z)]
      (braid(otimes(m, n), p) == compose(otimes(id(m), braid(n, p)), otimes(braid(m, p), id(n)))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z)]
      (braid(pcompose(m, n), pcompose(m′, n′)) == pcompose(braid(m, m′), braid(n, n′))) ⊣ [A::Ob, B::Ob, C::Ob, A′::Ob, B′::Ob, C′::Ob, m::Pro(A, B), n::Pro(B, C), m′::Pro(A′, B′), n′::Pro(B′, C′)]
      (braid(pid(A), pid(B)) == pid(braid(A, B))) ⊣ [A::Ob, B::Ob]
      
      pair(f, g)::Hom(A, otimes(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      proj1(A, B)::Hom(otimes(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(otimes(A, B), B) ⊣ [A::Ob, B::Ob]
      (compose(pair(f, g), proj1(B, C)) == f) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      (compose(pair(f, g), proj2(B, C)) == g) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      (pair(compose(h, proj1(B, C)), compose(h, proj2(B, C))) == h) ⊣ [A::Ob, B::Ob, C::Ob, h::Hom(A, otimes(B, C))]
      pair(α, β)::Cell(m, otimes(p, q), pair(f, g), pair(h, k)) ⊣ [A::Ob, B::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, W), g::Hom(A, Y), h::Hom(B, X), k::Hom(B, Z), m::Pro(A, B), p::Pro(W, X), q::Pro(Y, Z), α::Cell(m, p, f, h), β::Cell(m, q, g, k)]
      proj1(m, n)::Cell(otimes(m, n), m, proj1(A, C), proj1(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D)]
      proj2(m, n)::Cell(otimes(m, n), n, proj2(A, C), proj2(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D)]
      (pair(pcompose(α, γ), pcompose(β, δ)) == pcompose(pair(α, β), pair(γ, δ))) ⊣ [A::Ob, B::Ob, C::Ob, P::Ob, Q::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, W), g::Hom(A, Y), h::Hom(B, X), k::Hom(B, Z), i::Hom(C, P), j::Hom(C, Q), m::Pro(A, B), n::Pro(B, C), p::Pro(W, X), q::Pro(Y, Z), u::Pro(X, P), v::Pro(Z, Q), α::Cell(m, p, f, h), β::Cell(m, q, g, k), γ::Cell(n, u, h, i), δ::Cell(n, v, k, j)]
      (pair(pid(f), pid(g)) == pid(pair(f, g))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(B, C)]
      (proj1(pcompose(m, n), pcompose(p, q)) == pcompose(proj1(m, p), proj2(n, q))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(X, Y), q::Pro(Y, Z)]
      (proj2(pcompose(m, n), pcompose(p, q)) == pcompose(proj2(m, p), proj2(n, q))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(X, Y), q::Pro(Y, Z)]
      (proj1(pid(A), pid(B)) == pid(proj1(A, B))) ⊣ [A::Ob, B::Ob]
      (proj2(pid(A), pid(B)) == pid(proj2(A, B))) ⊣ [A::Ob, B::Ob]

Theory of a distributive monoidal category with diagonals

FIXME: Should also inherit ThMonoidalCategoryWithDiagonals.

ThDistributiveMonoidalCategoryWithDiagonals

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:33 =#
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      (copair(f, g) == compose(oplus(f, g), plus(C))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      (coproj1(A, B) == oplus(id(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (coproj2(A, B) == oplus(zero(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:68 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:70 =#

Syntax for a free closed monoidal category.

Theory of compact closed categories

ThCompactClosedCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      hom(A, B)::Ob ⊣ [A::Ob, B::Ob]
      ev(A, B)::Hom(otimes(hom(A, B), A), B) ⊣ [A::Ob, B::Ob]
      curry(A, B, f)::Hom(A, hom(B, C)) ⊣ [C::Ob, A::Ob, B::Ob, f::Hom(otimes(A, B), C)]
      
      dual(A)::Ob ⊣ [A::Ob]
      dunit(A)::Hom(munit(), otimes(dual(A), A)) ⊣ [A::Ob]
      dcounit(A)::Hom(otimes(A, dual(A)), munit()) ⊣ [A::Ob]
      mate(f)::Hom(dual(B), dual(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (hom(A, B) == otimes(B, dual(A))) ⊣ [A::Ob, B::Ob]
      (ev(A, B) == otimes(id(B), compose(braid(dual(A), A), dcounit(A)))) ⊣ [A::Ob, B::Ob]
      (curry(A, B, f) == compose(otimes(id(A), compose(dunit(B), braid(dual(B), B))), otimes(f, id(dual(B))))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(otimes(A, B), C)]

Theory of dagger compact categories

In a dagger compact category, there are two kinds of adjoints of a morphism f::Hom(A,B), the adjoint mate mate(f)::Hom(dual(B),dual(A)) and the dagger adjoint dagger(f)::Hom(B,A). In the category of Hilbert spaces, these are respectively the Banach space adjoint and the Hilbert space adjoint (Reed-Simon, Vol I, Sec VI.2). In Julia, they would correspond to transpose and adjoint in the official LinearAlegbra module. For the general relationship between mates and daggers, see Selinger's survey of graphical languages for monoidal categories.

FIXME: This theory should also extend ThDaggerCategory, but multiple inheritance is not yet supported.

ThDaggerCompactCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      hom(A, B)::Ob ⊣ [A::Ob, B::Ob]
      ev(A, B)::Hom(otimes(hom(A, B), A), B) ⊣ [A::Ob, B::Ob]
      curry(A, B, f)::Hom(A, hom(B, C)) ⊣ [C::Ob, A::Ob, B::Ob, f::Hom(otimes(A, B), C)]
      
      dual(A)::Ob ⊣ [A::Ob]
      dunit(A)::Hom(munit(), otimes(dual(A), A)) ⊣ [A::Ob]
      dcounit(A)::Hom(otimes(A, dual(A)), munit()) ⊣ [A::Ob]
      mate(f)::Hom(dual(B), dual(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (hom(A, B) == otimes(B, dual(A))) ⊣ [A::Ob, B::Ob]
      (ev(A, B) == otimes(id(B), compose(braid(dual(A), A), dcounit(A)))) ⊣ [A::Ob, B::Ob]
      (curry(A, B, f) == compose(otimes(id(A), compose(dunit(B), braid(dual(B), B))), otimes(f, id(dual(B))))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(otimes(A, B), C)]
      
      dagger(f)::Hom(B, A) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Theory of cartesian closed categories, aka CCCs

A CCC is a cartesian category with internal homs (aka, exponential objects).

FIXME: This theory should also extend ThClosedMonoidalCategory, but multiple inheritance is not yet supported.

ThCartesianClosedCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:178 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:180 =#
      (compose(mcopy(A), otimes(mcopy(A), id(A))) == compose(mcopy(A), otimes(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), braid(A, A)) == mcopy(A)) ⊣ [A::Ob]
      (mcopy(otimes(A, B)) == compose(otimes(mcopy(A), mcopy(B)), otimes(otimes(id(A), braid(A, B)), id(B)))) ⊣ [A::Ob, B::Ob]
      (delete(otimes(A, B)) == otimes(delete(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (mcopy(munit()) == id(munit())) ⊣ []
      (delete(munit()) == id(munit())) ⊣ []
      
      pair(f, g)::Hom(A, otimes(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      proj1(A, B)::Hom(otimes(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(otimes(A, B), B) ⊣ [A::Ob, B::Ob]
      (pair(f, g) == compose(mcopy(C), otimes(f, g))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(C, A), g::Hom(C, B)]
      (proj1(A, B) == otimes(id(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (proj2(A, B) == otimes(delete(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(f, mcopy(B)) == compose(mcopy(A), otimes(f, f))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(f, delete(B)) == delete(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      
      hom(A, B)::Ob ⊣ [A::Ob, B::Ob]
      ev(A, B)::Hom(otimes(hom(A, B), A), B) ⊣ [A::Ob, B::Ob]
      curry(A, B, f)::Hom(A, hom(B, C)) ⊣ [C::Ob, A::Ob, B::Ob, f::Hom(otimes(A, B), C)]

Free diagrams in a category.

A free diagram in a category is a diagram whose shape is a free category. Examples include the empty diagram, pairs of objects, discrete diagrams, parallel pairs, composable pairs, and spans and cospans. Limits and colimits are most commonly taken over free diagrams.

The default concrete type for bipartite free diagrams.

A free diagram with a bipartite structure.

Such diagrams include most of the fixed shapes, such as spans, cospans, and parallel morphisms. They are also the generic shape of diagrams for limits and colimits arising from undirected wiring diagrams. For limits, the boxes correspond to vertices in $V₁$ and the junctions to vertices in $V₂$. Colimits are dual.

Convert a free diagram to a bipartite free diagram.

Reduce a free diagram to a free bipartite diagram with the same limit (the default, colimit=false) or the same colimit (colimit=true). The reduction is essentially the same in both cases, except for the choice of where to put isolated vertices, where we follow the conventions described at cone_objects and cocone_objects. The resulting object is a bipartite free diagram equipped with maps from the vertices of the bipartite diagram to the vertices of the original diagram.

Composable morphisms in a category.

Composable morphisms are a sequence of morphisms in a category that form a path in the underlying graph of the category.

For the common special case of two morphisms, see ComposablePair.

Pair of composable morphisms in a category.

Composable pairs are a common special case of ComposableMorphisms.

Cospan of morphisms in a category.

A common special case of Multicospan. See also Span.

Discrete diagram: a diagram with no non-identity morphisms.

Abstract type for free diagram of fixed shape.

A free diagram that has been converted to a bipartite free diagram.

Wrapper type to interpret FreeDiagram as a FinDomFunctor.

Multicospan of morphisms in a category.

A multicospan is like a Cospan except that it may have a number of legs different than two. A limit of this shape is a pullback.

Multispan of morphisms in a category.

A multispan is like a Span except that it may have a number of legs different than two. A colimit of this shape is a pushout.

Parallel morphims in a category.

Parallel morphisms are just morphisms with the same domain and codomain. A (co)limit of this shape is a (co)equalizer.

For the common special case of two morphisms, see ParallelPair.

Pair of parallel morphisms in a category.

A common special case of ParallelMorphisms.

Span of morphims in a category.

A common special case of Multispan. See also Cospan.

Apex of multispan or multicospan.

The apex of a multi(co)span is the object that is the (co)domain of all the legs.

Bundle together legs of a multi(co)span.

For example, calling bundle_legs(span, SVector((1,2),(3,4))) on a multispan with four legs gives a span whose left leg bundles legs 1 and 2 and whose right leg bundles legs 3 and 4. Note that in addition to bundling, this function can also permute legs and discard them.

The bundling is performed using the universal property of (co)products, which assumes that these (co)limits exist.

Objects in diagram that will have explicit legs in colimit cocone.

See also: cone_objects.

Objects in diagram that will have explicit legs in limit cone.

In category theory, it is common practice to elide legs of limit cones that can be computed from other legs, especially for diagrams of certain fixed shapes. For example, when it taking a pullback (the limit of a cospan), the limit object is often treated as having two projections, rather than three. This function encodes such conventions by listing the objects in the diagram that will have corresponding legs in the limit object created by Catlab.

See also: cocone_objects.

Given a diagram in a category $C$, return Julia type of objects and morphisms in $C$ as a tuple type of form $Tuple{Ob,Hom}$.

Feet of multispan or multicospan.

The feet of a multispan are the codomains of the legs.

Left leg of span or cospan.

Legs of multispan or multicospan.

The legs are the morphisms comprising the multi(co)span.

Right leg of span or cospan.

Theory of a category with (finite) products

Finite products are presented in biased style, via the nullary case (terminal objects) and the binary case (binary products). The equational axioms are standard, especially in type theory (Lambek & Scott, 1986, Section 0.5 or Section I.3). Strictly speaking, this theory is not of a "category with finite products" (a category in which finite products exist) but of a "category with chosen finite products".

For a monoidal category axiomatization of finite products, see ThCartesianCategory.

ThCategoryWithProducts

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Terminal::TYPE ⊣ []
      Product(foot1, foot2)::TYPE ⊣ [foot1::Ob, foot2::Ob]
      terminal()::Terminal ⊣ []
      ob(⊤)::Ob ⊣ [⊤::Terminal]
      delete(⊤, C)::Hom(C, ob(⊤)) ⊣ [⊤::Terminal, C::Ob]
      product(A, B)::Product(A, B) ⊣ [A::Ob, B::Ob]
      ob(Π)::Ob ⊣ [A::Ob, B::Ob, Π::Product(A, B)]
      proj1(Π)::Hom(ob(Π), A) ⊣ [A::Ob, B::Ob, Π::Product(A, B)]
      proj2(Π)::Hom(ob(Π), B) ⊣ [A::Ob, B::Ob, Π::Product(A, B)]
      pair(Π, f, g)::Hom(C, ob(Π)) ⊣ [A::Ob, B::Ob, C::Ob, Π::Product(A, B), f::Hom(C, A), g::Hom(C, B)]
      (compose(pair(Π, f, g), proj1(Π)) == f) ⊣ [A::Ob, B::Ob, C::Ob, Π::Product(A, B), f::Hom(C, A), g::Hom(C, B)]
      (compose(pair(Π, f, g), proj2(Π)) == g) ⊣ [A::Ob, B::Ob, C::Ob, Π::Product(A, B), f::Hom(C, A), g::Hom(C, B)]
      (f == g) ⊣ [C::Ob, ⊤::Terminal, f::Hom(C, ob(⊤)), g::Hom(C, ob(⊤))]
      (pair(Π, compose(h, proj1(Π)), compose(h, proj2(Π))) == h) ⊣ [A::Ob, B::Ob, C::Ob, Π::Product(A, B), h::Hom(C, ob(Π))]

Theory of lattice of subobjects in a coherent category, such as a pretopos.

The axioms are omitted since this theory is the same as the theory Catlab.Theories.ThAlgebraicLattice except that the lattice elements are dependent on another type. In fact, if we supported GAT morphisms, it should be possible to define a projection morphism of GATs from ThSubobjectLattice to ThAlgebraicLattice that sends Ob to the unit type.

ThSubobjectLattice

      Ob::TYPE ⊣ []
      Sub(ob)::TYPE ⊣ [ob::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      meet(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      join(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      top(X)::Sub(X) ⊣ [X::Ob]
      bottom(X)::Sub(X) ⊣ [X::Ob]

Theory of bicategories of relations

TODO: The 2-morphisms are missing.

References:

• Carboni & Walters, 1987, "Cartesian bicategories I"
• Walters, 2009, blog post, "Categorical algebras of relations", http://rfcwalters.blogspot.com/2009/10/categorical-algebras-of-relations.html

ThBicategoryRelations

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:178 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:180 =#
      (compose(mcopy(A), otimes(mcopy(A), id(A))) == compose(mcopy(A), otimes(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), braid(A, A)) == mcopy(A)) ⊣ [A::Ob]
      (mcopy(otimes(A, B)) == compose(otimes(mcopy(A), mcopy(B)), otimes(otimes(id(A), braid(A, B)), id(B)))) ⊣ [A::Ob, B::Ob]
      (delete(otimes(A, B)) == otimes(delete(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (mcopy(munit()) == id(munit())) ⊣ []
      (delete(munit()) == id(munit())) ⊣ []
      
      mmerge(A)::Hom(otimes(A, A), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:248 =#
      create(A)::Hom(munit(), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:250 =#
      
      dunit(A)::Hom(munit(), otimes(A, A)) ⊣ [A::Ob]
      dcounit(A)::Hom(otimes(A, A), munit()) ⊣ [A::Ob]
      dagger(f)::Hom(B, A) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (dunit(A) == compose(create(A), mcopy(A))) ⊣ [A::Ob]
      (dcounit(A) == compose(mmerge(A), delete(A))) ⊣ [A::Ob]
      (dagger(f) == compose(compose(otimes(id(B), dunit(A)), otimes(otimes(id(B), f), id(A))), otimes(dcounit(B), id(A)))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      
      meet(R, S)::Hom(A, B) ⊣ [A::Ob, B::Ob, R::Hom(A, B), S::Hom(A, B)]
      top(A, B)::Hom(A, B) ⊣ [A::Ob, B::Ob]

The data of the object of a slice category (say, some category C sliced over an object X in Ob(C)) is the data of a homomorphism in Hom(A,X) for some ob A.

The data of the morphism of a slice category (call it h, and suppose a category C is sliced over an object X in Ob(C)) between objects f and g is a homomorphism in the underlying category that makes the following triangle commute.

h A –> B f ↘ ↙ g X

Convert a limit problem in the slice category to a limit problem of the underlying category.

Encode the base of slice as the first object in the new diagram

Get the underlying diagram of a slice category diagram which has the object being sliced over explicitly, and arrows are ACSetTransformations

Abstract type for graph with properties.

Concrete types are PropertyGraph and SymmetricPropertyGraph.

Graph with properties.

"Property graphs" are graphs with arbitrary named properties on the graph, vertices, and edges. They are intended for applications with a large number of ad-hoc properties. If you have a small number of known properties, it is better and more efficient to create a specialized C-set type using @acset_type.

See also: SymmetricPropertyGraph.

Symmetric graphs with properties.

The edge properties are preserved under the edge involution, so these can be interpreted as "undirected" property (multi)graphs.

See also: PropertyGraph.

Properties of edge in a property graph.

Get property of edge or edges in a property graph.

Get graph-level property of a property graph.

Get property of vertex or vertices in a property graph.

Graph-level properties of a property graph.

Set property of edge or edges in a property graph.

Set multiple properties of an edge in a property graph.

Set graph-level property in a property graph.

Set multiple graph-level properties in a property graph.

Set property of vertex or vertices in a property graph.

Set multiple properties of a vertex in a property graph.

Properties of vertex in a property graph.

Functorial data migration for attributed C-sets.

FreeDiagram(pres::Presentation{FreeSchema, Symbol})

Returns a FreeDiagram whose objects are the generating objects of pres and whose homs are the generating homs of pres.

A data migration is guaranteed to contain a functor between schemas that can be used to migrate data between acsets on those schemas. The migration may be a pullback data migration (DeltaMigration), specified by a functor $D → C$ between the schemas, or $F$ may be a schema functor specifying a $Σ$ migration in the covariant direction. Other data migration types are defined in DataMigrations.jl.

Abstract type for a data migration functor.

This allows a data migration to behave as an actual model of the theory of functors with domain and codomain categories of acsets rather than schemas, once one knows the exact concrete types Dom and Codom of the relevant acsets.

Data migration functor given contravariantly. Stores a contravariant migration.

Schema-level functor defining a pullback or delta data migration.

Given a functor $F: C → D$, the delta migration $Δ_F$ is a functor from $C$-sets to $D$-sets that simply sends a $C$-set $X$ to the $D$-set $X∘F$.

Sigma or left pushforward functorial data migration between acsets.

Given a functor $F: C → D$, the sigma data migration $Σ_F$ is a functor from $C$-sets to $D$-sets that is left adjoint to the delta migration functor $Δ_F$ (DeltaMigration). Explicitly, the $D$-set $Σ_F(X)$ is given on objects $d ∈ D$ by the formula $Σ_F(x)(d) = \mathrm{colim}_{F ↓ d} X ∘ π$, where $π: (F ↓ d) → C$ is the projection.

See (Spivak, 2014, Category Theory for the Sciences) for details.

Objects: Fᴳ(c) = C-Set(C × G, F) where C is the representable c

Given a map f: a->b, we compute that f(Aᵢ) = Bⱼ by constructing the following: Aᵢ A × G → F f*↑ ↑ ↑ ↗ Bⱼ find the hom Bⱼ that makes this commute B × G

where f* is given by yoneda.

Contravariantly migrate data from the acset Y to the acset X.

This is the mutating variant of migrate!. When the functor on schemas is the identity, this operation is equivalent to copy_parts!.

Apply a $Δ$ migration by simple precomposition.

Contravariantly migrate data from the acset Y to a new acset of type T.

The mutating variant of this function is migrate!.

Construct a representable C-set.

Recall that a representable C-set is one of form $C(c,-): C → Set$ for some object $c ∈ C$.

This function computes the $c$ representable as the left pushforward data migration of the singleton ${c}$-set along the inclusion functor ${c} ↪ C$, which works because left Kan extensions take representables to representables (Mac Lane 1978, Exercise X.3.2). Besides the intrinsic difficulties with representables (they can be infinite), this function thus inherits any limitations of our implementation of left pushforward data migrations.

Split an n-fold composite (n may be 1) Hom or Attr into its left n-1 and rightmost 1 components

The subobject classifier Ω in a presheaf topos is the presheaf that sends each object A to the set of sieves on it (equivalently, the set of subobjects of the representable presheaf for A). Counting subobjects gives us the number of A parts; the hom data for f:A->B for subobject Aᵢ is determined via:

Aᵢ ↪ A ↑ ↑ f* PB⌝↪ B (PB picks out a subobject of B, up to isomorphism.)

(where A and B are the representables for objects A and B and f* is the unique map from B into the A which sends the point of B to f applied to the point of A)

Returns the classifier as well as a dictionary of subobjects corresponding to the parts of the classifier.

Compute the Yoneda embedding of a category C in the category of C-sets.

Because Catlab privileges copresheaves (C-sets) over presheaves, this is the contravariant Yoneda embedding, i.e., the embedding functor C^op → C-Set.

The first argument cons is a constructor for the ACSet, such as a struct acset type. If representables have already been computed (which can be expensive), they can be supplied via the cache keyword argument.

Returns a FinDomFunctor with domain op(C).

Gives the underlying schema functor of a data migration seen as a functor of acset categories.

Theory of monoidal categories with diagonals

A monoidal category with diagonals is a symmetric monoidal category equipped with coherent operations of copying and deleting, also known as a supply of commutative comonoids. Unlike in a cartesian category, the naturality axioms need not be satisfied.

References:

• Fong & Spivak, 2019, "Supplying bells and whistles in symmetric monoidal categories" (arxiv:1908.02633)
• Selinger, 2010, "A survey of graphical languages for monoidal categories", Section 6.6: "Cartesian center"
• Selinger, 1999, "Categorical structure of asynchrony"

ThMonoidalCategoryWithDiagonals

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:178 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:180 =#
      (compose(mcopy(A), otimes(mcopy(A), id(A))) == compose(mcopy(A), otimes(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), braid(A, A)) == mcopy(A)) ⊣ [A::Ob]
      (mcopy(otimes(A, B)) == compose(otimes(mcopy(A), mcopy(B)), otimes(otimes(id(A), braid(A, B)), id(B)))) ⊣ [A::Ob, B::Ob]
      (delete(otimes(A, B)) == otimes(delete(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (mcopy(munit()) == id(munit())) ⊣ []
      (delete(munit()) == id(munit())) ⊣ []

Theory of traced monoidal categories

ThTracedMonoidalCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      trace(X, A, B, f)::Hom(A, B) ⊣ [X::Ob, A::Ob, B::Ob, f::Hom(otimes(X, A), otimes(X, B))]

Theory of monoidal categories with bidiagonals

The terminology is nonstandard (is there any standard terminology?) but is supposed to mean a monoidal category with coherent diagonals and codiagonals. Unlike in a biproduct category, the naturality axioms need not be satisfied.

ThMonoidalCategoryWithBidiagonals

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:178 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:180 =#
      (compose(mcopy(A), otimes(mcopy(A), id(A))) == compose(mcopy(A), otimes(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), braid(A, A)) == mcopy(A)) ⊣ [A::Ob]
      (mcopy(otimes(A, B)) == compose(otimes(mcopy(A), mcopy(B)), otimes(otimes(id(A), braid(A, B)), id(B)))) ⊣ [A::Ob, B::Ob]
      (delete(otimes(A, B)) == otimes(delete(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (mcopy(munit()) == id(munit())) ⊣ []
      (delete(munit()) == id(munit())) ⊣ []
      
      mmerge(A)::Hom(otimes(A, A), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:248 =#
      create(A)::Hom(munit(), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:250 =#

Limits and colimits in a category.

Abstract type for colimit in a category.

The standard concrete subtype is Colimit, although for computational reasons certain categories may use different subtypes to include extra data.

Abstract type for limit in a category.

The standard concrete subtype is Limit, although for computational reasons certain categories may use different subtypes to include extra data.

Limit computed by reduction to the limit of a free bipartite diagram.

Limit computed by reduction to the limit of a free bipartite diagram.

Colimit in a category.

Algorithm for computing colimits.

Compute pushout by composing a coproduct with a coequalizer.

See also: ComposeProductEqualizer.

Compute pullback by composing a product with an equalizer.

See also: ComposeCoproductCoequalizer.

Pullback formed as composite of product and equalizer.

The fields of this struct are an implementation detail; accessing them directly violates the abstraction. Everything that you can do with a pullback, including invoking its universal property, should be done through the generic interface for limits.

See also: CompositePushout.

Pushout formed as composite of coproduct and equalizer.

See also: CompositePullback.

Limit in a category.

Algorithm for computing limits.

Colimit of a singleton diagram.

Limit of a singleton diagram.

Meta-algorithm that reduces general colimits to common special cases.

Dual to SpecializeLimit.

Meta-algorithm that reduces general limits to common special cases.

Reduces limits of free diagrams that happen to be discrete to products. If this fails, fall back to the given algorithm (if any).

TODO: Reduce free diagrams that are (multi)cospans to (wide) pullbacks.

Compute a colimit by reducing the diagram to a free bipartite diagram.

Compute a limit by reducing the diagram to a free bipartite diagram.

Synonymous with ob in the case of Limits, but present here to allow a Limit to be implicitly treated like a Multispan.

https://en.wikipedia.org/wiki/Coimage

Colimit of a diagram.

To define colimits in a category with objects Ob, override the method colimit(::FreeDiagram{Ob}) for general colimits or colimit(::D) with suitable type D <: FixedShapeFreeDiagram{Ob} for colimits of specific shape, such as coproducts or coequalizers.

See also: limit

The image and coimage are isomorphic. We get this isomorphism using univeral properties.

  CoIm′ ╌╌> I ↠ CoIm
    ┆ ⌟     |
    v       v
    I   ⟶  R ↩ Im
    |       ┆
    v    ⌜  v
    R ╌╌> Im′

https://en.wikipedia.org/wiki/Image(categorytheory)#Second_definition

Limit of a diagram.

To define limits in a category with objects Ob, override the method limit(::FreeDiagram{Ob}) for general limits or limit(::D) with suitable type D <: FixedShapeFreeDiagram{Ob} for limits of specific shape, such as products or equalizers.

See also: colimit

Pullback of a pair of morphisms with common codomain.

To implement for a type T, define the method limit(::Cospan{T}) and/or limit(::Multicospan{T}) or, if you have already implemented products and equalizers, rely on the default implementation.

Pushout of a pair of morphisms with common domain.

To implement for a type T, define the method colimit(::Span{T}) and/or colimit(::Multispan{T}) or, if you have already implemented coproducts and coequalizers, rely on the default implementation.

Coequalizer of morphisms with common domain and codomain.

To implement for a type T, define the method colimit(::ParallelPair{T}) or colimit(::ParallelMorphisms{T}).

Copairing of morphisms: universal property of coproducts/pushouts.

To implement for coproducts of type T, define the method universal(::BinaryCoproduct{T}, ::Cospan{T}) and/or universal(::Coproduct{T}, ::Multicospan{T}) and similarly for pushouts.

Coproduct of objects.

To implement for a type T, define the method colimit(::ObjectPair{T}) and/or colimit(::DiscreteDiagram{T}).

Unique morphism out of an initial object.

To implement for a type T, define the method universal(::Initial{T}, ::SMulticospan{0,T}).

Unique morphism into a terminal object.

To implement for a type T, define the method universal(::Terminal{T}, ::SMultispan{0,T}).

Equalizer of morphisms with common domain and codomain.

To implement for a type T, define the method limit(::ParallelPair{T}) and/or limit(::ParallelMorphisms{T}).

Factor morphism through (co)equalizer, via the universal property.

To implement for equalizers of type T, define the method universal(::Equalizer{T}, ::SMultispan{1,T}). For coequalizers of type T, define the method universal(::Coequalizer{T}, ::SMulticospan{1,T}).

Initial object.

To implement for a type T, define the method colimit(::EmptyDiagram{T}).

Pairing of morphisms: universal property of products/pullbacks.

To implement for products of type T, define the method universal(::BinaryProduct{T}, ::Span{T}) and/or universal(::Product{T}, ::Multispan{T}) and similarly for pullbacks.

Product of objects.

To implement for a type T, define the method limit(::ObjectPair{T}) and/or limit(::DiscreteDiagram{T}).

Terminal object.

To implement for a type T, define the method limit(::EmptyDiagram{T}).

universal(lim,cone)

Universal property of (co)limits.

Compute the morphism whose existence and uniqueness is guaranteed by the universal property of (co)limits.

See also: limit, colimit.

Define cartesian monoidal structure using limits.

Implements an instance of ThCartesianCategory assuming that finite products have been implemented following the limits interface.

Define cocartesian monoidal structure using colimits.

Implements an instance of ThCocartesianCategory assuming that finite coproducts have been implemented following the colimits interface.

Catlab's standard library of generalized algebraic theories.

The focus is on categories and monoidal categories, but other related structures are also included.

Theory of groupoids.

Theory of copresheaves.

Axiomatized as a covariant category action.

Theory of presheaves.

Axiomatized as a contravariant category action.

Theory of an ℳ-category.

The term "ℳ-category", used on the nLab is not very common, but the concept itself shows up commonly. An ℳ-category is a category with a distinguished wide subcategory, whose morphisms are suggestively called tight; for contrast, a generic morphism is called loose. Equivalently, an ℳ-category is a category enriched in the category ℳ of injections, the full subcategory of the arrow category of Set spanned by injections.

In the following GAT, tightness is axiomatized as a property of morphisms: a dependent family of sets over the hom-sets, each having at most one inhabitant.

Theory of a pointed set-enriched category. We axiomatize a category equipped with zero morphisms.

A functor from an ordinary category into a freely generated pointed-set enriched category, equivalently, a pointed-set enriched category in which no two nonzero maps compose to a zero map, is a good notion of a functor that's total on objects and partial on morphisms.

Theory of a category with (finite) products

Finite products are presented in biased style, via the nullary case (terminal objects) and the binary case (binary products). The equational axioms are standard, especially in type theory (Lambek & Scott, 1986, Section 0.5 or Section I.3). Strictly speaking, this theory is not of a "category with finite products" (a category in which finite products exist) but of a "category with chosen finite products".

For a monoidal category axiomatization of finite products, see ThCartesianCategory.

Theory of a (finitely) complete category

Finite limits are presented in biased style, via finite products and equalizers. The equational axioms for equalizers are obscure, but can found in (Lambek & Scott, 1986, Section 0.5), who in turn attribute them to "Burroni's pioneering ideas". Strictly speaking, this theory is not of a "finitely complete category" (a category in which finite limits exist) but of a "category with chosen finite limits".

Theory of a category with (finite) coproducts

Finite coproducts are presented in biased style, via the nullary case (initial objects) and the binary case (binary coproducts). The axioms are dual to those of ThCategoryWithProducts.

For a monoidal category axiomatization of finite coproducts, see ThCocartesianCategory.

Theory of a (finitely) cocomplete category

Finite colimits are presented in biased style, via finite coproducts and coequalizers. The axioms are dual to those of ThCompleteCategory.

Theory of monoidal categories

To avoid associators and unitors, we assume that the monoidal category is strict. By the coherence theorem this involves no loss of generality, but we might add a theory for weak monoidal categories later.

Theory of (strict) symmetric monoidal categories

Theory of a symmetric monoidal copresheaf

The name is not standard but refers to a lax symmetric monoidal functor into Set. This can be interpreted as an action of a symmetric monoidal category, just as a copresheaf (set-valued functor) is an action of a category. The theory is simpler than that of a general lax monoidal functor because (1) the domain is a strict monoidal category and (2) the codomain is fixed to the cartesian monoidal category Set.

FIXME: This theory should also extend ThCopresheaf but multiple inheritance is not yet supported.

Theory of monoidal categories with diagonals

A monoidal category with diagonals is a symmetric monoidal category equipped with coherent operations of copying and deleting, also known as a supply of commutative comonoids. Unlike in a cartesian category, the naturality axioms need not be satisfied.

References:

• Fong & Spivak, 2019, "Supplying bells and whistles in symmetric monoidal categories" (arxiv:1908.02633)
• Selinger, 2010, "A survey of graphical languages for monoidal categories", Section 6.6: "Cartesian center"
• Selinger, 1999, "Categorical structure of asynchrony"

Theory of cartesian (monoidal) categories

For the traditional axiomatization of products, see ThCategoryWithProducts.

Theory of monoidal categories with bidiagonals

The terminology is nonstandard (is there any standard terminology?) but is supposed to mean a monoidal category with coherent diagonals and codiagonals. Unlike in a biproduct category, the naturality axioms need not be satisfied.

Theory of biproduct categories

Mathematically the same as ThSemiadditiveCategory but written multiplicatively, instead of additively.

Theory of (symmetric) closed monoidal categories

Theory of cartesian closed categories, aka CCCs

A CCC is a cartesian category with internal homs (aka, exponential objects).

FIXME: This theory should also extend ThClosedMonoidalCategory, but multiple inheritance is not yet supported.

Theory of compact closed categories

Theory of dagger categories

Theory of dagger symmetric monoidal categories

Also known as a symmetric monoidal dagger category.

FIXME: This theory should also extend ThDaggerCategory, but multiple inheritance is not yet supported.

Theory of dagger compact categories

In a dagger compact category, there are two kinds of adjoints of a morphism f::Hom(A,B), the adjoint mate mate(f)::Hom(dual(B),dual(A)) and the dagger adjoint dagger(f)::Hom(B,A). In the category of Hilbert spaces, these are respectively the Banach space adjoint and the Hilbert space adjoint (Reed-Simon, Vol I, Sec VI.2). In Julia, they would correspond to transpose and adjoint in the official LinearAlegbra module. For the general relationship between mates and daggers, see Selinger's survey of graphical languages for monoidal categories.

FIXME: This theory should also extend ThDaggerCategory, but multiple inheritance is not yet supported.

Theory of traced monoidal categories

Theory of hypergraph categories

Hypergraph categories are also known as "well-supported compact closed categories" and "spidered/dungeon categories", among other things.

FIXME: Should also inherit ThClosedMonoidalCategory and ThDaggerCategory, but multiple inheritance is not yet supported.

Theory of monoidal categories, in additive notation

Mathematically the same as ThMonoidalCategory but with different notation.

Theory of symmetric monoidal categories, in additive notation

Mathematically the same as ThSymmetricMonoidalCategory but with different notation.

Theory of monoidal categories with codiagonals

A monoidal category with codiagonals is a symmetric monoidal category equipped with coherent collections of merging and creating morphisms (monoids). Unlike in a cocartesian category, the naturality axioms need not be satisfied.

For references, see ThMonoidalCategoryWithDiagonals.

Theory of cocartesian (monoidal) categories

For the traditional axiomatization of coproducts, see ThCategoryWithCoproducts.

Theory of monoidal categories with bidiagonals, in additive notation

Mathematically the same as ThMonoidalCategoryWithBidiagonals but written additively, instead of multiplicatively.

Theory of semiadditive categories

Mathematically the same as ThBiproductCategory but written additively, instead of multiplicatively.

Theory of additive categories

An additive category is a biproduct category enriched in abelian groups. Thus, it is a semiadditive category where the hom-monoids have negatives.

Theory of hypergraph categories, in additive notation

Mathematically the same as ThHypergraphCategory but with different notation.

Theory of a rig category, also known as a bimonoidal category

Rig categories are the most general in the hierarchy of distributive monoidal structures.

Question: Do we also want the distributivty and absorption isomorphisms? Usually we ignore coherence isomorphisms such as associators and unitors.

FIXME: This theory should also inherit ThMonoidalCategory, but multiple inheritance is not supported.

Theory of a symmetric rig category

FIXME: Should also inherit ThSymmetricMonoidalCategory.

Theory of a distributive (symmetric) monoidal category

Reference: Jay, 1992, LFCS tech report LFCS-92-205, "Tail recursion through universal invariants", Section 3.2

FIXME: Should also inherit ThCocartesianCategory.

Theory of a distributive monoidal category with diagonals

FIXME: Should also inherit ThMonoidalCategoryWithDiagonals.

Theory of a distributive semiadditive category

This terminology is not standard but the concept occurs frequently. A distributive semiadditive category is a semiadditive category (or biproduct) category, written additively, with a tensor product that distributes over the biproduct.

FIXME: Should also inherit ThSemiadditiveCategory

Theory of a distributive category

A distributive category is a distributive monoidal category whose tensor product is the cartesian product, see ThDistributiveMonoidalCategory.

FIXME: Should also inherit ThCartesianCategory.

Theory of a displayed category.

More precisely, this is the theory of a category $C$ (Ob,Hom) together with a displayed category over $C$ (Fib,FibHom). Displayed categories axiomatize lax functors $C → **Span**$, or equivalently objects of a slice category $**Cat**/C$, in a generalized algebraic style.

References:

• nLab: displayed category
• Ahrens & Lumsdaine, 2019: Displayed categories, Definition 3.1

Theory of an opindexed, or covariantly indexed, category.

An opindexed category is a Cat-valued pseudofunctor. For simplicitly, we assume that the functor is strict.

Just as a copresheaf, or Set-valued functor, can be seen as a category action on a family of sets, an opindexed category can be seen as a category action on a family of categories. This picture guides our axiomatization of an opindexed category as a generalized algebraic theory. The symbol * is used for the actions since a common mathematical notation for the "pushforward functor" induced by an indexing morphism $f: A → B$ is $f_*: F(A) o F(B)$.

Theory of an opindexed, or covariantly indexed, monoidal category.

An opindexed monoidal category is a pseudofunctor into MonCat, the 2-category of monoidal categories, strong monoidal functors, and monoidal natural transformations. For simplicity, we take the pseudofunctor, the monoidal categories, and the monoidal functors all to be strict.

References:

• nLab: indexed monoidal category
• Shulman, 2008: Framed bicategories and monoidal fibrations
• Shulman, 2013: Enriched indexed categories

Theory of an opindexed monoidal category with lax transition functors.

This is a pseudofunctor into MonCatLax, the 2-category of monoidal categories, lax monoidal functors, and monoidal natural transformations. In (Hofstra & De Marchi 2006), these are called simply "(op)indexed monoidal categories," but that is not the standard usage.

References:

• Hofstra & De Marchi, 2006: Descent for monads
• Moeller & Vasilakopoulou, 2020: Monoidal Grothendieck construction, Remark 3.18 [this paper is about monoidal indexed categories, a different notion!]

Theory of an opindexed monoidal category with cocartesian indexing category.

This is equivalent via the Grothendieck construction to a monoidal opfibration over a cocartesian monoidal base (Shulman 2008, Theorem 12.7). The terminology "coindexed monoidal category" used here is not standard and arguably not good, but I'm running out of ways to combine these adjectives.

References:

• Shulman, 2008: Framed bicategories and monoidal fibrations
• Shulman, 2013: Enriched indexed categories

Theory of 2-categories

Theory of double categories

A strict double category $D$ is an internal category

$(S,T: D₁ ⇉ D₀, U: D₀ → D₁, *: D₁ ×_{D₀} D₁ → D₁)$

in Cat where

• objects of $D₀$ are objects of $D$
• morphisms of $D₀$ are arrows (vertical morphisms) of $D$
• objects of $D₁$ are proarrows (horizontal morphisms) of $D$
• morphisms of $D₁$ are cells of $D$.

The domain and codomain (top and bottom) of a cell are given by the domain and codomain in $D₁$ and the source and target (left and right) are given by the functors $S,T$.

Theory of a double category with tabulators

A tabulator of a proarrow is a double-categorical limit. It is a certain cell with identity domain to the given proarrow that is universal among all cells of that form. A double category "has tabulators" if the external identity functor has a right adjoint. The values of this right adjoint are the apex objects of its tabulators. The counit of the adjunction provides the universal cells. Tabulators figure in the double-categorical limit construction theorem of Grandis-Pare 1999. In the case where the double category is actually a 2-category, tabulators specialize to cotensors, a more familiar 2-categorical limit.

Theory of a proarrow equipment, or equipment for short

Equipments have also been called "framed bicategories," "fibrant double categories," and "gregarious double categories" (?!).

References:

• Shulman, 2008: Framed bicategories and monoidal fibrations
• Cruttwell & Shulman, 2010: A unified framework for generalized multicategories

Theory of monoidal double categories

To avoid associators and unitors, we assume that the monoidal double category is fully strict: both the double category and its monoidal product are strict. Apart from assuming strictness, this theory agrees with the definition of a monoidal double category in (Shulman 2010) and other recent works.

In a monoidal double category $(D,⊗,I)$, the underlying categories $D₀$ and $D₁$ are each monoidal categories, $(D₀,⊗₀,I₀)$ and $(D₁,⊗₁,I₁)$, subject to further axioms such as the source and target functors $S, T: D₁ → D₀$ being strict monoidal functors.

Despite the apparent asymmetry in this setup, the definition of a monoidal double category unpacks to be nearly symmetric with respect to arrows and proarrows, except that the monoidal unit $I₀$ of $D₀$ induces the monoidal unit of $D₁$ as $I₁ = U(I₀)$.

References:

• Shulman, 2010: Constructing symmetric monoidal bicategories

FIXME: Should also inherit ThMonoidalCategory{Ob,Hom} but multiple inheritance is not supported.

Theory of symmetric monoidal double categories

Unlike the classical notion of strict double categories, symmetric monoidal double categories do not treat the two directions on an equal footing, even when everything (except the braiding) is strict. See ThMonoidalDoubleCategory for references.

FIXME: Should also inherit ThSymmetricMonoidalCategory{Ob,Hom} but multiple inheritance is not supported.

Theory of a cartesian double category

Loosely speaking, a cartesian double category is a double category $D$ such that the underlying catgories $D₀$ and $D₁$ are both cartesian categories, in a compatible way.

Reference: Aleiferi 2018, PhD thesis.

Theory of thin categories

Thin categories have at most one morphism between any two objects and are isomorphic to preorders.

Theory of thin symmetric monoidal category

Thin SMCs are isomorphic to commutative monoidal prosets.

Theory of preorders

The generalized algebraic theory of preorders encodes inequalities $A≤B$ as dependent types `$Leq(A,B)$ and the axioms of reflexivity and transitivity as term constructors.

Theory of partial orders (posets)

Theory of lattices as posets

A (bounded) lattice is a poset with all finite meets and joins. Viewed as a thin category, this means that the category has all finite products and coproducts, hence the names for the inequality constructors in the theory. Compare with ThCartesianCategory and ThCocartesianCategory.

This is one of two standard axiomatizations of a lattice, the other being ThAlgebraicLattice.

Theory of lattices as algebraic structures

This is one of two standard axiomatizations of a lattice, the other being ThLattice. Because the partial order is not present, this theory is merely an algebraic theory (no dependent types).

The partial order is recovered as $A ≤ B$ iff $A ∧ B = A$ iff $A ∨ B = B$. This definition could be reintroduced into a generalized algebraic theory using an equality type Eq(lhs::El, rhs::El)::TYPE combined with term constructors `meet_leq(eq::Eq(A∧B, A))::(A ≤ B) and join_leq(eq::Eq(A∨B, B))::(A ≤ B). We do not employ that trick here because at that point it is more convenient to just start with the poset structure, as in ThLattice.

Theory of bicategories of relations

TODO: The 2-morphisms are missing.

References:

• Carboni & Walters, 1987, "Cartesian bicategories I"
• Walters, 2009, blog post, "Categorical algebras of relations", http://rfcwalters.blogspot.com/2009/10/categorical-algebras-of-relations.html

Theory of abelian bicategories of relations

Unlike ThBicategoryRelations, this theory uses additive notation.

References:

• Carboni & Walters, 1987, "Cartesian bicategories I", Sec. 5
• Baez & Erbele, 2015, "Categories in control"

Theory of a distributive bicategory of relations

References:

• Carboni & Walters, 1987, "Cartesian bicategories I", Remark 3.7 (mention in passing only)
• Patterson, 2017, "Knowledge representation in bicategories of relations", Section 9.2

FIXME: Should also inherit ThBicategoryOfRelations, but multiple inheritance is not yet supported.

The GAT that parameterizes Attributed C-sets A schema is comprised of a category C, a discrete category D, and a profunctor Attr : C^op x D → Set. In GAT form, this is given by extending the theory of categories with two extra types, AttrType for objects of D, and Attr, for elements of the sets given by the profunctor.

Base type for GAT expressions in categories or other categorical structures.

All symbolic expression types exported by Catlab.Theories are subtypes of this abstract type.

Base type for morphism expressions in categorical structures.

Base type for object expressions in categorical structures.

Collect generators of object in monoidal category as a vector.

Number of "dimensions" of object in monoidal category.

Distribute dagger over composition.

Distribute adjoint mates over composition and products.

Syntax for a double category.

Checks domains of morphisms but not 2-morphisms.

Algorithms on graphs based on C-sets.

Projection onto (weakly) connected components of a graph.

Returns a function in FinSet{Int} from the vertex set to the set of components.

(Weakly) connected components of a graph.

Returns a vector of vectors, which are the components of the graph.

Enumerate all paths of an acyclic graph, indexed by src+tgt

Longest paths in a DAG.

Returns a vector of integers whose i-th element is the length of the longest path to vertex i. Requires a topological sort, which is computed if it is not supplied.

Topological sort of a directed acyclic graph.

The depth-first search algorithm is adapted from the function topological_sort_by_dfs in Graphs.jl.

Transitive reduction of a DAG.

The algorithm computes the longest paths in the DAGs and keeps only the edges corresponding to longest paths of length 1. Requires a topological sort, which is computed if it is not supplied.

Theory of lattices as algebraic structures

This is one of two standard axiomatizations of a lattice, the other being ThLattice. Because the partial order is not present, this theory is merely an algebraic theory (no dependent types).

The partial order is recovered as $A ≤ B$ iff $A ∧ B = A$ iff $A ∨ B = B$. This definition could be reintroduced into a generalized algebraic theory using an equality type Eq(lhs::El, rhs::El)::TYPE combined with term constructors `meet_leq(eq::Eq(A∧B, A))::(A ≤ B) and join_leq(eq::Eq(A∨B, B))::(A ≤ B). We do not employ that trick here because at that point it is more convenient to just start with the poset structure, as in ThLattice.

ThAlgebraicLattice

      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:135 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:135 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:135 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:135 =#
      El::TYPE ⊣ []
      meet(A, B)::El ⊣ [A::El, B::El]
      top()::El ⊣ []
      (meet(meet(A, B), C) == meet(A, meet(B, C))) ⊣ [A::El, B::El, C::El]
      (meet(A, top()) == A) ⊣ [A::El]
      (meet(top(), A) == A) ⊣ [A::El]
      (meet(A, B) == meet(B, A)) ⊣ [A::El, B::El]
      (meet(A, A) == A) ⊣ [A::El]
      join(A, B)::El ⊣ [A::El, B::El]
      bottom()::El ⊣ []
      (join(join(A, B), C) == join(A, join(B, C))) ⊣ [A::El, B::El, C::El]
      (join(A, bottom()) == A) ⊣ [A::El]
      (join(bottom(), A) == A) ⊣ [A::El]
      (join(A, B) == join(B, A)) ⊣ [A::El, B::El]
      (join(A, A) == A) ⊣ [A::El]
      (join(A, meet(A, B)) == A) ⊣ [A::El, B::El]
      (meet(A, join(A, B)) == A) ⊣ [A::El, B::El]

Categories of matrices.

Domain or codomain of a Julia matrix of a specific type.

Object in the category of matrices of this type.

Biproduct category of Julia matrices of specific type.

The matrices can be dense or sparse, and the element type can be any commutative rig (commutative semiring): any Julia type implementing +, *, zero, one and obeying the axioms. Note that commutativity is required only in order to define braid.

For a similar design (only for sparse matrices) by the Julia core developers, see SemiringAlgebra.jl and accompanying short paper.

The "vec-permutation" matrix, aka the "perfect shuffle" permutation matrix.

This formula is (Henderson & Searle, 1981, "The vec-permutation matrix, the vec operator and Kronecker products: a review", Equation 18). Many other formulas are given there.

Theory of an opindexed monoidal category with lax transition functors.

This is a pseudofunctor into MonCatLax, the 2-category of monoidal categories, lax monoidal functors, and monoidal natural transformations. In (Hofstra & De Marchi 2006), these are called simply "(op)indexed monoidal categories," but that is not the standard usage.

References:

• Hofstra & De Marchi, 2006: Descent for monads
• Moeller & Vasilakopoulou, 2020: Monoidal Grothendieck construction, Remark 3.18 [this paper is about monoidal indexed categories, a different notion!]

ThOpindexedMonoidalCategoryLax

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      Fib(ob)::TYPE ⊣ [ob::Ob]
      FibHom(dom, codom)::TYPE ⊣ [A::Ob, dom::Fib(A), codom::Fib(A)]
      id(X)::FibHom(X, X) ⊣ [A::Ob, X::Fib(A)]
      compose(u, v)::FibHom(X, Z) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(X, Y), v::FibHom(Y, Z)]
      act(X, f)::Fib(B) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      act(u, f)::FibHom(act(X, f), act(Y, f)) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y), f::Hom(A, B)]
      (compose(compose(u, v), w) == compose(u, compose(v, w))) ⊣ [A::Ob, W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(W, X), v::FibHom(X, Y), w::FibHom(Y, Z)]
      (compose(u, id(X)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (compose(id(X), u) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (act(compose(u, v), f) == compose(act(u, f), act(v, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), f::Hom(A, B), u::FibHom(X, Y), v::FibHom(Y, Z)]
      (act(id(X), f) == id(act(X, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      (act(X, compose(f, g)) == act(act(X, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), f::Hom(A, B), g::Hom(A, C)]
      (act(u, compose(f, g)) == act(act(u, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), Y::Fib(A), f::Hom(A, B), g::Hom(B, C), u::FibHom(X, Y)]
      (act(X, id(A)) == X) ⊣ [A::Ob, X::Fib(A)]
      (act(u, id(A)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:102 =#
      otimes(X, Y)::Fib(A) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]
      otimes(u, v)::FibHom(otimes(X, W), otimes(Y, Z)) ⊣ [A::Ob, W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(X, Y), v::FibHom(W, Z)]
      munit(A)::Fib(A) ⊣ [A::Ob]
      (otimes(otimes(X, Y), Z) == otimes(X, otimes(Y, Z))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A)]
      (otimes(munit(A), X) == X) ⊣ [A::Ob, X::Fib(A)]
      (otimes(X, munit(A)) == X) ⊣ [A::Ob, X::Fib(A)]
      (otimes(otimes(u, v), w) == otimes(u, otimes(v, w))) ⊣ [A::Ob, U::Fib(A), V::Fib(A), W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(U, X), v::FibHom(V, Y), w::FibHom(W, Z)]
      (otimes(id(munit(A)), u) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (otimes(u, id(munit(A))) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (compose(otimes(t, u), otimes(v, w)) == otimes(compose(t, v), compose(u, w))) ⊣ [A::Ob, U::Fib(A), V::Fib(A), W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), t::FibHom(U, V), v::FibHom(V, W), u::FibHom(X, Y), w::FibHom(Y, Z)]
      (id(otimes(X, Y)) == otimes(id(X), id(Y))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]
      
      otimes(f, X, Y)::FibHom(otimes(act(X, f), act(Y, f)), act(otimes(X, Y), f)) ⊣ [A::Ob, B::Ob, f::Hom(A, B), X::Fib(A), Y::Fib(A)]
      munit(f)::FibHom(munit(B), act(munit(A), f)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, X, Y), act(otimes(u, v), f)) == compose(otimes(act(u, f), act(v, f)), otimes(f, Z, W))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), W::Fib(A), f::Hom(A, B), u::FibHom(X, Z), v::FibHom(Y, W)]
      (otimes(compose(f, g), X, Y) == compose(otimes(g, act(X, f), act(Y, f)), act(otimes(f, X, Y), g))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(B, C), X::Fib(A), Y::Fib(A)]
      (otimes(id(A), X, Y) == id(otimes(X, Y))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]

Theory of a pointed set-enriched category. We axiomatize a category equipped with zero morphisms.

A functor from an ordinary category into a freely generated pointed-set enriched category, equivalently, a pointed-set enriched category in which no two nonzero maps compose to a zero map, is a good notion of a functor that's total on objects and partial on morphisms.

ThPointedSetCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      zeromap(A, B)::Hom(A, B) ⊣ [A::Ob, B::Ob]
      (compose(zeromap(A, B), f) == zeromap(A, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(B, C)]
      (compose(g, zeromap(A, B)) == zeromap(A, C)) ⊣ [A::Ob, B::Ob, C::Ob, g::Hom(C, A)]

Algebra of subobjects in a category.

This module defines the interface for subobjects as well as some generic algorithm for computing subobjects using limits and colimits. Concrete instances such as subsets (subobjects in Set or FinSet) and sub-C-sets (subobjects in C-Set) are defined elsewhere.

Theory of lattice of subobjects in a coherent category, such as a pretopos.

The axioms are omitted since this theory is the same as the theory Catlab.Theories.ThAlgebraicLattice except that the lattice elements are dependent on another type. In fact, if we supported GAT morphisms, it should be possible to define a projection morphism of GATs from ThSubobjectLattice to ThAlgebraicLattice that sends Ob to the unit type.

Theory of Heyting algebra of subobjects in a Heyting category, such as a topos.

Theory of bi-Heyting algebra of subobjects in a bi-Heyting topos, such as a presheaf topos.

Abstract type for algorithm to compute operation(s) on subobjects.

Algorithm to compute subobject operations using limits and/or colimits.

Subobject in a category.

By definition, a subobject of an object $X$ in a category is a monomorphism into $X$. This is the default representation of a subobject. Certain categories may support additional representations. For example, if the category has a subobject classifier $Ω$, then subobjects of $X$ are also morphisms $X → Ω$.

Join (union) of subobjects.

Bottom (empty) subobject.

Meet (intersection) of subobjects.

Top (full) subobject.

Theory of a rig category, also known as a bimonoidal category

Rig categories are the most general in the hierarchy of distributive monoidal structures.

Question: Do we also want the distributivty and absorption isomorphisms? Usually we ignore coherence isomorphisms such as associators and unitors.

FIXME: This theory should also inherit ThMonoidalCategory, but multiple inheritance is not supported.

ThRigCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []

Theory of semiadditive categories

Mathematically the same as ThBiproductCategory but written additively, instead of multiplicatively.

ThSemiadditiveCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      (compose(oplus(plus(A), id(A)), plus(A)) == compose(oplus(id(A), plus(A)), plus(A))) ⊣ [A::Ob]
      (compose(oplus(zero(A), id(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (compose(oplus(id(A), zero(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (plus(A) == compose(swap(A, A), plus(A))) ⊣ [A::Ob]
      (plus(oplus(A, B)) == compose(oplus(oplus(id(A), swap(B, A)), id(B)), oplus(plus(A), plus(B)))) ⊣ [A::Ob, B::Ob]
      (zero(oplus(A, B)) == oplus(zero(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (plus(mzero()) == id(mzero())) ⊣ []
      (zero(mzero()) == id(mzero())) ⊣ []
      
      mcopy(A)::Hom(A, oplus(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:157 =#
      delete(A)::Hom(A, mzero()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:159 =#
      (mcopy(A) == compose(mcopy(A), swap(A, A))) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(mcopy(A), id(A))) == compose(mcopy(A), oplus(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      
      pair(f, g)::Hom(A, oplus(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      proj1(A, B)::Hom(oplus(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(oplus(A, B), B) ⊣ [A::Ob, B::Ob]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      plus(f, g)::Hom(A, B) ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B)]
      (compose(f, mcopy(B)) == compose(mcopy(A), oplus(f, f))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(f, delete(B)) == delete(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(plus(A), mcopy(A)) == compose(compose(oplus(mcopy(A), mcopy(A)), oplus(oplus(id(A), swap(A, A)), id(A))), oplus(plus(A), plus(A)))) ⊣ [A::Ob]
      (compose(plus(A), delete(A)) == oplus(delete(A), delete(A))) ⊣ [A::Ob]
      (compose(zero(A), mcopy(A)) == oplus(zero(A), zero(A))) ⊣ [A::Ob]
      (compose(zero(A), delete(A)) == id(mzero())) ⊣ [A::Ob]

Theory of lattice of subobjects in a coherent category, such as a pretopos.

The axioms are omitted since this theory is the same as the theory Catlab.Theories.ThAlgebraicLattice except that the lattice elements are dependent on another type. In fact, if we supported GAT morphisms, it should be possible to define a projection morphism of GATs from ThSubobjectLattice to ThAlgebraicLattice that sends Ob to the unit type.

ThSubobjectLattice

      Ob::TYPE ⊣ []
      Sub(ob)::TYPE ⊣ [ob::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      meet(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      join(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      top(X)::Sub(X) ⊣ [X::Ob]
      bottom(X)::Sub(X) ⊣ [X::Ob]

Theory of monoidal categories with diagonals

A monoidal category with diagonals is a symmetric monoidal category equipped with coherent operations of copying and deleting, also known as a supply of commutative comonoids. Unlike in a cartesian category, the naturality axioms need not be satisfied.

References:

• Fong & Spivak, 2019, "Supplying bells and whistles in symmetric monoidal categories" (arxiv:1908.02633)
• Selinger, 2010, "A survey of graphical languages for monoidal categories", Section 6.6: "Cartesian center"
• Selinger, 1999, "Categorical structure of asynchrony"

ThMonoidalCategoryWithDiagonals

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:178 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:180 =#
      (compose(mcopy(A), otimes(mcopy(A), id(A))) == compose(mcopy(A), otimes(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), braid(A, A)) == mcopy(A)) ⊣ [A::Ob]
      (mcopy(otimes(A, B)) == compose(otimes(mcopy(A), mcopy(B)), otimes(otimes(id(A), braid(A, B)), id(B)))) ⊣ [A::Ob, B::Ob]
      (delete(otimes(A, B)) == otimes(delete(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (mcopy(munit()) == id(munit())) ⊣ []
      (delete(munit()) == id(munit())) ⊣ []

Theory of a distributive category

A distributive category is a distributive monoidal category whose tensor product is the cartesian product, see ThDistributiveMonoidalCategory.

FIXME: Should also inherit ThCartesianCategory.

ThDistributiveCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:33 =#
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      (copair(f, g) == compose(oplus(f, g), plus(C))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      (coproj1(A, B) == oplus(id(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (coproj2(A, B) == oplus(zero(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:68 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:70 =#
      
      pair(f, g)::Hom(A, otimes(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      proj1(A, B)::Hom(otimes(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(otimes(A, B), B) ⊣ [A::Ob, B::Ob]
      (pair(f, g) == compose(mcopy(C), otimes(f, g))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(C, A), g::Hom(C, B)]
      (proj1(A, B) == otimes(id(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (proj2(A, B) == otimes(delete(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(f, mcopy(B)) == compose(mcopy(A), otimes(f, f))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(f, delete(B)) == delete(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Draw wiring diagrams using Compose.jl.

Internal data type for configurable options of Compose.jl wiring diagrams.

A Compose context together with a given width and height.

We need this type because contexts have no notion of size or aspect ratio, but wiring diagram layouts have fixed aspect ratios.

Get Compose.jl properties for box.

Draw a form with centered text label in Compose.

Draw a wiring diagram in Compose.jl using the given layout.

Draw a continuous piecewise cubic Bezier curve in Compose.

The points are given by a vector [p1, c1, c2, p2, c3, c4, p3, ...] of length 3n+1 where n >=1 is the number of Bezier curves.

Draw an atomic box in Compose.jl.

Draw a rounded rectangle in Compose.

Control points for Bezier curve from endpoints and unit tangent vectors.

Draw a wiring diagram in Compose.jl.

Theory of monoidal categories with bidiagonals

The terminology is nonstandard (is there any standard terminology?) but is supposed to mean a monoidal category with coherent diagonals and codiagonals. Unlike in a biproduct category, the naturality axioms need not be satisfied.

ThMonoidalCategoryWithBidiagonals

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:178 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:180 =#
      (compose(mcopy(A), otimes(mcopy(A), id(A))) == compose(mcopy(A), otimes(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), braid(A, A)) == mcopy(A)) ⊣ [A::Ob]
      (mcopy(otimes(A, B)) == compose(otimes(mcopy(A), mcopy(B)), otimes(otimes(id(A), braid(A, B)), id(B)))) ⊣ [A::Ob, B::Ob]
      (delete(otimes(A, B)) == otimes(delete(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (mcopy(munit()) == id(munit())) ⊣ []
      (delete(munit()) == id(munit())) ⊣ []
      
      mmerge(A)::Hom(otimes(A, A), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:248 =#
      create(A)::Hom(munit(), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:250 =#

Theory of copresheaves.

Axiomatized as a covariant category action.

ThCopresheaf

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      El(ob)::TYPE ⊣ [ob::Ob]
      act(x, f)::El(B) ⊣ [A::Ob, B::Ob, x::El(A), f::Hom(A, B)]
      (act(act(x, f), g) == act(x, compose(f, g))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(B, C), x::El(A)]
      (act(x, id(A)) == x) ⊣ [A::Ob, x::El(A)]

Theory of hypergraph categories, in additive notation

Mathematically the same as ThHypergraphCategory but with different notation.

ThHypergraphCategoryAdditive

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      mcopy(A)::Hom(A, oplus(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:223 =#
      delete(A)::Hom(A, mzero()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:225 =#
      mmerge(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:227 =#
      create(A)::Hom(mzero(), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:229 =#
      dunit(A)::Hom(mzero(), oplus(A, A)) ⊣ [A::Ob]
      dcounit(A)::Hom(oplus(A, A), mzero()) ⊣ [A::Ob]
      dagger(f)::Hom(B, A) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Theory of thin categories

Thin categories have at most one morphism between any two objects and are isomorphic to preorders.

ThThinCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      (f == g) ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B)]

Data structure for (directed) wiring diagrams, aka string diagrams.

A (directed) wiring diagram consists of a collection of boxes with input and output ports connected by wires. A box can be atomic (possessing no internal structure) or can itself be a wiring diagram. Thus, wiring diagrams can be nested recursively. Wiring diagrams are closely related to what the CS literature calls "directed graphs with ports" or more simply "port graphs". The main difference is that a wiring diagram has an "outer box": a wiring diagram has its own ports that can be connected to the ports of its boxes.

This module provides a generic data structure for wiring diagrams. Arbitrary data can be attached to the boxes, ports, and wires of a wiring diagram. The diagrams are "abstract" in the sense that they cannot be directly rendered as raster or vector graphics. However, they form a useful intermediate representation that can be serialized to and from GraphML or translated into Graphviz or other declarative diagram languages.

Base type for any box (node) in a wiring diagram.

This type represents an arbitrary black box with inputs and outputs.

An atomic box in a wiring diagram.

These boxes have no internal structure.

A port on a box to which wires can be connected.

Kind of port: input or output.

A wire connecting one port to another.

Graph underlying a directed wiring diagram.

Are the two wiring diagrams equal?

Warning: This method checks equality of the underlying C-set representation. Use is_isomorphic to check isomorphism of wiring diagrams.

Grapn underlying wiring diagram, including parts for noin-internal wires.

The graph has two special vertices representing the input and output boundaries of the outer box.

Encapsulate multiple boxes within a single sub-diagram.

This operation is a (one-sided) inverse to subsitution, see substitute.

Create an encapsulating box for a set of boxes in a wiring diagram.

To a first approximation, the union of input ports of the given boxes will become the inputs ports of the encapsulating box and likewise for the output ports. However, when copies or merges occur, as in a cartesian or cocartesian category, a simplification procedure may reduce the number of ports on the encapsulating box.

Specifically:

1. Each input port of an encapsulated box will have at most one incoming wire

from the encapsulating outer box, and each output port of an encapsulated box will have at most one outgoing wire to the encapsulating outer box.

1. A set of ports connected to the same outside (non-encapsulated) ports will be

simplified into a single port of the encapsulating box.

See also induced_subdiagram.

Get all wires coming into the box.

Get all wires coming into the port.

The wiring diagram induced by a subset of its boxes.

See also encapsulated_subdiagram.

Graph underlying wiring diagram, with edges for internal wires only.

Operadic composition of wiring diagrams.

This generic function has two different signatures, corresponding to the "full" and "partial" notions of operadic composition (Yau, 2018, Operads of Wiring Diagrams, Definitions 2.3 and 2.10).

This operation is a simple wrapper around substitute.

Get all wires coming out of the box.

Get all wires coming out of the port.

Wiring diagram with a single box connected to the outer ports.

Substitute wiring diagrams for boxes.

Performs one or more substitutions. When performing multiple substitutions, the substitutions are simultaneous.

This operation implements the operadic composition of wiring diagrams, see also ocompose.

Substitute wires of sub-diagram into containing wiring diagram.

Check compatibility of source and target ports.

The default implementation is a no-op.

Get all wires coming into or out of the box.

Theory of a rig category, also known as a bimonoidal category

Rig categories are the most general in the hierarchy of distributive monoidal structures.

Question: Do we also want the distributivty and absorption isomorphisms? Usually we ignore coherence isomorphisms such as associators and unitors.

FIXME: This theory should also inherit ThMonoidalCategory, but multiple inheritance is not supported.

ThRigCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []

Theory of an opindexed, or covariantly indexed, category.

An opindexed category is a Cat-valued pseudofunctor. For simplicitly, we assume that the functor is strict.

Just as a copresheaf, or Set-valued functor, can be seen as a category action on a family of sets, an opindexed category can be seen as a category action on a family of categories. This picture guides our axiomatization of an opindexed category as a generalized algebraic theory. The symbol * is used for the actions since a common mathematical notation for the "pushforward functor" induced by an indexing morphism $f: A → B$ is $f_*: F(A) o F(B)$.

ThOpindexedCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      Fib(ob)::TYPE ⊣ [ob::Ob]
      FibHom(dom, codom)::TYPE ⊣ [A::Ob, dom::Fib(A), codom::Fib(A)]
      id(X)::FibHom(X, X) ⊣ [A::Ob, X::Fib(A)]
      compose(u, v)::FibHom(X, Z) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(X, Y), v::FibHom(Y, Z)]
      act(X, f)::Fib(B) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      act(u, f)::FibHom(act(X, f), act(Y, f)) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y), f::Hom(A, B)]
      (compose(compose(u, v), w) == compose(u, compose(v, w))) ⊣ [A::Ob, W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(W, X), v::FibHom(X, Y), w::FibHom(Y, Z)]
      (compose(u, id(X)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (compose(id(X), u) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (act(compose(u, v), f) == compose(act(u, f), act(v, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), f::Hom(A, B), u::FibHom(X, Y), v::FibHom(Y, Z)]
      (act(id(X), f) == id(act(X, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      (act(X, compose(f, g)) == act(act(X, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), f::Hom(A, B), g::Hom(A, C)]
      (act(u, compose(f, g)) == act(act(u, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), Y::Fib(A), f::Hom(A, B), g::Hom(B, C), u::FibHom(X, Y)]
      (act(X, id(A)) == X) ⊣ [A::Ob, X::Fib(A)]
      (act(u, id(A)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]

Theory of an opindexed monoidal category with lax transition functors.

This is a pseudofunctor into MonCatLax, the 2-category of monoidal categories, lax monoidal functors, and monoidal natural transformations. In (Hofstra & De Marchi 2006), these are called simply "(op)indexed monoidal categories," but that is not the standard usage.

References:

• Hofstra & De Marchi, 2006: Descent for monads
• Moeller & Vasilakopoulou, 2020: Monoidal Grothendieck construction, Remark 3.18 [this paper is about monoidal indexed categories, a different notion!]

ThOpindexedMonoidalCategoryLax

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      Fib(ob)::TYPE ⊣ [ob::Ob]
      FibHom(dom, codom)::TYPE ⊣ [A::Ob, dom::Fib(A), codom::Fib(A)]
      id(X)::FibHom(X, X) ⊣ [A::Ob, X::Fib(A)]
      compose(u, v)::FibHom(X, Z) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(X, Y), v::FibHom(Y, Z)]
      act(X, f)::Fib(B) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      act(u, f)::FibHom(act(X, f), act(Y, f)) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y), f::Hom(A, B)]
      (compose(compose(u, v), w) == compose(u, compose(v, w))) ⊣ [A::Ob, W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(W, X), v::FibHom(X, Y), w::FibHom(Y, Z)]
      (compose(u, id(X)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (compose(id(X), u) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (act(compose(u, v), f) == compose(act(u, f), act(v, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), f::Hom(A, B), u::FibHom(X, Y), v::FibHom(Y, Z)]
      (act(id(X), f) == id(act(X, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      (act(X, compose(f, g)) == act(act(X, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), f::Hom(A, B), g::Hom(A, C)]
      (act(u, compose(f, g)) == act(act(u, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), Y::Fib(A), f::Hom(A, B), g::Hom(B, C), u::FibHom(X, Y)]
      (act(X, id(A)) == X) ⊣ [A::Ob, X::Fib(A)]
      (act(u, id(A)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:102 =#
      otimes(X, Y)::Fib(A) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]
      otimes(u, v)::FibHom(otimes(X, W), otimes(Y, Z)) ⊣ [A::Ob, W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(X, Y), v::FibHom(W, Z)]
      munit(A)::Fib(A) ⊣ [A::Ob]
      (otimes(otimes(X, Y), Z) == otimes(X, otimes(Y, Z))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A)]
      (otimes(munit(A), X) == X) ⊣ [A::Ob, X::Fib(A)]
      (otimes(X, munit(A)) == X) ⊣ [A::Ob, X::Fib(A)]
      (otimes(otimes(u, v), w) == otimes(u, otimes(v, w))) ⊣ [A::Ob, U::Fib(A), V::Fib(A), W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(U, X), v::FibHom(V, Y), w::FibHom(W, Z)]
      (otimes(id(munit(A)), u) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (otimes(u, id(munit(A))) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (compose(otimes(t, u), otimes(v, w)) == otimes(compose(t, v), compose(u, w))) ⊣ [A::Ob, U::Fib(A), V::Fib(A), W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), t::FibHom(U, V), v::FibHom(V, W), u::FibHom(X, Y), w::FibHom(Y, Z)]
      (id(otimes(X, Y)) == otimes(id(X), id(Y))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]
      
      otimes(f, X, Y)::FibHom(otimes(act(X, f), act(Y, f)), act(otimes(X, Y), f)) ⊣ [A::Ob, B::Ob, f::Hom(A, B), X::Fib(A), Y::Fib(A)]
      munit(f)::FibHom(munit(B), act(munit(A), f)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, X, Y), act(otimes(u, v), f)) == compose(otimes(act(u, f), act(v, f)), otimes(f, Z, W))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), W::Fib(A), f::Hom(A, B), u::FibHom(X, Z), v::FibHom(Y, W)]
      (otimes(compose(f, g), X, Y) == compose(otimes(g, act(X, f), act(Y, f)), act(otimes(f, X, Y), g))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(B, C), X::Fib(A), Y::Fib(A)]
      (otimes(id(A), X, Y) == id(otimes(X, Y))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]

Theory of symmetric monoidal categories, in additive notation

Mathematically the same as ThSymmetricMonoidalCategory but with different notation.

ThSymmetricMonoidalCategoryAdditive

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]

Theory of additive categories

An additive category is a biproduct category enriched in abelian groups. Thus, it is a semiadditive category where the hom-monoids have negatives.

ThAdditiveCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      (compose(oplus(plus(A), id(A)), plus(A)) == compose(oplus(id(A), plus(A)), plus(A))) ⊣ [A::Ob]
      (compose(oplus(zero(A), id(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (compose(oplus(id(A), zero(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (plus(A) == compose(swap(A, A), plus(A))) ⊣ [A::Ob]
      (plus(oplus(A, B)) == compose(oplus(oplus(id(A), swap(B, A)), id(B)), oplus(plus(A), plus(B)))) ⊣ [A::Ob, B::Ob]
      (zero(oplus(A, B)) == oplus(zero(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (plus(mzero()) == id(mzero())) ⊣ []
      (zero(mzero()) == id(mzero())) ⊣ []
      
      mcopy(A)::Hom(A, oplus(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:157 =#
      delete(A)::Hom(A, mzero()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:159 =#
      (mcopy(A) == compose(mcopy(A), swap(A, A))) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(mcopy(A), id(A))) == compose(mcopy(A), oplus(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      
      pair(f, g)::Hom(A, oplus(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      proj1(A, B)::Hom(oplus(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(oplus(A, B), B) ⊣ [A::Ob, B::Ob]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      plus(f, g)::Hom(A, B) ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B)]
      (compose(f, mcopy(B)) == compose(mcopy(A), oplus(f, f))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(f, delete(B)) == delete(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(plus(A), mcopy(A)) == compose(compose(oplus(mcopy(A), mcopy(A)), oplus(oplus(id(A), swap(A, A)), id(A))), oplus(plus(A), plus(A)))) ⊣ [A::Ob]
      (compose(plus(A), delete(A)) == oplus(delete(A), delete(A))) ⊣ [A::Ob]
      (compose(zero(A), mcopy(A)) == oplus(zero(A), zero(A))) ⊣ [A::Ob]
      (compose(zero(A), delete(A)) == id(mzero())) ⊣ [A::Ob]
      
      antipode(A)::Hom(A, A) ⊣ [A::Ob]
      (compose(antipode(A), f) == compose(f, antipode(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(compose(mcopy(A), oplus(id(A), antipode(A))), plus(A)) == compose(delete(A), zero(A))) ⊣ [A::Ob]
      (compose(compose(mcopy(A), oplus(antipode(A), id(A))), plus(A)) == compose(delete(A), zero(A))) ⊣ [A::Ob]

Theory of thin symmetric monoidal category

Thin SMCs are isomorphic to commutative monoidal prosets.

ThThinSymmetricMonoidalCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      (f == g) ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B)]

Theory of compact closed categories

ThCompactClosedCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      hom(A, B)::Ob ⊣ [A::Ob, B::Ob]
      ev(A, B)::Hom(otimes(hom(A, B), A), B) ⊣ [A::Ob, B::Ob]
      curry(A, B, f)::Hom(A, hom(B, C)) ⊣ [C::Ob, A::Ob, B::Ob, f::Hom(otimes(A, B), C)]
      
      dual(A)::Ob ⊣ [A::Ob]
      dunit(A)::Hom(munit(), otimes(dual(A), A)) ⊣ [A::Ob]
      dcounit(A)::Hom(otimes(A, dual(A)), munit()) ⊣ [A::Ob]
      mate(f)::Hom(dual(B), dual(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (hom(A, B) == otimes(B, dual(A))) ⊣ [A::Ob, B::Ob]
      (ev(A, B) == otimes(id(B), compose(braid(dual(A), A), dcounit(A)))) ⊣ [A::Ob, B::Ob]
      (curry(A, B, f) == compose(otimes(id(A), compose(dunit(B), braid(dual(B), B))), otimes(f, id(dual(B))))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(otimes(A, B), C)]

Lay out and draw wiring diagrams using Graphviz.

This module requires Graphviz v2.42 or higher.

Draw an undirected wiring diagram using Graphviz.

Creates an undirected, bipartite Graphviz graph, with the boxes and outer ports of the diagram becoming nodes of one kind and the junctions of the diagram becoming nodes of the second kind.

Arguments

• graph_name="G": name of Graphviz graph
• prog="neato": Graphviz program, usually "neato" or "fdp"
• box_labels=false: if boolean, whether to label boxes with their number; if a symbol, name of data attribute for box label
• port_labels=false: whether to label ports with their number
• junction_labels=false: if boolean, whether to label junctions with their number; if a symbol, name of data attribute for junction label
• junction_size="0.075": size of junction nodes, in inches
• implicit_junctions=false: whether to represent a junction implicity as a wire when it has exactly two incident ports
• graph_attrs=Dict(): top-level graph attributes
• node_attrs=Dict(): top-level node attributes
• edge_attrs=Dict(): top-level edge attributes

Draw a circular port graph using Graphviz.

Creates a Graphviz graph. Ports are currently not respected in the image, but the port index for each box can be displayed to provide clarification.

Arguments

• graph_name="G": name of Graphviz graph
• prog="neato": Graphviz program, usually "neato" or "fdp"
• box_labels=false: whether to label boxes with their number
• port_labels=false: whether to label ports with their number
• graph_attrs=Dict(): top-level graph attributes
• node_attrs=Dict(): top-level node attributes
• edge_attrs=Dict(): top-level edge attributes

TODO: The lack of ports might be able to be resolved by introducing an extra node per port which is connected to its box with an edge of length 0.

Draw a wiring diagram using Graphviz.

The input can also be a morphism expression, in which case it is first converted into a wiring diagram. This function requires Graphviz v2.42 or higher.

Arguments

• graph_name="G": name of Graphviz digraph
• orientation=TopToBottom: orientation of layout. One of LeftToRight, RightToLeft, TopToBottom, or BottomToTop.
• node_labels=true: whether to label the nodes
• labels=false: whether to label the edges
• label_attr=:label: what kind of edge label to use (if labels is true). One of :label, :xlabel, :headlabel, or :taillabel.
• port_size="24": minimum size of ports on box, in points
• junction_size="0.05": size of junction nodes, in inches
• outer_ports=true: whether to display the outer box's input and output ports. If disabled, no incoming or outgoing wires will be shown either!
• anchor_outer_ports=true: whether to enforce ordering of the outer box's input and output, i.e., ordering of the incoming and outgoing wires
• graph_attrs=Dict(): top-level graph attributes
• node_attrs=Dict(): top-level node attributes
• edge_attrs=Dict(): top-level edge attributes
• cell_attrs=Dict(): main cell attributes in node HTML-like label

Create "HTML-like" node label for a box.

Create a label for an edge.

Escape special HTML characters: &, <, >, ", '

Adapted from HttpCommon.jl.

Graphviz box for a generic box.

Graphviz box for a junction.

Lay out directed wiring diagram using Graphviz.

Note: At this time, only the positions and sizes of the boxes, and the positions of the outer ports, are used. The positions of the box ports and the splines for the wires are ignored.

Graphviz box for the outer box of a wiring diagram.

Create invisible nodes for the input or output ports of an outer box.

Encode attributes for Graphviz HTML-like labels.

Layout orientation for Graphviz rank direction (rankdir).

Reference: https://www.graphviz.org/doc/info/attrs.html#k:rankdir

Lay out ports linearly, equispaced along a rectangular box.

FIXME: Should this be in WiringDiagramLayouts as an alternative layout method?

Create a label for the main content of a box.

Graphviz anchor for port.

Create horizontal "HTML-like" label for the input or output ports of a box.

Create vertical "HTML-like" label for the input or output ports of a box.

Graphviz rank direction (rankdir) for layout orientation.

Reference: https://www.graphviz.org/doc/info/attrs.html#k:rankdir

Theory of double categories

A strict double category $D$ is an internal category

$(S,T: D₁ ⇉ D₀, U: D₀ → D₁, *: D₁ ×_{D₀} D₁ → D₁)$

in Cat where

• objects of $D₀$ are objects of $D$
• morphisms of $D₀$ are arrows (vertical morphisms) of $D$
• objects of $D₁$ are proarrows (horizontal morphisms) of $D$
• morphisms of $D₁$ are cells of $D$.

The domain and codomain (top and bottom) of a cell are given by the domain and codomain in $D₁$ and the source and target (left and right) are given by the functors $S,T$.

ThDoubleCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Pro(src, tgt)::TYPE ⊣ [src::Ob, tgt::Ob]
      Cell(dom, codom, src, tgt)::TYPE ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, dom::Pro(A, B), codom::Pro(C, D), src::Hom(A, C), tgt::Hom(B, D)]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      compose(α, β)::Cell(m, p, compose(f, h), compose(g, k)) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z), f::Hom(A, B), g::Hom(X, Y), h::Hom(B, C), k::Hom(Y, Z), α::Cell(m, n, f, g), β::Cell(n, p, h, k)]
      id(m)::Cell(m, m, id(A), id(B)) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (compose(compose(α, β), γ) == compose(α, compose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, W), n::Pro(B, X), p::Pro(C, Y), q::Pro(D, Z), f::Hom(A, B), g::Hom(B, C), h::Hom(C, D), i::Hom(W, X), j::Hom(X, Y), k::Hom(Y, Z), α::Cell(m, n, f, i), β::Cell(n, p, g, j), γ::Cell(p, q, h, k)]
      (compose(α, id(n)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (compose(id(m), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      pcompose(m, n)::Pro(A, C) ⊣ [A::Ob, B::Ob, C::Ob, m::Pro(A, B), n::Pro(B, C)]
      pid(A)::Pro(A, A) ⊣ [A::Ob]
      pcompose(α, β)::Cell(pcompose(m, n), pcompose(p, q), f, h) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(X, Y), q::Pro(Y, Z), f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z), α::Cell(m, p, f, g), β::Cell(n, q, g, h)]
      pid(f)::Cell(pid(A), pid(B), f, f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (pcompose(pcompose(m, n), p) == pcompose(m, pcompose(n, p))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D)]
      (pcompose(m, pid(B)) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pid(A), m) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pcompose(α, β), γ) == pcompose(α, pcompose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D), u::Pro(W, X), v::Pro(X, Y), w::Pro(Y, Z), f::Hom(A, W), g::Hom(B, X), h::Hom(C, Y), k::Hom(D, Z), α::Cell(m, u, f, g), β::Cell(n, v, g, h), γ::Cell(p, w, h, k)]
      (pcompose(α, pid(g)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (pcompose(pid(f), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]

Categories of C-sets and attributed C-sets.

Colimit of attributed C-sets that stores the pointwise colimits in Set.

Wrapper type to interpret attributed C-set as a functor.

Limit of attributed C-sets that stores the pointwise limits in Set.

Common type for ACSetTransformation and CSetTransformation.

Transformation between attributed C-sets.

Homomorphisms of attributed C-sets generalize homomorphisms of C-sets (CSetTransformation), which you should understand before reading this.

A homomorphism of attributed C-sets with schema S: C ↛ A (a profunctor) is a natural transformation between the corresponding functors col(S) → Set, where col(S) is the collage of S. When the components on attribute types, indexed by objects of A, are all identity functions, the morphism is called tight; in general, it is called loose. With this terminology, acsets on a fixed schema are the objects of an ℳ-category (see Catlab.Theories.MCategory). Calling ACSetTransformation will construct a tight or loose morphism as appropriate, depending on which components are specified.

Since every tight morphism can be considered a loose one, the distinction between tight and loose may seem a minor technicality, but it has important consequences because limits and colimits in a category depend as much on the morphisms as on the objects. In particular, limits and colimits of acsets differ greatly depending on whether they are taken in the category of acsets with tight morphisms or with loose morphisms. Tight morphisms suffice for many purposes, including most applications of colimits. However, when computing limits of acsets, loose morphisms are usually preferable. For more information about limits and colimits in these categories, see TightACSetTransformation and LooseACSetTransformation.

Move components as first argument

A map f (from A to B) as a map from A to a subobject of B

i.e. get the image of f as a subobject of B

A map f (from A to B) as a map of subobjects of A to subjects of B

Transformation between C-sets.

Recall that a C-set homomorphism is a natural transformation: a transformation between functors C → Set satisfying the naturality axiom for every morphism, or equivalently every generating morphism, in C.

This data type records the data of a C-set transformation. Naturality is not strictly enforced but is expected to be satisfied. It can be checked using the function is_natural.

If the schema of the dom and codom has attributes, this has the semantics of being a valid C-set transformation on the combinatorial data alone (including attribute variables, if any).

Loose transformation between attributed C-sets.

Limits and colimits in the category of attributed C-sets and loose homomorphisms are computed pointwise on both objects and attribute types. This implies that (co)limits of Julia types must be computed. Due to limitations in the expressivity of Julia's type system, only certain simple kinds of (co)limits, such as products, are supported.

Alternatively, colimits involving loose acset transformations can be constructed with respect to explicitly given attribute type components for the legs of the cocone, via the keyword argument type_components to colimit and related functions. This uses the universal property of the colimit. To see how this works, notice that a diagram of acsets and loose acset transformations can be expressed as a diagram D: J → C-Set (for the C-sets) along with another diagram A: J → C-Set (for the attribute sets) and a natural transformation α: D ⇒ A (assigning attributes). Given a natural transformation τ: A ⇒ ΔB to a constant functor ΔB, with components given by type_components, the composite transformation α⋅τ: D ⇒ ΔB is a cocone under D, hence factors through the colimit cocone of D. This factoring yields an assigment of attributes to the colimit in C-Set.

For the distinction between tight and loose, see ACSetTranformation.

Sub-C-set represented componentwise as a collection of subsets.

Sub-C-set of a C-set.

Tight transformation between attributed C-sets.

The category of attributed C-sets and tight homomorphisms is isomorphic to a slice category of C-Set, as explained in our paper "Categorical Data Structures for Technical Computing". Colimits in this category thus reduce to colimits of C-sets, by a standard result about slice categories. Limits are more complicated and are currently not supported.

For the distinction between tight and loose, see ACSetTranformation.

Create FinDomFunction for morphism or attribute of attributed C-set.

Indices are included whenever they exist. Unlike the FinFunction constructor, the codomain of the result is always of type TypeSet.

Runtime error if there are any attributes in the column

Create FinFunction for morphism of attributed C-set.

Indices are included whenever they exist.

Create FinSet for object of attributed C-set.

Create VarSet for attribute type of attributed C-set.

Create SetFunction for morphism or attribute of attributed C-set.

For morphisms, the result is a FinFunction; for attributes, a FinDomFunction.

Create SetOb for object or attribute type of attributed C-set.

For objects, the result is a FinSet; for attribute types, a TypeSet.

Create TypeSet for object or attribute type of attributed C-set.

Copy parts from a set-valued FinDomFunctor to an ACSet.

preimage(f::ACSetTransformation,Y::StructACSet)

Inverse f (from A to B) as a map from subobjects of B to subobjects of A. Cast an ACSet to subobject, though this has a trivial answer when computing the preimage (it is necessarily the top subobject of A).

preimage(f::ACSetTransformation,Y::Subobject)

Inverse of f (from A to B) as a map of subobjects of B to subjects of A.

For any ACSet, X, a canonical map A→X where A has distinct variables for all attributes valued in attrtypes present in abstract (by default: all attrtypes)

Coerce an arbitrary julia function to a LooseVarFunction assuming no variables

Set data attributes of colimit of acsets using universal property.

Check whether an ACSetTransformation is still valid, despite possible deletion of elements in the codomain. An ACSetTransformation that isn't in bounds will throw an error, rather than return false, if run through is_natural.

is_cartesian(f,hs)

Checks if an acset transformation f is cartesian at the homs in the list hs. Expects the homs to be given as a list of Symbols.

Returns a dictionary whose keys are contained in the names in arrows(S) and whose value at :f, for an arrow (f,c,d), is a lazy iterator over the elements of X(c) on which α's naturality square for f does not commute. Components should be a NamedTuple or Dictionary with keys contained in the names of S's morphisms and values vectors or dicts defining partial functions from X(c) to Y(c).

Make colimit of acsets from colimits of sets, ignoring attributes.

Named tuple of vectors of FinFunctions → vector of C-set transformations.

Make limit of acsets from limits of underlying sets, ignoring attributes.

If one wants to consider the attributes of the apex, the following type_components - TBD abstract_product - places attribute variables in the apex attrfun - allows one to, instead of placing an attribute in the apex, apply a function to the values of the projections. Can be applied to an AttrType or an Attr (which takes precedence).

C-set → named tuple of sets.

Pretty-print failures of transformation to be natural.

See also: naturality_failures.

Vector of C-set transformations → named tuple of vectors of functions.

Diagram in C-Set → named tuple of diagrams in Set.

Vector of C-sets → named tuple of vectors of sets.

Find some part + attr that refers to an AttrVar. Throw error if none exists (i.e. i is a wandering variable).

Check naturality condition for a purported ACSetTransformation, α: X→Y. For each hom in the schema, e.g. h: m → n, the following square must commute:

     αₘ
  Xₘ --> Yₘ
Xₕ ↓  ✓  ↓ Yₕ
  Xₙ --> Yₙ
     αₙ

You're allowed to run this on a named tuple partly specifying an ACSetTransformation, though at this time the domain and codomain must be fully specified ACSets.

Variables are used for the attributes in the apex of limit of CSetTransformations when there happen to be attributes. However, a commutative monoid on the attribute type may be provided in order to avoid introducing variables.

A limit of a diagram of ACSets with LooseACSetTransformations.

For general diagram shapes, the apex of the categorical limit will not have clean Julia types for its attributes, i.e. predicates will be needed to further constrain them. product_attrs must be turned on in order to avoid an error in cases where predicates would be needed.

product_attrs=true will take a limit of the purely combinatorial data, and the attribute data of the apex is dictated purely by the ACSets that are have explicit cone legs: the value of an attribute (e.g. f) for the i'th part in the apex is the product (f(π₁(i)), ..., f(πₙ(i))) where π maps come from the combinatorial part of the limit legs. The type components of the j'th leg of the limit is just the j'th cartesian projection.

Implication of sub-C-sets.

By (Reyes et al 2004, Proposition 9.1.5), the implication $A ⟹ B$ for two sub-$C$-sets $A,B ↪ X$ is given by

$x ∈ (A ⟹ B)(c) iff ∀f: c → c′, x⋅f ∈ A(c′) ⟹ x⋅f ∈ B(c′)$

for all $c ∈ C$ and $x ∈ X(c)$. By the definition of implication and De Morgan's law in classical logic, this is equivalent to

$x ∉ (A ⟹ B)(c) iff ∃f: c → c′, x⋅f ∈ A(c′) ∧ x⋅f ∉ B(c′)$.

In this form, we can clearly see the duality to formula and algorithm for subtraction of sub-C-sets (subtract).

Subtraction of sub-C-sets.

By (Reyes et al 2004, Sec 9.1, pp. 144), the subtraction $A ∖ B$ for two sub-$C$-sets $A,B ↪ X$ is given by

$x ∈ (A ∖ B)(c) iff ∃f: c′ → c, ∃x′ ∈ f⁻¹⋅x, x′ ∈ A(c′) ∧ x′ ∉ B(c′)$

for all $c ∈ C$ and $x ∈ X(c)$. Compare with implies.

Theory of a proarrow equipment, or equipment for short

Equipments have also been called "framed bicategories," "fibrant double categories," and "gregarious double categories" (?!).

References:

• Shulman, 2008: Framed bicategories and monoidal fibrations
• Cruttwell & Shulman, 2010: A unified framework for generalized multicategories

ThEquipment

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Pro(src, tgt)::TYPE ⊣ [src::Ob, tgt::Ob]
      Cell(dom, codom, src, tgt)::TYPE ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, dom::Pro(A, B), codom::Pro(C, D), src::Hom(A, C), tgt::Hom(B, D)]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      compose(α, β)::Cell(m, p, compose(f, h), compose(g, k)) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z), f::Hom(A, B), g::Hom(X, Y), h::Hom(B, C), k::Hom(Y, Z), α::Cell(m, n, f, g), β::Cell(n, p, h, k)]
      id(m)::Cell(m, m, id(A), id(B)) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (compose(compose(α, β), γ) == compose(α, compose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, W), n::Pro(B, X), p::Pro(C, Y), q::Pro(D, Z), f::Hom(A, B), g::Hom(B, C), h::Hom(C, D), i::Hom(W, X), j::Hom(X, Y), k::Hom(Y, Z), α::Cell(m, n, f, i), β::Cell(n, p, g, j), γ::Cell(p, q, h, k)]
      (compose(α, id(n)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (compose(id(m), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      pcompose(m, n)::Pro(A, C) ⊣ [A::Ob, B::Ob, C::Ob, m::Pro(A, B), n::Pro(B, C)]
      pid(A)::Pro(A, A) ⊣ [A::Ob]
      pcompose(α, β)::Cell(pcompose(m, n), pcompose(p, q), f, h) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(X, Y), q::Pro(Y, Z), f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z), α::Cell(m, p, f, g), β::Cell(n, q, g, h)]
      pid(f)::Cell(pid(A), pid(B), f, f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (pcompose(pcompose(m, n), p) == pcompose(m, pcompose(n, p))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D)]
      (pcompose(m, pid(B)) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pid(A), m) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pcompose(α, β), γ) == pcompose(α, pcompose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D), u::Pro(W, X), v::Pro(X, Y), w::Pro(Y, Z), f::Hom(A, W), g::Hom(B, X), h::Hom(C, Y), k::Hom(D, Z), α::Cell(m, u, f, g), β::Cell(n, v, g, h), γ::Cell(p, w, h, k)]
      (pcompose(α, pid(g)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (pcompose(pid(f), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      
      companion(f)::Pro(A, B) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      conjoint(f)::Pro(B, A) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      companion_unit(f)::Cell(pid(A), companion(f), id(A), f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      companion_counit(f)::Cell(companion(f), pid(B), f, id(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      conjoint_unit(f)::Cell(pid(A), conjoint(f), f, id(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      conjoint_counit(f)::Cell(conjoint(f), pid(B), id(B), f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(companion_unit(f), companion_counit(f)) == pid(f)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (pcompose(companion_unit(f), companion_counit(f)) == id(companion(f))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(conjoint_unit(f), conjoint_counit(f)) == pid(f)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (pcompose(conjoint_counit(f), conjoint_unit(f)) == id(conjoint(f))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Theory of a category with (finite) coproducts

Finite coproducts are presented in biased style, via the nullary case (initial objects) and the binary case (binary coproducts). The axioms are dual to those of ThCategoryWithProducts.

For a monoidal category axiomatization of finite coproducts, see ThCocartesianCategory.

ThCategoryWithCoproducts

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Initial::TYPE ⊣ []
      Coproduct(foot1, foot2)::TYPE ⊣ [foot1::Ob, foot2::Ob]
      initial()::Initial ⊣ []
      ob(⊥)::Ob ⊣ [⊥::Initial]
      create(⊥, C)::Hom(ob(⊥), C) ⊣ [⊥::Initial, C::Ob]
      coproduct(A, B)::Coproduct(A, B) ⊣ [A::Ob, B::Ob]
      ob(⨆)::Ob ⊣ [A::Ob, B::Ob, ⨆::Coproduct(A, B)]
      coproj1(⨆)::Hom(A, ob(⨆)) ⊣ [A::Ob, B::Ob, ⨆::Coproduct(A, B)]
      coproj2(⨆)::Hom(B, ob(⨆)) ⊣ [A::Ob, B::Ob, ⨆::Coproduct(A, B)]
      copair(⨆, f, g)::Hom(ob(⨆), C) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), f::Hom(A, C), g::Hom(B, C)]
      (compose(coproj1(⨆), copair(⨆, f, g)) == f) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), f::Hom(A, C), g::Hom(B, C)]
      (compose(coproj2(⨆), copair(⨆, f, g)) == g) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), f::Hom(A, C), g::Hom(B, C)]
      (f == g) ⊣ [C::Ob, ⊥::Initial, f::Hom(ob(⊥), C), g::Hom(ob(⊥), C)]
      (copair(⨆, compose(coproj1(⨆), h), compose(coproj2(⨆), h)) == h) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), h::Hom(ob(⨆), C)]

Theory of presheaves.

Axiomatized as a contravariant category action.

ThPresheaf

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      El(ob)::TYPE ⊣ [ob::Ob]
      coact(f, x)::El(A) ⊣ [A::Ob, B::Ob, f::Hom(A, B), x::El(B)]
      (coact(f, coact(g, x)) == coact(compose(f, g), x)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(B, C), x::El(C)]
      (coact(id(A), x) == x) ⊣ [A::Ob, x::El(A)]

Theory of a distributive semiadditive category

This terminology is not standard but the concept occurs frequently. A distributive semiadditive category is a semiadditive category (or biproduct) category, written additively, with a tensor product that distributes over the biproduct.

FIXME: Should also inherit ThSemiadditiveCategory

ThDistributiveSemiadditiveCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:33 =#
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      (copair(f, g) == compose(oplus(f, g), plus(C))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      (coproj1(A, B) == oplus(id(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (coproj2(A, B) == oplus(zero(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      
      mcopy(A)::Hom(A, oplus(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:84 =#
      delete(A)::Hom(A, mzero()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:86 =#
      plus(f, g)::Hom(A, B) ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B)]
      pair(f, g)::Hom(A, oplus(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      proj1(A, B)::Hom(oplus(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(oplus(A, B), B) ⊣ [A::Ob, B::Ob]
      (compose(f, mcopy(B)) == compose(mcopy(A), oplus(f, f))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(f, delete(B)) == delete(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Graphviz drawing of categories, functors, diagrams, and related structures.

Visualize a function between finite sets using Graphviz.

Visualize a function (FinFunction) between two finite sets (FinSets). Reduces to drawing an undirected bipartite graph; see that method for more.

Theory of cartesian (monoidal) categories

For the traditional axiomatization of products, see ThCategoryWithProducts.

ThCartesianCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:178 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:180 =#
      (compose(mcopy(A), otimes(mcopy(A), id(A))) == compose(mcopy(A), otimes(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), braid(A, A)) == mcopy(A)) ⊣ [A::Ob]
      (mcopy(otimes(A, B)) == compose(otimes(mcopy(A), mcopy(B)), otimes(otimes(id(A), braid(A, B)), id(B)))) ⊣ [A::Ob, B::Ob]
      (delete(otimes(A, B)) == otimes(delete(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (mcopy(munit()) == id(munit())) ⊣ []
      (delete(munit()) == id(munit())) ⊣ []
      
      pair(f, g)::Hom(A, otimes(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      proj1(A, B)::Hom(otimes(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(otimes(A, B), B) ⊣ [A::Ob, B::Ob]
      (pair(f, g) == compose(mcopy(C), otimes(f, g))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(C, A), g::Hom(C, B)]
      (proj1(A, B) == otimes(id(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (proj2(A, B) == otimes(delete(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(f, mcopy(B)) == compose(mcopy(A), otimes(f, f))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(f, delete(B)) == delete(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

No documentation found.

Catlab.Theories.##2291 is of type Nothing.

Summary

struct Nothing

ThPointedSetSchema

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      zeromap(A, B)::Hom(A, B) ⊣ [A::Ob, B::Ob]
      (compose(zeromap(A, B), f) == zeromap(A, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(B, C)]
      (compose(g, zeromap(A, B)) == zeromap(A, C)) ⊣ [A::Ob, B::Ob, C::Ob, g::Hom(C, A)]
      
      AttrType::TYPE ⊣ []
      Attr(dom, codom)::TYPE ⊣ [dom::Ob, codom::AttrType]
      zeromap(A, X)::Attr(A, X) ⊣ [A::Ob, X::AttrType]
      compose(f, g)::Attr(A, X) ⊣ [A::Ob, B::Ob, X::AttrType, f::Hom(A, B), g::Attr(B, X)]
      (compose(f, zeromap(B, X)) == zeromap(A, X)) ⊣ [A::Ob, B::Ob, X::AttrType, f::Hom(A, B)]
      (compose(zeromap(A, B), f) == zeromap(A, X)) ⊣ [A::Ob, B::Ob, X::AttrType, f::Attr(B, X)]
      (compose(f, compose(g, a)) == compose(compose(f, g), a)) ⊣ [A::Ob, B::Ob, C::Ob, X::AttrType, f::Hom(A, B), g::Hom(B, C), a::Attr(C, X)]
      (compose(id(A), a) == a) ⊣ [A::Ob, X::AttrType, a::Attr(A, X)]

Data structures for graphs, based on C-sets.

This module provides the category theorist's four basic kinds of graphs: graphs (aka directed multigraphs), symmetric graphs, reflexive graphs, and symmetric reflexive graphs. It also defines half-edge graphs, which are isomorphic to symmetric graphs, and a few standard kinds of attributed graphs, such as weighted graphs.

The graphs API generally follows that of Graphs.jl, with some departures due to differences between the data structures.

Abstract type for graphs, aka directed multigraphs.

Abstract type for half-edge graphs, possibly with data attributes.

Abstract type for labeled graphs.

Abstract type for reflexive graphs, possibly with data attributes.

Abstract type for symmetric graph, possibly with data attributes.

Abstract type for symmetric reflexive graphs, possibly with data attributes.

Abstract type for symmetric weighted graphs.

Abstract type for weighted graphs.

A graph, also known as a directed multigraph.

A half-edge graph.

Half-edge graphs are a variant of undirected graphs whose edges are pairs of "half-edges" or "darts". Half-edge graphs are isomorphic to symmetric graphs but have a different data model.

Abstract type for C-sets that contain a graph.

This type encompasses C-sets where the schema for graphs is a subcategory of C. This includes, for example, graphs, symmetric graphs, and reflexive graphs, but not half-edge graphs.

Abstract type for C-sets that contain vertices.

This type encompasses C-sets where the schema C contains an object V interpreted as vertices. This includes, for example, graphs and half-edge graphs, but not bipartite graphs or wiring diagrams.

A labeled graph.

By convention, a "labeled graph" without qualification is a vertex-labeled graph. We do not require that the label be unique, and in this data type, the label attribute is not indexed.

A reflexive graph.

Reflexive graphs are graphs in which every vertex has a distinguished self-loop.

A symmetric graph, or graph with an orientation-reversing edge involution.

Symmetric graphs are closely related, but not identical, to undirected graphs.

A symmetric reflexive graph.

Symmetric reflexive graphs are both symmetric graphs (SymmetricGraph) and reflexive graphs (ReflexiveGraph) such that the reflexive loops are fixed by the edge involution.

A symmetric weighted graph.

A symmetric graph in which every edge has a numerical weight, preserved by the edge involution.

A weighted graph.

A graph in which every edge has a numerical weight.

Involution on half-edge(s) in a half-edge graph.

Involution on edge(s) in a symmetric graph.

Interchange src and tgt, keeping all other data the same

Add a dangling edge to a half-edge graph.

A "dangling edge" is a half-edge that is paired with itself under the half-edge involution. They are usually interpreted differently than "self-loops", i.e., a pair of distinct half-edges incident to the same vertex.

Add multiple dangling edges to a half-edge graph.

Add an edge to a graph.

Add multiple edges to a graph.

Add a vertex to a graph.

Add multiple vertices to a graph.

Add vertices with preallocated src/tgt indexes

Union of in-neighbors and out-neighbors in a graph.

Total degree of a vertex

Equivalent to length(all_neighbors(g,v)) but faster

Edges in a graph, or between two vertices in a graph.

Half-edges in a half-edge graph, or incident to a vertex.

Whether the graph has the given edge, or an edge between two vertices.

Whether the graph has the given vertex.

Subgraph induced by a set of a vertices.

The induced subgraph consists of the given vertices and all edges between vertices in this set.

Edges coming into a vertex

In-neighbors of vertex in a graph.

Number of edges in a graph, or between two vertices in a graph.

In a symmetric graph, this function counts both edges in each edge pair, so that the number of edges in a symmetric graph is twice the number of edges in the corresponding undirected graph (at least when the edge involution has no fixed points).

Neighbors of vertex in a graph.

In a graph, this function is an alias for outneighbors; in a symmetric graph, a vertex has the same out-neighbors and as in-neighbors, so the distinction is moot.

In the presence of multiple edges, neighboring vertices are given with multiplicity. To get the unique neighbors, call unique(neighbors(g)).

Number of vertices in a graph.

Edges coming out of a vertex

Out-neighbors of vertex in a graph.

Reflexive loop(s) of vertex (vertices) in a reflexive graph.

Remove an edge from a graph.

Remove multiple edges from a graph.

Remove a vertex from a graph.

When keep_edges is false (the default), all edges incident to the vertex are also deleted. When keep_edges is true, incident edges are preserved but their source/target vertices become undefined.

Remove multiple vertices from a graph.

Edges incident to any of the vertices are treated as in rem_vertex!.

Incident vertex (vertices) of half-edge(s) in a half-edge graph.

Vertices in a graph.

Weight(s) of edge(s) in a weighted graph.

Source vertex (vertices) of edges(s) in a graph.

Target vertex (vertices) of edges(s) in a graph.

Theory of a (finitely) cocomplete category

Finite colimits are presented in biased style, via finite coproducts and coequalizers. The axioms are dual to those of ThCompleteCategory.

ThCocompleteCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Initial::TYPE ⊣ []
      Coproduct(foot1, foot2)::TYPE ⊣ [foot1::Ob, foot2::Ob]
      initial()::Initial ⊣ []
      ob(⊥)::Ob ⊣ [⊥::Initial]
      create(⊥, C)::Hom(ob(⊥), C) ⊣ [⊥::Initial, C::Ob]
      coproduct(A, B)::Coproduct(A, B) ⊣ [A::Ob, B::Ob]
      ob(⨆)::Ob ⊣ [A::Ob, B::Ob, ⨆::Coproduct(A, B)]
      coproj1(⨆)::Hom(A, ob(⨆)) ⊣ [A::Ob, B::Ob, ⨆::Coproduct(A, B)]
      coproj2(⨆)::Hom(B, ob(⨆)) ⊣ [A::Ob, B::Ob, ⨆::Coproduct(A, B)]
      copair(⨆, f, g)::Hom(ob(⨆), C) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), f::Hom(A, C), g::Hom(B, C)]
      (compose(coproj1(⨆), copair(⨆, f, g)) == f) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), f::Hom(A, C), g::Hom(B, C)]
      (compose(coproj2(⨆), copair(⨆, f, g)) == g) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), f::Hom(A, C), g::Hom(B, C)]
      (f == g) ⊣ [C::Ob, ⊥::Initial, f::Hom(ob(⊥), C), g::Hom(ob(⊥), C)]
      (copair(⨆, compose(coproj1(⨆), h), compose(coproj2(⨆), h)) == h) ⊣ [A::Ob, B::Ob, C::Ob, ⨆::Coproduct(A, B), h::Hom(ob(⨆), C)]
      
      Coequalizer(f, g)::TYPE ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B)]
      coequalizer(f, g)::Coequalizer(f, g) ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B)]
      ob(eq)::Ob ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B), eq::Coequalizer(f, g)]
      proj(eq)::Hom(B, ob(eq)) ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B), eq::Coequalizer(f, g)]
      factorize(coeq, h, coeq_h)::Hom(ob(coeq), ob(coeq_h)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, B), coeq::Coequalizer(f, g), h::Hom(B, C), coeq_h::Coequalizer(compose(f, h), compose(g, h))]
      (compose(f, proj(coeq)) == compose(g, proj(coeq))) ⊣ [A::Ob, B::Ob, f::Hom(A, B), g::Hom(A, B), coeq::Coequalizer(f, g)]
      (proj(coeq) == id(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B), coeq::Coequalizer(f, f)]
      (compose(proj(coeq), factorize(coeq, h, coeq_h)) == compose(h, proj(coeq_h))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, B), h::Hom(B, C), coeq::Coequalizer(f, g), coeq_h::Coequalizer(compose(f, h), compose(g, h))]
      (factorize(coeq, compose(proj(coeq), k), coeq_k) == k) ⊣ [A::Ob, B::Ob, D::Ob, f::Hom(A, B), g::Hom(A, B), coeq::Coequalizer(f, g), k::Hom(ob(coeq), D), coeq_k::Coequalizer(compose(compose(f, proj(coeq)), k), compose(compose(g, proj(coeq)), k))]

Theory of traced monoidal categories

ThTracedMonoidalCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      trace(X, A, B, f)::Hom(A, B) ⊣ [X::Ob, A::Ob, B::Ob, f::Hom(otimes(X, A), otimes(X, B))]

Data structure for undirected wiring diagrams.

Abstract type for UWDs, typed or untyped, possibly with extra attributes.

Abstract type for C-sets that contain a UWD.

This type includes UWDs, scheduled UWDs, and nested UWDs.

A typed undirected wiring diagram.

A UWD whose ports and junctions must be compatibly typed.

An undirected wiring diagram.

The most basic kind of UWD, without types or other extra attributes.

Wire together two ports in an undirected wiring diagram.

A convenience method that creates and sets junctions as needed. Ports are only allowed to have one junction, so if both ports already have junctions, then the second port is assigned the junction of the first. The handling of the two arguments is otherwise symmetric.

FIXME: When both ports already have junctions, the two junctions should be merged. To do this, we must implement merge_junctions! and thus also rem_part!.

Undirected wiring diagram defined by a cospan.

The wiring diagram has a single box. The ports of this box, the outer ports, the junctions, and the connections between them are defined by the cospan. Thus, this function generalizes singleton_diagram.

See also: junction_diagram.

Undirected wiring diagram with no boxes, only junctions.

See also: singleton_diagram, cospan_diagram.

No documentation found.

Catlab.Theories.##2139 is of type Nothing.

Summary

struct Nothing

ThOpindexedMonoidalCategoryPre

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      Fib(ob)::TYPE ⊣ [ob::Ob]
      FibHom(dom, codom)::TYPE ⊣ [A::Ob, dom::Fib(A), codom::Fib(A)]
      id(X)::FibHom(X, X) ⊣ [A::Ob, X::Fib(A)]
      compose(u, v)::FibHom(X, Z) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(X, Y), v::FibHom(Y, Z)]
      act(X, f)::Fib(B) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      act(u, f)::FibHom(act(X, f), act(Y, f)) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y), f::Hom(A, B)]
      (compose(compose(u, v), w) == compose(u, compose(v, w))) ⊣ [A::Ob, W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(W, X), v::FibHom(X, Y), w::FibHom(Y, Z)]
      (compose(u, id(X)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (compose(id(X), u) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (act(compose(u, v), f) == compose(act(u, f), act(v, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), f::Hom(A, B), u::FibHom(X, Y), v::FibHom(Y, Z)]
      (act(id(X), f) == id(act(X, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      (act(X, compose(f, g)) == act(act(X, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), f::Hom(A, B), g::Hom(A, C)]
      (act(u, compose(f, g)) == act(act(u, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), Y::Fib(A), f::Hom(A, B), g::Hom(B, C), u::FibHom(X, Y)]
      (act(X, id(A)) == X) ⊣ [A::Ob, X::Fib(A)]
      (act(u, id(A)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:102 =#
      otimes(X, Y)::Fib(A) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]
      otimes(u, v)::FibHom(otimes(X, W), otimes(Y, Z)) ⊣ [A::Ob, W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(X, Y), v::FibHom(W, Z)]
      munit(A)::Fib(A) ⊣ [A::Ob]
      (otimes(otimes(X, Y), Z) == otimes(X, otimes(Y, Z))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A)]
      (otimes(munit(A), X) == X) ⊣ [A::Ob, X::Fib(A)]
      (otimes(X, munit(A)) == X) ⊣ [A::Ob, X::Fib(A)]
      (otimes(otimes(u, v), w) == otimes(u, otimes(v, w))) ⊣ [A::Ob, U::Fib(A), V::Fib(A), W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(U, X), v::FibHom(V, Y), w::FibHom(W, Z)]
      (otimes(id(munit(A)), u) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (otimes(u, id(munit(A))) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (compose(otimes(t, u), otimes(v, w)) == otimes(compose(t, v), compose(u, w))) ⊣ [A::Ob, U::Fib(A), V::Fib(A), W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), t::FibHom(U, V), v::FibHom(V, W), u::FibHom(X, Y), w::FibHom(Y, Z)]
      (id(otimes(X, Y)) == otimes(id(X), id(Y))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]

Abstract type for circular port graphs.

Abstract type for open circular port graphs.

A circular port graph.

Circular port graphs consist of boxes with ports connected by directed wires. The ports are not seperated into inputs and outputs, so the "boxes" are actually circular, hence the name.

An open circular port graph.

Open circular port graphs are circular port graphs with a distinguished set of outer ports. They have a natural operad structure and can be seen as a specialization of directed wiring diagrams.

Generate and parse Julia programs based on diagrams.

Theory of a symmetric monoidal copresheaf

The name is not standard but refers to a lax symmetric monoidal functor into Set. This can be interpreted as an action of a symmetric monoidal category, just as a copresheaf (set-valued functor) is an action of a category. The theory is simpler than that of a general lax monoidal functor because (1) the domain is a strict monoidal category and (2) the codomain is fixed to the cartesian monoidal category Set.

FIXME: This theory should also extend ThCopresheaf but multiple inheritance is not yet supported.

ThSymmetricMonoidalCopresheaf

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      El(ob)::TYPE ⊣ [ob::Ob]
      act(x, f)::El(B) ⊣ [A::Ob, B::Ob, x::El(A), f::Hom(A, B)]
      otimes(x, y)::El(otimes(A, B)) ⊣ [A::Ob, B::Ob, x::El(A), y::El(B)]
      elunit()::El(munit()) ⊣ []
      (act(act(x, f), g) == act(x, compose(f, g))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(B, C), x::El(A)]

Theory of monoidal double categories

To avoid associators and unitors, we assume that the monoidal double category is fully strict: both the double category and its monoidal product are strict. Apart from assuming strictness, this theory agrees with the definition of a monoidal double category in (Shulman 2010) and other recent works.

In a monoidal double category $(D,⊗,I)$, the underlying categories $D₀$ and $D₁$ are each monoidal categories, $(D₀,⊗₀,I₀)$ and $(D₁,⊗₁,I₁)$, subject to further axioms such as the source and target functors $S, T: D₁ → D₀$ being strict monoidal functors.

Despite the apparent asymmetry in this setup, the definition of a monoidal double category unpacks to be nearly symmetric with respect to arrows and proarrows, except that the monoidal unit $I₀$ of $D₀$ induces the monoidal unit of $D₁$ as $I₁ = U(I₀)$.

References:

• Shulman, 2010: Constructing symmetric monoidal bicategories

FIXME: Should also inherit ThMonoidalCategory{Ob,Hom} but multiple inheritance is not supported.

ThMonoidalDoubleCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Pro(src, tgt)::TYPE ⊣ [src::Ob, tgt::Ob]
      Cell(dom, codom, src, tgt)::TYPE ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, dom::Pro(A, B), codom::Pro(C, D), src::Hom(A, C), tgt::Hom(B, D)]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      compose(α, β)::Cell(m, p, compose(f, h), compose(g, k)) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z), f::Hom(A, B), g::Hom(X, Y), h::Hom(B, C), k::Hom(Y, Z), α::Cell(m, n, f, g), β::Cell(n, p, h, k)]
      id(m)::Cell(m, m, id(A), id(B)) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (compose(compose(α, β), γ) == compose(α, compose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, W), n::Pro(B, X), p::Pro(C, Y), q::Pro(D, Z), f::Hom(A, B), g::Hom(B, C), h::Hom(C, D), i::Hom(W, X), j::Hom(X, Y), k::Hom(Y, Z), α::Cell(m, n, f, i), β::Cell(n, p, g, j), γ::Cell(p, q, h, k)]
      (compose(α, id(n)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (compose(id(m), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      pcompose(m, n)::Pro(A, C) ⊣ [A::Ob, B::Ob, C::Ob, m::Pro(A, B), n::Pro(B, C)]
      pid(A)::Pro(A, A) ⊣ [A::Ob]
      pcompose(α, β)::Cell(pcompose(m, n), pcompose(p, q), f, h) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(X, Y), q::Pro(Y, Z), f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z), α::Cell(m, p, f, g), β::Cell(n, q, g, h)]
      pid(f)::Cell(pid(A), pid(B), f, f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (pcompose(pcompose(m, n), p) == pcompose(m, pcompose(n, p))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D)]
      (pcompose(m, pid(B)) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pid(A), m) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pcompose(α, β), γ) == pcompose(α, pcompose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D), u::Pro(W, X), v::Pro(X, Y), w::Pro(Y, Z), f::Hom(A, W), g::Hom(B, X), h::Hom(C, Y), k::Hom(D, Z), α::Cell(m, u, f, g), β::Cell(n, v, g, h), γ::Cell(p, w, h, k)]
      (pcompose(α, pid(g)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (pcompose(pid(f), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:273 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      otimes(m, n)::Pro(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D)]
      otimes(α, β)::Cell(otimes(m, m′), otimes(n, n′), otimes(f, f′), otimes(g, g′)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, A′::Ob, B′::Ob, C′::Ob, D′::Ob, f::Hom(A, C), g::Hom(B, D), f′::Hom(A′, C′), g′::Hom(B′, D′), m::Pro(A, B), n::Pro(C, D), m′::Pro(A′, B′), n′::Pro(C′, D′), α::Cell(m, n, f, g), β::Cell(m′, n′, f′, g′)]
      (otimes(otimes(m, n), p) == otimes(m, otimes(n, p))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z)]
      (otimes(m, pid(munit())) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (otimes(pid(munit()), m) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (otimes(otimes(α, β), γ) == otimes(α, otimes(β, γ))) ⊣ [A₁::Ob, A₂::Ob, A₃::Ob, B₁::Ob, B₂::Ob, B₃::Ob, C₁::Ob, C₂::Ob, C₃::Ob, D₁::Ob, D₂::Ob, D₃::Ob, f₁::Hom(A₁, C₁), f₂::Hom(A₂, C₂), f₃::Hom(A₃, C₃), g₁::Hom(B₁, D₁), g₂::Hom(B₂, D₂), g₃::Hom(B₃, D₃), m₁::Pro(A₁, B₁), m₂::Pro(A₂, B₂), m₃::Pro(A₃, B₃), n₁::Pro(C₁, D₁), n₂::Pro(C₂, D₂), n₃::Pro(C₃, D₃), α::Cell(m₁, n₁, f₁, g₁), β::Cell(m₂, n₂, f₂, g₂), γ::Cell(m₃, m₃, f₃, g₃)]
      (compose(otimes(α, α′), otimes(β, β′)) == otimes(compose(α, β), compose(α′, β′))) ⊣ [A::Ob, B::Ob, C::Ob, A′::Ob, B′::Ob, C′::Ob, X::Ob, Y::Ob, Z::Ob, X′::Ob, Y′::Ob, Z′::Ob, f::Hom(A, B), g::Hom(X, Y), f′::Hom(A′, B′), g′::Hom(X′, Y′), h::Hom(B, C), k::Hom(Y, Z), h′::Hom(B′, C′), k′::Hom(Y′, Z′), m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z), m′::Pro(A′, X′), n′::Pro(B′, Y′), p′::Pro(C′, Z′), α::Cell(m, n, f, g), α′::Cell(m′, n′, f′, g′), β::Cell(n, p, h, k), β′::Cell(n′, p′, h′, k′)]
      (id(otimes(m, n)) == otimes(id(m), id(n))) ⊣ [A::Ob, B::Ob, X::Ob, Y::Ob, m::Pro(A, X), n::Pro(B, Y)]
      (pcompose(otimes(m, n), otimes(p, q)) == otimes(pcompose(m, p), pcompose(n, q))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), p::Pro(B, C), n::Pro(X, Y), q::Pro(Y, Z)]
      (pid(otimes(A, B)) == otimes(pid(A), pid(B))) ⊣ [A::Ob, B::Ob]

Theory of Heyting algebra of subobjects in a Heyting category, such as a topos.

ThSubobjectHeytingAlgebra

      Ob::TYPE ⊣ []
      Sub(ob)::TYPE ⊣ [ob::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      meet(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      join(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      top(X)::Sub(X) ⊣ [X::Ob]
      bottom(X)::Sub(X) ⊣ [X::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:54 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:54 =#
      implies(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      negate(A)::Sub(X) ⊣ [X::Ob, A::Sub(X)]

Diagrams in a category and their morphisms.

Diagram in a category.

Recall that a diagram in a category $C$ is a functor $D: J → C$, where for us the shape category $J$ is finitely presented. Although such a diagram is captured perfectly well by a FinDomFunctor, there are several different notions of morphism between diagrams. The first type parameter T in this wrapper type distinguishes which diagram category the diagram belongs to. See DiagramHom for more about the possible choices. The parameter T may also be Any to indicate that no choice has (yet) been made.

Morphism of diagrams in a category.

In fact, this type encompasses several different kinds of morphisms from a diagram $D: J → C$ to another diagram $D′: J′ → C$:

1. DiagramHom{id}: a functor $F: J → J′$ together with a natural transformation $ϕ: D ⇒ F⋅D′$
2. DiagramHom{op}: a functor $F: J′ → J$ together with a natural transformation $ϕ: F⋅D ⇒ D′$
3. DiagramHom{co}: a functor $F: J → J′$ together with a natural transformation $ϕ: F⋅D′ ⇒ D$.

Note that Diagram{op} is not the opposite category of Diagram{id}, but Diagram{op} and Diagram{co} are opposites of each other. Explicit support is included for both because they are useful for different purposes: morphisms of type DiagramHom{id} and DiagramHom{op} induce morphisms between colimits and between limits of the diagrams, respectively, whereas morphisms of type DiagramHom{co} generalize morphisms of polynomial functors.

Convert the diagram category in which a diagram hom is being viewed.

Default concrete type for diagram in a category.

Functor underlying a diagram in a category.

Functor underlying a diagram in a category.

The shape or indexing category of a diagram.

This is the domain of the underlying functor.

Force-evaluate the functor in a diagram.

Theory of an opindexed monoidal category with cocartesian indexing category.

This is equivalent via the Grothendieck construction to a monoidal opfibration over a cocartesian monoidal base (Shulman 2008, Theorem 12.7). The terminology "coindexed monoidal category" used here is not standard and arguably not good, but I'm running out of ways to combine these adjectives.

References:

• Shulman, 2008: Framed bicategories and monoidal fibrations
• Shulman, 2013: Enriched indexed categories

ThCoindexedMonoidalCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      Fib(ob)::TYPE ⊣ [ob::Ob]
      FibHom(dom, codom)::TYPE ⊣ [A::Ob, dom::Fib(A), codom::Fib(A)]
      id(X)::FibHom(X, X) ⊣ [A::Ob, X::Fib(A)]
      compose(u, v)::FibHom(X, Z) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(X, Y), v::FibHom(Y, Z)]
      act(X, f)::Fib(B) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      act(u, f)::FibHom(act(X, f), act(Y, f)) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y), f::Hom(A, B)]
      (compose(compose(u, v), w) == compose(u, compose(v, w))) ⊣ [A::Ob, W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(W, X), v::FibHom(X, Y), w::FibHom(Y, Z)]
      (compose(u, id(X)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (compose(id(X), u) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (act(compose(u, v), f) == compose(act(u, f), act(v, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), f::Hom(A, B), u::FibHom(X, Y), v::FibHom(Y, Z)]
      (act(id(X), f) == id(act(X, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      (act(X, compose(f, g)) == act(act(X, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), f::Hom(A, B), g::Hom(A, C)]
      (act(u, compose(f, g)) == act(act(u, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), Y::Fib(A), f::Hom(A, B), g::Hom(B, C), u::FibHom(X, Y)]
      (act(X, id(A)) == X) ⊣ [A::Ob, X::Fib(A)]
      (act(u, id(A)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:102 =#
      otimes(X, Y)::Fib(A) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]
      otimes(u, v)::FibHom(otimes(X, W), otimes(Y, Z)) ⊣ [A::Ob, W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(X, Y), v::FibHom(W, Z)]
      munit(A)::Fib(A) ⊣ [A::Ob]
      (otimes(otimes(X, Y), Z) == otimes(X, otimes(Y, Z))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A)]
      (otimes(munit(A), X) == X) ⊣ [A::Ob, X::Fib(A)]
      (otimes(X, munit(A)) == X) ⊣ [A::Ob, X::Fib(A)]
      (otimes(otimes(u, v), w) == otimes(u, otimes(v, w))) ⊣ [A::Ob, U::Fib(A), V::Fib(A), W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(U, X), v::FibHom(V, Y), w::FibHom(W, Z)]
      (otimes(id(munit(A)), u) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (otimes(u, id(munit(A))) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (compose(otimes(t, u), otimes(v, w)) == otimes(compose(t, v), compose(u, w))) ⊣ [A::Ob, U::Fib(A), V::Fib(A), W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), t::FibHom(U, V), v::FibHom(V, W), u::FibHom(X, Y), w::FibHom(Y, Z)]
      (id(otimes(X, Y)) == otimes(id(X), id(Y))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]
      
      (act(otimes(X, Y), f) == otimes(act(X, f), act(Y, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), f::Hom(A, B)]
      (act(munit(A), f) == munit(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (act(otimes(u, v), f) == otimes(act(u, f), act(v, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), W::Fib(A), f::Hom(A, B), u::FibHom(X, Z), v::FibHom(Y, W)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:194 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]

Theory of monoidal double categories

To avoid associators and unitors, we assume that the monoidal double category is fully strict: both the double category and its monoidal product are strict. Apart from assuming strictness, this theory agrees with the definition of a monoidal double category in (Shulman 2010) and other recent works.

In a monoidal double category $(D,⊗,I)$, the underlying categories $D₀$ and $D₁$ are each monoidal categories, $(D₀,⊗₀,I₀)$ and $(D₁,⊗₁,I₁)$, subject to further axioms such as the source and target functors $S, T: D₁ → D₀$ being strict monoidal functors.

Despite the apparent asymmetry in this setup, the definition of a monoidal double category unpacks to be nearly symmetric with respect to arrows and proarrows, except that the monoidal unit $I₀$ of $D₀$ induces the monoidal unit of $D₁$ as $I₁ = U(I₀)$.

References:

• Shulman, 2010: Constructing symmetric monoidal bicategories

FIXME: Should also inherit ThMonoidalCategory{Ob,Hom} but multiple inheritance is not supported.

ThMonoidalDoubleCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Pro(src, tgt)::TYPE ⊣ [src::Ob, tgt::Ob]
      Cell(dom, codom, src, tgt)::TYPE ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, dom::Pro(A, B), codom::Pro(C, D), src::Hom(A, C), tgt::Hom(B, D)]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      compose(α, β)::Cell(m, p, compose(f, h), compose(g, k)) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z), f::Hom(A, B), g::Hom(X, Y), h::Hom(B, C), k::Hom(Y, Z), α::Cell(m, n, f, g), β::Cell(n, p, h, k)]
      id(m)::Cell(m, m, id(A), id(B)) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (compose(compose(α, β), γ) == compose(α, compose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, W), n::Pro(B, X), p::Pro(C, Y), q::Pro(D, Z), f::Hom(A, B), g::Hom(B, C), h::Hom(C, D), i::Hom(W, X), j::Hom(X, Y), k::Hom(Y, Z), α::Cell(m, n, f, i), β::Cell(n, p, g, j), γ::Cell(p, q, h, k)]
      (compose(α, id(n)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (compose(id(m), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      pcompose(m, n)::Pro(A, C) ⊣ [A::Ob, B::Ob, C::Ob, m::Pro(A, B), n::Pro(B, C)]
      pid(A)::Pro(A, A) ⊣ [A::Ob]
      pcompose(α, β)::Cell(pcompose(m, n), pcompose(p, q), f, h) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(X, Y), q::Pro(Y, Z), f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z), α::Cell(m, p, f, g), β::Cell(n, q, g, h)]
      pid(f)::Cell(pid(A), pid(B), f, f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (pcompose(pcompose(m, n), p) == pcompose(m, pcompose(n, p))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D)]
      (pcompose(m, pid(B)) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pid(A), m) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pcompose(α, β), γ) == pcompose(α, pcompose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D), u::Pro(W, X), v::Pro(X, Y), w::Pro(Y, Z), f::Hom(A, W), g::Hom(B, X), h::Hom(C, Y), k::Hom(D, Z), α::Cell(m, u, f, g), β::Cell(n, v, g, h), γ::Cell(p, w, h, k)]
      (pcompose(α, pid(g)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (pcompose(pid(f), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:273 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      otimes(m, n)::Pro(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D)]
      otimes(α, β)::Cell(otimes(m, m′), otimes(n, n′), otimes(f, f′), otimes(g, g′)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, A′::Ob, B′::Ob, C′::Ob, D′::Ob, f::Hom(A, C), g::Hom(B, D), f′::Hom(A′, C′), g′::Hom(B′, D′), m::Pro(A, B), n::Pro(C, D), m′::Pro(A′, B′), n′::Pro(C′, D′), α::Cell(m, n, f, g), β::Cell(m′, n′, f′, g′)]
      (otimes(otimes(m, n), p) == otimes(m, otimes(n, p))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z)]
      (otimes(m, pid(munit())) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (otimes(pid(munit()), m) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (otimes(otimes(α, β), γ) == otimes(α, otimes(β, γ))) ⊣ [A₁::Ob, A₂::Ob, A₃::Ob, B₁::Ob, B₂::Ob, B₃::Ob, C₁::Ob, C₂::Ob, C₃::Ob, D₁::Ob, D₂::Ob, D₃::Ob, f₁::Hom(A₁, C₁), f₂::Hom(A₂, C₂), f₃::Hom(A₃, C₃), g₁::Hom(B₁, D₁), g₂::Hom(B₂, D₂), g₃::Hom(B₃, D₃), m₁::Pro(A₁, B₁), m₂::Pro(A₂, B₂), m₃::Pro(A₃, B₃), n₁::Pro(C₁, D₁), n₂::Pro(C₂, D₂), n₃::Pro(C₃, D₃), α::Cell(m₁, n₁, f₁, g₁), β::Cell(m₂, n₂, f₂, g₂), γ::Cell(m₃, m₃, f₃, g₃)]
      (compose(otimes(α, α′), otimes(β, β′)) == otimes(compose(α, β), compose(α′, β′))) ⊣ [A::Ob, B::Ob, C::Ob, A′::Ob, B′::Ob, C′::Ob, X::Ob, Y::Ob, Z::Ob, X′::Ob, Y′::Ob, Z′::Ob, f::Hom(A, B), g::Hom(X, Y), f′::Hom(A′, B′), g′::Hom(X′, Y′), h::Hom(B, C), k::Hom(Y, Z), h′::Hom(B′, C′), k′::Hom(Y′, Z′), m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z), m′::Pro(A′, X′), n′::Pro(B′, Y′), p′::Pro(C′, Z′), α::Cell(m, n, f, g), α′::Cell(m′, n′, f′, g′), β::Cell(n, p, h, k), β′::Cell(n′, p′, h′, k′)]
      (id(otimes(m, n)) == otimes(id(m), id(n))) ⊣ [A::Ob, B::Ob, X::Ob, Y::Ob, m::Pro(A, X), n::Pro(B, Y)]
      (pcompose(otimes(m, n), otimes(p, q)) == otimes(pcompose(m, p), pcompose(n, q))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), p::Pro(B, C), n::Pro(X, Y), q::Pro(Y, Z)]
      (pid(otimes(A, B)) == otimes(pid(A), pid(B))) ⊣ [A::Ob, B::Ob]

Theory of a cartesian double category

Loosely speaking, a cartesian double category is a double category $D$ such that the underlying catgories $D₀$ and $D₁$ are both cartesian categories, in a compatible way.

Reference: Aleiferi 2018, PhD thesis.

ThCartesianDoubleCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Pro(src, tgt)::TYPE ⊣ [src::Ob, tgt::Ob]
      Cell(dom, codom, src, tgt)::TYPE ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, dom::Pro(A, B), codom::Pro(C, D), src::Hom(A, C), tgt::Hom(B, D)]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:95 =#
      compose(α, β)::Cell(m, p, compose(f, h), compose(g, k)) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z), f::Hom(A, B), g::Hom(X, Y), h::Hom(B, C), k::Hom(Y, Z), α::Cell(m, n, f, g), β::Cell(n, p, h, k)]
      id(m)::Cell(m, m, id(A), id(B)) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (compose(compose(α, β), γ) == compose(α, compose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, W), n::Pro(B, X), p::Pro(C, Y), q::Pro(D, Z), f::Hom(A, B), g::Hom(B, C), h::Hom(C, D), i::Hom(W, X), j::Hom(X, Y), k::Hom(Y, Z), α::Cell(m, n, f, i), β::Cell(n, p, g, j), γ::Cell(p, q, h, k)]
      (compose(α, id(n)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (compose(id(m), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      pcompose(m, n)::Pro(A, C) ⊣ [A::Ob, B::Ob, C::Ob, m::Pro(A, B), n::Pro(B, C)]
      pid(A)::Pro(A, A) ⊣ [A::Ob]
      pcompose(α, β)::Cell(pcompose(m, n), pcompose(p, q), f, h) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(X, Y), q::Pro(Y, Z), f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z), α::Cell(m, p, f, g), β::Cell(n, q, g, h)]
      pid(f)::Cell(pid(A), pid(B), f, f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (pcompose(pcompose(m, n), p) == pcompose(m, pcompose(n, p))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D)]
      (pcompose(m, pid(B)) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pid(A), m) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (pcompose(pcompose(α, β), γ) == pcompose(α, pcompose(β, γ))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(C, D), u::Pro(W, X), v::Pro(X, Y), w::Pro(Y, Z), f::Hom(A, W), g::Hom(B, X), h::Hom(C, Y), k::Hom(D, Z), α::Cell(m, u, f, g), β::Cell(n, v, g, h), γ::Cell(p, w, h, k)]
      (pcompose(α, pid(g)) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      (pcompose(pid(f), α) == α) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D), f::Hom(A, C), g::Hom(B, D), α::Cell(m, n, f, g)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:273 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      otimes(m, n)::Pro(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D)]
      otimes(α, β)::Cell(otimes(m, m′), otimes(n, n′), otimes(f, f′), otimes(g, g′)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, A′::Ob, B′::Ob, C′::Ob, D′::Ob, f::Hom(A, C), g::Hom(B, D), f′::Hom(A′, C′), g′::Hom(B′, D′), m::Pro(A, B), n::Pro(C, D), m′::Pro(A′, B′), n′::Pro(C′, D′), α::Cell(m, n, f, g), β::Cell(m′, n′, f′, g′)]
      (otimes(otimes(m, n), p) == otimes(m, otimes(n, p))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z)]
      (otimes(m, pid(munit())) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (otimes(pid(munit()), m) == m) ⊣ [A::Ob, B::Ob, m::Pro(A, B)]
      (otimes(otimes(α, β), γ) == otimes(α, otimes(β, γ))) ⊣ [A₁::Ob, A₂::Ob, A₃::Ob, B₁::Ob, B₂::Ob, B₃::Ob, C₁::Ob, C₂::Ob, C₃::Ob, D₁::Ob, D₂::Ob, D₃::Ob, f₁::Hom(A₁, C₁), f₂::Hom(A₂, C₂), f₃::Hom(A₃, C₃), g₁::Hom(B₁, D₁), g₂::Hom(B₂, D₂), g₃::Hom(B₃, D₃), m₁::Pro(A₁, B₁), m₂::Pro(A₂, B₂), m₃::Pro(A₃, B₃), n₁::Pro(C₁, D₁), n₂::Pro(C₂, D₂), n₃::Pro(C₃, D₃), α::Cell(m₁, n₁, f₁, g₁), β::Cell(m₂, n₂, f₂, g₂), γ::Cell(m₃, m₃, f₃, g₃)]
      (compose(otimes(α, α′), otimes(β, β′)) == otimes(compose(α, β), compose(α′, β′))) ⊣ [A::Ob, B::Ob, C::Ob, A′::Ob, B′::Ob, C′::Ob, X::Ob, Y::Ob, Z::Ob, X′::Ob, Y′::Ob, Z′::Ob, f::Hom(A, B), g::Hom(X, Y), f′::Hom(A′, B′), g′::Hom(X′, Y′), h::Hom(B, C), k::Hom(Y, Z), h′::Hom(B′, C′), k′::Hom(Y′, Z′), m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z), m′::Pro(A′, X′), n′::Pro(B′, Y′), p′::Pro(C′, Z′), α::Cell(m, n, f, g), α′::Cell(m′, n′, f′, g′), β::Cell(n, p, h, k), β′::Cell(n′, p′, h′, k′)]
      (id(otimes(m, n)) == otimes(id(m), id(n))) ⊣ [A::Ob, B::Ob, X::Ob, Y::Ob, m::Pro(A, X), n::Pro(B, Y)]
      (pcompose(otimes(m, n), otimes(p, q)) == otimes(pcompose(m, p), pcompose(n, q))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), p::Pro(B, C), n::Pro(X, Y), q::Pro(Y, Z)]
      (pid(otimes(A, B)) == otimes(pid(A), pid(B))) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/HigherCategory.jl:345 =#
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      braid(m, n)::Cell(otimes(m, n), otimes(n, m), braid(A, B), braid(C, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, C), n::Pro(B, D)]
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (compose(braid(m, n), braid(n, m)) == id(otimes(m, n))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, C), n::Pro(B, D)]
      (compose(otimes(f, g), braid(C, D)) == compose(braid(A, B), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, C), g::Hom(B, D)]
      (compose(otimes(α, β), braid(m′, n′)) == compose(braid(m, n), otimes(β, α))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, A′::Ob, B′::Ob, C′::Ob, D′::Ob, f::Hom(A, C), g::Hom(B, D), f′::Hom(A′, C′), g′::Hom(B′, D′), m::Pro(A, B), n::Pro(C, D), m′::Pro(A′, B′), n′::Pro(C′, D′), α::Cell(m, n, f, g), β::Cell(m′, n′, f′, g′)]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(m, otimes(n, p)) == compose(otimes(braid(m, n), id(p)), otimes(id(n), braid(m, p)))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z)]
      (braid(otimes(m, n), p) == compose(otimes(id(m), braid(n, p)), otimes(braid(m, p), id(n)))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, X), n::Pro(B, Y), p::Pro(C, Z)]
      (braid(pcompose(m, n), pcompose(m′, n′)) == pcompose(braid(m, m′), braid(n, n′))) ⊣ [A::Ob, B::Ob, C::Ob, A′::Ob, B′::Ob, C′::Ob, m::Pro(A, B), n::Pro(B, C), m′::Pro(A′, B′), n′::Pro(B′, C′)]
      (braid(pid(A), pid(B)) == pid(braid(A, B))) ⊣ [A::Ob, B::Ob]
      
      pair(f, g)::Hom(A, otimes(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      proj1(A, B)::Hom(otimes(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(otimes(A, B), B) ⊣ [A::Ob, B::Ob]
      (compose(pair(f, g), proj1(B, C)) == f) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      (compose(pair(f, g), proj2(B, C)) == g) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      (pair(compose(h, proj1(B, C)), compose(h, proj2(B, C))) == h) ⊣ [A::Ob, B::Ob, C::Ob, h::Hom(A, otimes(B, C))]
      pair(α, β)::Cell(m, otimes(p, q), pair(f, g), pair(h, k)) ⊣ [A::Ob, B::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, W), g::Hom(A, Y), h::Hom(B, X), k::Hom(B, Z), m::Pro(A, B), p::Pro(W, X), q::Pro(Y, Z), α::Cell(m, p, f, h), β::Cell(m, q, g, k)]
      proj1(m, n)::Cell(otimes(m, n), m, proj1(A, C), proj1(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D)]
      proj2(m, n)::Cell(otimes(m, n), n, proj2(A, C), proj2(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, m::Pro(A, B), n::Pro(C, D)]
      (pair(pcompose(α, γ), pcompose(β, δ)) == pcompose(pair(α, β), pair(γ, δ))) ⊣ [A::Ob, B::Ob, C::Ob, P::Ob, Q::Ob, W::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, W), g::Hom(A, Y), h::Hom(B, X), k::Hom(B, Z), i::Hom(C, P), j::Hom(C, Q), m::Pro(A, B), n::Pro(B, C), p::Pro(W, X), q::Pro(Y, Z), u::Pro(X, P), v::Pro(Z, Q), α::Cell(m, p, f, h), β::Cell(m, q, g, k), γ::Cell(n, u, h, i), δ::Cell(n, v, k, j)]
      (pair(pid(f), pid(g)) == pid(pair(f, g))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(B, C)]
      (proj1(pcompose(m, n), pcompose(p, q)) == pcompose(proj1(m, p), proj2(n, q))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(X, Y), q::Pro(Y, Z)]
      (proj2(pcompose(m, n), pcompose(p, q)) == pcompose(proj2(m, p), proj2(n, q))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, m::Pro(A, B), n::Pro(B, C), p::Pro(X, Y), q::Pro(Y, Z)]
      (proj1(pid(A), pid(B)) == pid(proj1(A, B))) ⊣ [A::Ob, B::Ob]
      (proj2(pid(A), pid(B)) == pid(proj2(A, B))) ⊣ [A::Ob, B::Ob]

Theory of symmetric monoidal categories, in additive notation

Mathematically the same as ThSymmetricMonoidalCategory but with different notation.

ThSymmetricMonoidalCategoryAdditive

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]

Syntax for a 2-category.

This syntax checks domains of morphisms but not 2-morphisms.

Theory of cocartesian (monoidal) categories

For the traditional axiomatization of coproducts, see ThCategoryWithCoproducts.

ThCocartesianCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      (compose(oplus(plus(A), id(A)), plus(A)) == compose(oplus(id(A), plus(A)), plus(A))) ⊣ [A::Ob]
      (compose(oplus(zero(A), id(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (compose(oplus(id(A), zero(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (plus(A) == compose(swap(A, A), plus(A))) ⊣ [A::Ob]
      (plus(oplus(A, B)) == compose(oplus(oplus(id(A), swap(B, A)), id(B)), oplus(plus(A), plus(B)))) ⊣ [A::Ob, B::Ob]
      (zero(oplus(A, B)) == oplus(zero(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (plus(mzero()) == id(mzero())) ⊣ []
      (zero(mzero()) == id(mzero())) ⊣ []
      
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      (copair(f, g) == compose(oplus(f, g), plus(C))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      (coproj1(A, B) == oplus(id(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (coproj2(A, B) == oplus(zero(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Theory of monoidal categories with codiagonals

A monoidal category with codiagonals is a symmetric monoidal category equipped with coherent collections of merging and creating morphisms (monoids). Unlike in a cocartesian category, the naturality axioms need not be satisfied.

For references, see ThMonoidalCategoryWithDiagonals.

ThMonoidalCategoryWithCodiagonals

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      (compose(oplus(plus(A), id(A)), plus(A)) == compose(oplus(id(A), plus(A)), plus(A))) ⊣ [A::Ob]
      (compose(oplus(zero(A), id(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (compose(oplus(id(A), zero(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (plus(A) == compose(swap(A, A), plus(A))) ⊣ [A::Ob]
      (plus(oplus(A, B)) == compose(oplus(oplus(id(A), swap(B, A)), id(B)), oplus(plus(A), plus(B)))) ⊣ [A::Ob, B::Ob]
      (zero(oplus(A, B)) == oplus(zero(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (plus(mzero()) == id(mzero())) ⊣ []
      (zero(mzero()) == id(mzero())) ⊣ []

Serialize abstract wiring diagrams as GraphML.

Serialization of box, port, and wire values can be overloaded by data type (see convert_to_graphml_data and convert_from_graphml_data).

GraphML is the closest thing to a de jure and de facto standard in the space of graph data formats, supported by a variety of graph applications and libraries. We depart mildly from the GraphML spec by allowing JSON data attributes for GraphML nodes, ports, and edges.

References:

• GraphML Primer: http://graphml.graphdrawing.org/primer/graphml-primer.html
• GraphML DTD: http://graphml.graphdrawing.org/specification/dtd.html

Generate GraphML representing a wiring diagram.

Parse a wiring diagram from a GraphML string or XML document.

Parse a property graph from a GraphML string or XML document.

The equivalent of NetworkX's parse_graphml function.

Read a wiring diagram from a GraphML file.

Read a property graph from a GraphML file.

The equivalent of NetworkX's read_graphml function.

Write a wiring diagram to a file as GraphML.

Theory of monoidal categories with bidiagonals, in additive notation

Mathematically the same as ThMonoidalCategoryWithBidiagonals but written additively, instead of multiplicatively.

ThMonoidalCategoryWithBidiagonalsAdditive

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      (compose(oplus(plus(A), id(A)), plus(A)) == compose(oplus(id(A), plus(A)), plus(A))) ⊣ [A::Ob]
      (compose(oplus(zero(A), id(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (compose(oplus(id(A), zero(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (plus(A) == compose(swap(A, A), plus(A))) ⊣ [A::Ob]
      (plus(oplus(A, B)) == compose(oplus(oplus(id(A), swap(B, A)), id(B)), oplus(plus(A), plus(B)))) ⊣ [A::Ob, B::Ob]
      (zero(oplus(A, B)) == oplus(zero(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (plus(mzero()) == id(mzero())) ⊣ []
      (zero(mzero()) == id(mzero())) ⊣ []
      
      mcopy(A)::Hom(A, oplus(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:157 =#
      delete(A)::Hom(A, mzero()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:159 =#
      (mcopy(A) == compose(mcopy(A), swap(A, A))) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(mcopy(A), id(A))) == compose(mcopy(A), oplus(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(id(A), delete(A))) == id(A)) ⊣ [A::Ob]

Category of (possibly infinite) sets and functions.

This module defines generic types for the category of sets (SetOb, SetFunction), as well as a few basic concrete types, such as a wrapper type to view Julia types as sets (TypeSet). Extensive support for finite sets is provided by another module, FinSets.

Composite of functions in Set.

Not to be confused with Base.ComposedFunctions for ordinary Julia functions.

Function in Set taking a constant value.

Identity function in Set.

Set defined by a predicate (boolean-valued function) on a Julia data type.

Abstract type for morphism in the category Set.

Every instance of SetFunction{<:SetOb{T},<:SetOb{T′}} is callable with elements of type T, returning an element of type T′.

Note: This type would be better called simply Function but that name is already taken by the base Julia type.

Function in Set defined by a callable Julia object.

Abstract type for object in the category Set.

The type parameter T is the element type of the set.

Note: This type is more abstract than the built-in Julia types AbstractSet and Set, which are intended for data structures for finite sets. Those are encompassed by the subtype FinSet.

A Julia data type regarded as a set.

Forgetful functor Ob: Cat → Set.

Sends a category to its set of objects and a functor to its object map.

Theory of monoidal categories, in additive notation

Mathematically the same as ThMonoidalCategory but with different notation.

ThMonoidalCategoryAdditive

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []

Conventions for serialization of wiring diagrams.

Defines a consistent set of names for boxes, ports, and wires to be used when serializing wiring diagrams, as well as conventions for serializing box, port, and wire attributes.

Theory of a symmetric rig category

FIXME: Should also inherit ThSymmetricMonoidalCategory.

ThSymmetricRigCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:33 =#

Theory of a displayed category.

More precisely, this is the theory of a category $C$ (Ob,Hom) together with a displayed category over $C$ (Fib,FibHom). Displayed categories axiomatize lax functors $C → **Span**$, or equivalently objects of a slice category $**Cat**/C$, in a generalized algebraic style.

References:

• nLab: displayed category
• Ahrens & Lumsdaine, 2019: Displayed categories, Definition 3.1

ThDisplayedCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Fib(ob)::TYPE ⊣ [ob::Ob]
      FibHom(hom, dom, codom)::TYPE ⊣ [A::Ob, B::Ob, hom::Hom(A, B), dom::Fib(A), codom::Fib(B)]
      id(x)::FibHom(id(A), x, x) ⊣ [A::Ob, x::Fib(A)]
      compose(f̄, ḡ)::FibHom(compose(f, g), x, z) ⊣ [A::Ob, B::Ob, C::Ob, x::Fib(A), y::Fib(B), z::Fib(C), f::Hom(A, B), g::Hom(B, C), f̄::FibHom(f, x, y), ḡ::FibHom(g, y, z)]
      (compose(compose(f̄, ḡ), h̄) == compose(f̄, compose(ḡ, h̄))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(B, C), h::Hom(C, D), w::Fib(A), x::Fib(B), y::Fib(C), z::Fib(D), f̄::FibHom(f, w, x), ḡ::FibHom(g, x, y), h̄::FibHom(h, y, z)]
      (compose(f̄, id(y)) == f̄) ⊣ [A::Ob, B::Ob, f::Hom(A, B), x::Fib(A), y::Fib(B), f̄::FibHom(f, x, y)]
      (compose(id(x), f̄) == f̄) ⊣ [A::Ob, B::Ob, f::Hom(A, B), x::Fib(A), y::Fib(B), f̄::FibHom(f, x, y)]

The chase is an algorithm which subjects a C-Set instance to constraints expressed in the language of regular logic, called embedded dependencies (EDs, or 'triggers').

A morphism S->T, encodes an embedded dependency. If the pattern S is matched (via a homomorphism S->I), we demand there exist a morphism T->I (for some database instance I) that makes the triangle commute in order to satisfy the dependency (if this is not the case, then the trigger is 'active').

Homomorphisms can merge elements and introduce new ones. The former kind are called "equality generating dependencies" (EGDs) and the latter "tuple generating dependencies" (TGDs). Any homomorphism can be factored into EGD and TGD components by, respectively, restricting the codomain to the image or restricting the domain to the coimage.

Naively determine active triggers of EDs (S->T) by filtering all triggers (i.e. maps S->I) to see which are active (i.e. there exists no T->I such that S->T->I = S->I). Store the trigger with the ED as a span, I<-S->T.

Optionally initialize the homomorphism search to control the chase process.

Modify C-Set representing a pattern to add a term. Assumes morphism begins from index 1.

chase(I::ACSet, Σ::AbstractDict, n::Int)

Chase a C-Set or C-Rel instance given a list of embedded dependencies. This may not terminate, so a bound n on the number of iterations is required.

[,]

ΣS ⟶ Iₙ ⊕↓ ⋮ (resulting morphism) ΣT ... Iₙ₊₁

There is a copy of S and T for each active trigger. A trigger is a map from S into the current instance. What makes it 'active' is that there is no morphism from T to I that makes the triangle commute.

Each iteration constructs the above pushout square. The result is a morphism, so that one can keep track of the provenance of elements in the original CSet instance within the chased result.

Whether or not the result is due to success or timeout is returned as a boolean flag.

TODO: this algorithm could be made more efficient by homomorphism caching.

Run a single chase step.

A collage of a functor is a schema encoding the data of the functor It has the mapping data in addition to injections from the (co)domain.

Convert a CSet morphism X->Y into a CSet on the schema C->C (collage of id functor on C).

Combine a user-specified initial dict with init, generated by constraints Initial could contain vectors or int-keyed dicts as its data for each object.

Preserves the original name of the inputs if it is unambiguous, otherwise disambiguates with index in original input. E.g. (A,B)⊔(B,C) → (A,B#1,B#2,C)

Create an ACSet type that replaces each Hom/Attr with a span. If a name is provided, return a ()->DynamicACSet, otherwise an AnonACSetType.

Distill the component of a morphism that merges elements together

An equation is a pair of paths: ↗ a₁ → ... → aₙ start ↘ b₁ → ... → bₙ

The EGD that enforces the equation has, as domain a CSet whose category of elements looks like the above graphic. Its codomain is the same, with aₙ and bₙ merged. This merging is performed via a pushout. The diagram above corresponds to l, while r1 is a single point of type aₙ. r2 has two points of that type, with a unique map to r1 and picking out aₙ and bₙ in its map into l.

Given a span of morphisms, we seek to find a morphism B → C that makes a commuting triangle if possible. Accepts homomorphism search keyword arguments to constrain the Hom(B,C) search.

Given a span of morphisms, we seek to find all morphisms B → C that make a commuting triangle.

B

g ↗ ↘ ? A ⟶ C f This may be impossible, because f(a₁)≠f(a₂) but g(a₁)=g(a₂), in which case return nothing. Otherwise, return a Dict which can be used to initialize the homomorphism search Hom(B,C).

Compute pushout of all EDs in parallel by combining each list of morphisms into a single one & taking a pushout.

A partially defined inverse to tocrel.

This fails if a C-Rel morphism is non-unique and returns a C-set with undefined references if the morphism isn't total (a return flag signals whether this occured).

A partially defined inverse to tocrel., on morphisms.

Check if id up to isomorphism

Create constraints for enforcing a C-Set schema on a C-Rel instance.

A presentation implies constraints of foreign keys being functional (total and unique) in addition to any extra equations.

We do not have general limits for ACSet transformations, so we cannot yet automatically factor an ED into an EGD+TGD. However, it should be possible to define limits such that the CSetTransformation code above works for ACSets too.

Split a dict of (general) EDs into dicts of EGDs and TGDs

Distill the component of a morphism that adds new elements

A functor C-Set -> C-Rel, on morphisms. It simply disregards the morphism data in C-Rel that keeps track of the span apex objects.

A functor C-Set -> C-Rel, on objects. Can be applied safely to C-sets with undefined references.

Theory of biproduct categories

Mathematically the same as ThSemiadditiveCategory but written multiplicatively, instead of additively.

ThBiproductCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:178 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:180 =#
      (compose(mcopy(A), otimes(mcopy(A), id(A))) == compose(mcopy(A), otimes(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), braid(A, A)) == mcopy(A)) ⊣ [A::Ob]
      (mcopy(otimes(A, B)) == compose(otimes(mcopy(A), mcopy(B)), otimes(otimes(id(A), braid(A, B)), id(B)))) ⊣ [A::Ob, B::Ob]
      (delete(otimes(A, B)) == otimes(delete(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (mcopy(munit()) == id(munit())) ⊣ []
      (delete(munit()) == id(munit())) ⊣ []
      
      mmerge(A)::Hom(otimes(A, A), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:248 =#
      create(A)::Hom(munit(), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:250 =#
      
      pair(f, g)::Hom(A, otimes(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      copair(f, g)::Hom(otimes(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      proj1(A, B)::Hom(otimes(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(otimes(A, B), B) ⊣ [A::Ob, B::Ob]
      coproj1(A, B)::Hom(A, otimes(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, otimes(A, B)) ⊣ [A::Ob, B::Ob]
      (compose(f, mcopy(B)) == compose(mcopy(A), otimes(f, f))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(f, delete(B)) == delete(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(mmerge(A), f) == compose(otimes(f, f), mmerge(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(create(A), f) == create(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(mmerge(A), mcopy(A)) == compose(compose(otimes(mcopy(A), mcopy(A)), otimes(otimes(id(A), braid(A, A)), id(A))), otimes(mmerge(A), mmerge(A)))) ⊣ [A::Ob]
      (compose(mmerge(A), delete(A)) == otimes(delete(A), delete(A))) ⊣ [A::Ob]
      (compose(create(A), mcopy(A)) == otimes(create(A), create(A))) ⊣ [A::Ob]
      (compose(create(A), delete(A)) == id(munit())) ⊣ [A::Ob]

Theory of a displayed category.

More precisely, this is the theory of a category $C$ (Ob,Hom) together with a displayed category over $C$ (Fib,FibHom). Displayed categories axiomatize lax functors $C → **Span**$, or equivalently objects of a slice category $**Cat**/C$, in a generalized algebraic style.

References:

• nLab: displayed category
• Ahrens & Lumsdaine, 2019: Displayed categories, Definition 3.1

ThDisplayedCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Fib(ob)::TYPE ⊣ [ob::Ob]
      FibHom(hom, dom, codom)::TYPE ⊣ [A::Ob, B::Ob, hom::Hom(A, B), dom::Fib(A), codom::Fib(B)]
      id(x)::FibHom(id(A), x, x) ⊣ [A::Ob, x::Fib(A)]
      compose(f̄, ḡ)::FibHom(compose(f, g), x, z) ⊣ [A::Ob, B::Ob, C::Ob, x::Fib(A), y::Fib(B), z::Fib(C), f::Hom(A, B), g::Hom(B, C), f̄::FibHom(f, x, y), ḡ::FibHom(g, y, z)]
      (compose(compose(f̄, ḡ), h̄) == compose(f̄, compose(ḡ, h̄))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(B, C), h::Hom(C, D), w::Fib(A), x::Fib(B), y::Fib(C), z::Fib(D), f̄::FibHom(f, w, x), ḡ::FibHom(g, x, y), h̄::FibHom(h, y, z)]
      (compose(f̄, id(y)) == f̄) ⊣ [A::Ob, B::Ob, f::Hom(A, B), x::Fib(A), y::Fib(B), f̄::FibHom(f, x, y)]
      (compose(id(x), f̄) == f̄) ⊣ [A::Ob, B::Ob, f::Hom(A, B), x::Fib(A), y::Fib(B), f̄::FibHom(f, x, y)]

Theory of dagger compact categories

In a dagger compact category, there are two kinds of adjoints of a morphism f::Hom(A,B), the adjoint mate mate(f)::Hom(dual(B),dual(A)) and the dagger adjoint dagger(f)::Hom(B,A). In the category of Hilbert spaces, these are respectively the Banach space adjoint and the Hilbert space adjoint (Reed-Simon, Vol I, Sec VI.2). In Julia, they would correspond to transpose and adjoint in the official LinearAlegbra module. For the general relationship between mates and daggers, see Selinger's survey of graphical languages for monoidal categories.

FIXME: This theory should also extend ThDaggerCategory, but multiple inheritance is not yet supported.

ThDaggerCompactCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      hom(A, B)::Ob ⊣ [A::Ob, B::Ob]
      ev(A, B)::Hom(otimes(hom(A, B), A), B) ⊣ [A::Ob, B::Ob]
      curry(A, B, f)::Hom(A, hom(B, C)) ⊣ [C::Ob, A::Ob, B::Ob, f::Hom(otimes(A, B), C)]
      
      dual(A)::Ob ⊣ [A::Ob]
      dunit(A)::Hom(munit(), otimes(dual(A), A)) ⊣ [A::Ob]
      dcounit(A)::Hom(otimes(A, dual(A)), munit()) ⊣ [A::Ob]
      mate(f)::Hom(dual(B), dual(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (hom(A, B) == otimes(B, dual(A))) ⊣ [A::Ob, B::Ob]
      (ev(A, B) == otimes(id(B), compose(braid(dual(A), A), dcounit(A)))) ⊣ [A::Ob, B::Ob]
      (curry(A, B, f) == compose(otimes(id(A), compose(dunit(B), braid(dual(B), B))), otimes(f, id(dual(B))))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(otimes(A, B), C)]
      
      dagger(f)::Hom(B, A) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Theory of lattices as algebraic structures

This is one of two standard axiomatizations of a lattice, the other being ThLattice. Because the partial order is not present, this theory is merely an algebraic theory (no dependent types).

The partial order is recovered as $A ≤ B$ iff $A ∧ B = A$ iff $A ∨ B = B$. This definition could be reintroduced into a generalized algebraic theory using an equality type Eq(lhs::El, rhs::El)::TYPE combined with term constructors `meet_leq(eq::Eq(A∧B, A))::(A ≤ B) and join_leq(eq::Eq(A∨B, B))::(A ≤ B). We do not employ that trick here because at that point it is more convenient to just start with the poset structure, as in ThLattice.

ThAlgebraicLattice

      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:135 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:135 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:135 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:135 =#
      El::TYPE ⊣ []
      meet(A, B)::El ⊣ [A::El, B::El]
      top()::El ⊣ []
      (meet(meet(A, B), C) == meet(A, meet(B, C))) ⊣ [A::El, B::El, C::El]
      (meet(A, top()) == A) ⊣ [A::El]
      (meet(top(), A) == A) ⊣ [A::El]
      (meet(A, B) == meet(B, A)) ⊣ [A::El, B::El]
      (meet(A, A) == A) ⊣ [A::El]
      join(A, B)::El ⊣ [A::El, B::El]
      bottom()::El ⊣ []
      (join(join(A, B), C) == join(A, join(B, C))) ⊣ [A::El, B::El, C::El]
      (join(A, bottom()) == A) ⊣ [A::El]
      (join(bottom(), A) == A) ⊣ [A::El]
      (join(A, B) == join(B, A)) ⊣ [A::El, B::El]
      (join(A, A) == A) ⊣ [A::El]
      (join(A, meet(A, B)) == A) ⊣ [A::El, B::El]
      (meet(A, join(A, B)) == A) ⊣ [A::El, B::El]

Theory of dagger categories

ThDaggerCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      dagger(f)::Hom(B, A) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Parse Julia programs into morphisms represented as wiring diagrams.

Generate a Julia function expression that will record function calls.

Rewrites the function body so that:

1. Ordinary function calls are mapped to recorded calls, e.g., f(x,y) becomes recorder(f,x,y)
2. "Curly" function calls are mapped to ordinary function calls, e.g., f{X,Y} becomes f(X,Y)

Evaluate pseudo-Julia type expression, such as X or otimes{X,Y}.

Make a lookup table assigning names to generators or term constructors.

Normalize arguments given as (possibly nested) tuples or vectors of values.

Parse a wiring diagram from a Julia function expression.

For more information, see the corresponding macro @program.

Record a Julia function call as a box in a wiring diagram.

Set of all symbols occuring in a Julia expression.

Parse a wiring diagram from a Julia program.

For the most part, this is standard Julia code but a few liberties are taken with the syntax. Products are represented as tuples. So if x and y are variables of type $X$ and $Y$, then (x,y) has type $X ⊗ Y$. Also, both () and nothing are interpreted as the monoidal unit $I$.

Unlike standard Julia, the function call expressions f(x,y) and f((x,y)) are equivalent. Consequently, given morphisms $f: W → X ⊗ Y$ and $g: X ⊗ Y → Z$, the code

x, y = f(w)
g(x,y)

is equivalent to g(f(w)). In standard Julia, at most one of these calls to g would be valid, unless g had multiple signatures.

The diagonals (copying and deleting) of a cartesian category are implicit in the Julia syntax: copying is variable reuse and deleting is variable non-use. For the codiagonals (merging and creating), a special syntax is provided, reinterpreting Julia's vector literals. The merging of x1 and x2 is represented by the vector [x1,x2] and creation by the empty vector []. For example, f([x1,x2]) translates to compose(mmerge(X),f).

This macro is a wrapper around parse_wiring_diagram.

Complete graph on $n$ vertices.

Cycle graph on $n$ vertices.

When $n = 1$, this is a loop graph.

erdos_renyi(GraphType, n, ne)

Create an Erdős–Rényi random graph with n vertices and ne edges.

References

• https://github.com/JuliaGraphs/LightGraphs.jl/blob/2a644c2b15b444e7f32f73021ec276aa9fc8ba30/src/SimpleGraphs/generators/randgraphs.jl

erdos_renyi(GraphType, n, p)

Create an Erdős–Rényi random graph with n vertices. Edges are added between pairs of vertices with probability p.

Optional Arguments

• seed=-1: set the RNG seed.
• rng: set the RNG directly

References

• https://github.com/JuliaGraphs/LightGraphs.jl/blob/2a644c2b15b444e7f32f73021ec276aa9fc8ba30/src/SimpleGraphs/generators/randgraphs.jl

expected_degree_graph(GraphType, ω)

Given a vector of expected degrees ω indexed by vertex, create a random undirected graph in which vertices i and j are connected with probability ω[i]*ω[j]/sum(ω).

Optional Arguments

• seed=-1: set the RNG seed.
• rng: set the RNG directly

Implementation Notes

The algorithm should work well for maximum(ω) << sum(ω). As maximum(ω) approaches sum(ω), some deviations from the expected values are likely.

References

• Connected Components in Random Graphs with Given Expected Degree Sequences, Linyuan Lu and Fan Chung. https://link.springer.com/article/10.1007%2FPL00012580
• Efficient Generation of Networks with Given Expected Degrees, Joel C. Miller and Aric Hagberg. https://doi.org/10.1007/978-3-642-21286-4_10
• https://github.com/JuliaGraphs/LightGraphs.jl/blob/2a644c2b15b444e7f32f73021ec276aa9fc8ba30/src/SimpleGraphs/generators/randgraphs.jl#L187

Graph with two vertices and $n$ parallel edges.

Path graph on $n$ vertices.

randbn(n, p, seed=-1)

Return a binomally-distribted random number with parameters n and p and optional seed.

Optional Arguments

• seed=-1: set the RNG seed.
• rng: set the RNG directly

References

• "Non-Uniform Random Variate Generation," Luc Devroye, p. 522. Retrieved via http://www.eirene.de/Devroye.pdf.
• http://stackoverflow.com/questions/23561551/a-efficient-binomial-random-number-generator-code-in-java
• https://github.com/JuliaGraphs/LightGraphs.jl/blob/2a644c2b15b444e7f32f73021ec276aa9fc8ba30/src/SimpleGraphs/generators/randgraphs.jl#L90

Star graph on $n$ vertices.

In the directed case, the edges point outward.

watts_strogatz(n, k, β)

Return a Watts-Strogatz small world random graph with n vertices, each with expected degree k (or `k

• 1ifkis odd). Edges are randomized per the model based on probabilityβ`.

The algorithm proceeds as follows. First, a perfect 1-lattice is constructed, where each vertex has exacly div(k, 2) neighbors on each side (i.e., k or k - 1 in total). Then the following steps are repeated for a hop length i of 1 through div(k, 2).

1. Consider each vertex s in turn, along with the edge to its ith nearest neighbor t, in a clockwise sense.

2. Generate a uniformly random number r. If r ≥ β, then the edge (s, t) is left unaltered. Otherwise, the edge is deleted and rewired so that s is connected to some vertex d, chosen uniformly at random from the entire graph, excluding s and its neighbors. (Note that t is a valid candidate.)

For β = 0, the graph will remain a 1-lattice, and for β = 1, all edges will be rewired randomly.

Optional Arguments

• is_directed=false: if true, return a directed graph.
• seed=-1: set the RNG seed.

References

• Collective dynamics of ‘small-world’ networks, Duncan J. Watts, Steven H. Strogatz. https://doi.org/10.1038/30918
• Small Worlds, Duncan J. watts. https://en.wikipedia.org/wiki/Special:BookSources?isbn=978-0691005416
• https://github.com/JuliaGraphs/LightGraphs.jl/blob/2a644c2b15b444e7f32f73021ec276aa9fc8ba30/src/SimpleGraphs/generators/randgraphs.jl#L187

Wheel graph on $n$ vertices.

In the directed case, the outer cycle is directed and the spokes point outward.

AST and pretty printer for Graphviz's DOT language.

References:

• DOT grammar: http://www.graphviz.org/doc/info/lang.html
• DOT language guide: http://www.graphviz.org/pdf/dotguide.pdf

AST type for Graphviz's "HTML-like" node labels.

For now, the HTML content is just a string.

labelloc defaults: "t" (clusters) , "b" (root graphs) , "c" (nodes) For graphs and clusters, only labelloc=t and labelloc=b are allowed

Pretty-print the Graphviz expression.

Run a Graphviz program.

Invokes Graphviz through its command-line interface. If the Graphviz_jll package is installed and loaded, it is used; otherwise, Graphviz must be installed on the local system.

For bindings to the Graphviz C API, see the the package GraphViz.jl. At the time of this writing, GraphViz.jl is unmaintained.

Serialize abstract wiring diagrams as JSON.

JSON data formats are convenient when programming for the web. Unfortunately, no standard for JSON graph formats has gained any kind of widespread adoption. We adopt a format compatible with that used by the KEILER project and its successor ELK (Eclipse Layout Kernel). This format is roughly feature compatible with GraphML, supporting nested graphs and ports. It also supports layout information like node position and size.

References:

• KEILER's JSON graph format: https://rtsys.informatik.uni-kiel.de/confluence/display/KIELER/JSON+Graph+Format
• ELK's JSON graph format: https://www.eclipse.org/elk/documentation/tooldevelopers/graphdatastructure/jsonformat.html

Generate a JSON dict representing a wiring diagram.

Parse a wiring diagram from a JSON string or dict.

Read a wiring diagram from a JSON file.

Write a wiring diagram to a file as JSON.

Theory of a category with (finite) products

Finite products are presented in biased style, via the nullary case (terminal objects) and the binary case (binary products). The equational axioms are standard, especially in type theory (Lambek & Scott, 1986, Section 0.5 or Section I.3). Strictly speaking, this theory is not of a "category with finite products" (a category in which finite products exist) but of a "category with chosen finite products".

For a monoidal category axiomatization of finite products, see ThCartesianCategory.

ThCategoryWithProducts

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Terminal::TYPE ⊣ []
      Product(foot1, foot2)::TYPE ⊣ [foot1::Ob, foot2::Ob]
      terminal()::Terminal ⊣ []
      ob(⊤)::Ob ⊣ [⊤::Terminal]
      delete(⊤, C)::Hom(C, ob(⊤)) ⊣ [⊤::Terminal, C::Ob]
      product(A, B)::Product(A, B) ⊣ [A::Ob, B::Ob]
      ob(Π)::Ob ⊣ [A::Ob, B::Ob, Π::Product(A, B)]
      proj1(Π)::Hom(ob(Π), A) ⊣ [A::Ob, B::Ob, Π::Product(A, B)]
      proj2(Π)::Hom(ob(Π), B) ⊣ [A::Ob, B::Ob, Π::Product(A, B)]
      pair(Π, f, g)::Hom(C, ob(Π)) ⊣ [A::Ob, B::Ob, C::Ob, Π::Product(A, B), f::Hom(C, A), g::Hom(C, B)]
      (compose(pair(Π, f, g), proj1(Π)) == f) ⊣ [A::Ob, B::Ob, C::Ob, Π::Product(A, B), f::Hom(C, A), g::Hom(C, B)]
      (compose(pair(Π, f, g), proj2(Π)) == g) ⊣ [A::Ob, B::Ob, C::Ob, Π::Product(A, B), f::Hom(C, A), g::Hom(C, B)]
      (f == g) ⊣ [C::Ob, ⊤::Terminal, f::Hom(C, ob(⊤)), g::Hom(C, ob(⊤))]
      (pair(Π, compose(h, proj1(Π)), compose(h, proj2(Π))) == h) ⊣ [A::Ob, B::Ob, C::Ob, Π::Product(A, B), h::Hom(C, ob(Π))]

The category of finite sets and functions, and its skeleton.

Discrete category on a finite set.

The only morphisms in a discrete category are the identities, which are here identified with the objects.

Function out of a finite set.

This class of functions is convenient because it is exactly the class that can be represented explicitly by a vector of values from the codomain.

Function in Set represented by a dictionary.

The domain is a FinSet{S} where S is the type of the dictionary's keys collection.

Function in Set represented by a vector.

The domain of this function is always of type FinSet{Int}, with elements of the form ${1,...,n}$.

Function between finite sets.

The function can be defined implicitly by an arbitrary Julia function, in which case it is evaluated lazily, or explictly by a vector of integers. In the vector representation, the function (1↦1, 2↦3, 3↦2, 4↦3), for example, is represented by the vector [1,3,2,3].

FinFunctions can be constructed with or without an explicitly provided codomain. If a codomain is provided, by default the constructor checks it is valid.

This type is mildly generalized by FinDomFunction.

Function in FinSet represented by a dictionary.

Function in FinSet represented explicitly by a vector.

Finite set.

A finite set has abstract type FinSet{S,T}. The second type parameter T is the element type of the set and the first parameter S is the collection type, which can be a subtype of AbstractSet or another Julia collection type. In addition, the skeleton of the category FinSet is the important special case S = Int. The set ${1,…,n}$ is represented by the object FinSet(n) of type FinSet{Int,Int}.

Finite set given by Julia collection.

The underlying collection should be a Julia iterable of definite length. It may be, but is not required to be, set-like (a subtype of AbstractSet).

Colimit of general diagram of FinSets computed by coproduct-then-quotient.

See Limits.CompositePushout for a very similar construction.

Limit of general diagram of FinSets computed by product-then-filter.

See Limits.CompositePullback for a very similar construction.

Limit of finite sets with a reverse mapping or index into the limit set.

This type provides a fallback for limit algorithms that do not come with a specialized algorithm to apply the universal property of the limit. In such cases, you can explicitly construct a mapping from tuples of elements in the feet of the limit cone to elements in the apex of the cone.

The index is constructed the first time it is needed. Thus there is no extra cost to using this type if the universal property will not be invoked.

Finite set of the form ${1,…,n}$ for some number $n ≥ 0$.

Hash join algorithm.

Indexed function out of a finite set of type FinSet{Int}.

Works in the same way as the special case of IndexedFinFunctionVector, except that the index is typically a dictionary, not a vector.

Indexed function between finite sets of type FinSet{Int}.

Indexed functions store both the forward map $f: X → Y$, as a vector of integers, and the backward map $f: Y → X⁻¹$, as a vector of vectors of integers, accessible through the preimage function. The backward map is called the index. If it is not supplied through the keyword argument index, it is computed when the object is constructed.

This type is mildly generalized by IndexedFinDomFunctionVector.

Algorithm for limit of cospan or multicospan with feet being finite sets.

In the context of relational databases, such limits are called joins. The trivial join algorithm is NestedLoopJoin, which is algorithmically equivalent to the generic algorithm ComposeProductEqualizer. The algorithms HashJoin and SortMergeJoin are usually much faster. If you are unsure what algorithm to pick, use SmartJoin.

Compute colimit of finite sets whose elements are meaningfully named.

This situation seems to be mathematically uninteresting but is practically important. The colimit is computed by reduction to the skeleton of FinSet (FinSet{Int}) and the names are assigned afterwards, following some reasonable conventions and add tags where necessary to avoid name clashes.

Nested-loop join algorithm.

This is the naive algorithm for computing joins.

Meta-algorithm for joins that attempts to pick an appropriate algorithm.

Sort-merge join algorithm.

Subset of a finite set.

Subset of a finite set represented as a boolean vector.

This is the subobject classifier representation since Bool is the subobject classifier for Set.

Algorithm to compute subobject operations using elementwise boolean logic.

Limit of finite sets viewed as a table.

Any limit of finite sets can be canonically viewed as a table (TabularSet) whose columns are the legs of the limit cone and whose rows correspond to elements of the limit object. To construct this table from an already computed limit, call TabularLimit(::AbstractLimit; ...). The column names of the table are given by the optional argument names.

In this tabular form, applying the universal property of the limit is trivial since it is just tupling. Thus, this representation can be useful when the original limit algorithm does not support efficient application of the universal property. On the other hand, this representation has the disadvantage of generally making the element type of the limit set more complicated.

Finite set whose elements are rows of a table.

The underlying table should be compliant with Tables.jl. For the sake of uniformity, the rows are provided as named tuples, which assumes that the table is not "extremely wide". This should not be a major limitation in practice but see the Tables.jl documentation for further discussion.

Data type for a morphism of VarSet{T}s. Note we can equivalently view these as morphisms [n]+T -> [m]+T fixing T or as morphisms [n] -> [m]+T, in the typical Kleisli category yoga.

Currently, domains are treated as VarSets. The codom field is treated as a FinSet{Int}. Note that the codom accessor gives a VarSet while the codom field is just that VarSet's FinSet of AttrVars. This could be generalized to being FinSet{Symbol} to allow for symbolic attributes. (Likewise, AttrVars will have to wrap Any rather than Int)

Control dispatch in the category of VarFunctions

The preimage (inverse image) of the value y in the codomain.

Compose [n]->[m] with [m]->[p]+T, yielding a [n]->T+[p]

Compose [n]->[m]+T with [m]->[p], yielding a [n]->T+[p]

Kleisi composition of [n]->T+[m] and [m]->T'+[p], yielding a [n]->T'+[p]

The iterable part of a varset is its collection of AttrVars.

Compute all possible equalizers in a bipartite free diagram.

The result is a new bipartite free diagram that has the same vertices but is simple, i.e., has no multiple edges. The list of inclusion morphisms into layer 1 of the original diagram is also returned.

Whether the given function is indexed, i.e., supports efficient preimages.

Perform all possible pairings in a bipartite free diagram.

The resulting diagram has the same layer 1 vertices but a possibly reduced set of layer 2 vertices. Layer 2 vertices are merged when they have exactly the same multiset of adjacent vertices.

Given h: X → Y, pass to quotient q: X/~ → Y under projection π: X → X/~.

Create projection map π: X → X/∼ from partition of X.

Make list of elements unique by adding tags if necessary.

If the elements are already unique, they will not be mutated.

Theory of Heyting algebra of subobjects in a Heyting category, such as a topos.

ThSubobjectHeytingAlgebra

      Ob::TYPE ⊣ []
      Sub(ob)::TYPE ⊣ [ob::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      meet(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      join(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      top(X)::Sub(X) ⊣ [X::Ob]
      bottom(X)::Sub(X) ⊣ [X::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:54 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:54 =#
      implies(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      negate(A)::Sub(X) ⊣ [X::Ob, A::Sub(X)]

Theory of bi-Heyting algebra of subobjects in a bi-Heyting topos, such as a presheaf topos.

ThSubobjectBiHeytingAlgebra

      Ob::TYPE ⊣ []
      Sub(ob)::TYPE ⊣ [ob::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:37 =#
      meet(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      join(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      top(X)::Sub(X) ⊣ [X::Ob]
      bottom(X)::Sub(X) ⊣ [X::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:54 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:54 =#
      implies(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      negate(A)::Sub(X) ⊣ [X::Ob, A::Sub(X)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:67 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/categorical_algebra/Subobjects.jl:67 =#
      subtract(A, B)::Sub(X) ⊣ [X::Ob, A::Sub(X), B::Sub(X)]
      non(A)::Sub(X) ⊣ [X::Ob, A::Sub(X)]

Syntax for a free cartesian category.

In this syntax, the pairing and projection operations are defined using duplication and deletion, and do not have their own syntactic elements. This convention could be dropped or reversed.

elements(f::ACSetTransformation)

Apply category of elements functor to a morphism f: X->Y. This relies on the fact elements of an object puts El components from the same Ob in a contiguous index range.

elements(X::AbstractACSet)

construct the category of elements from an ACSet. This only correctly handles the CSet part. This transformation converts an instance of C into a Graph homomorphism. The codomain of the homomorphism is a graph shaped like the schema. This is one half of the isomorphism between databases and knowledge graphs.

inverse_elements(X::AbstractElements, typ::StructACSet)

Compute inverse grothendieck transformation on a morphism of Elements

inverse_elements(X::AbstractElements, typ::StructACSet)

Compute inverse grothendieck transformation on the result of elements. Does not assume that the elements are ordered. Rather than dynamically create a new ACSet type, it requires any instance of the ACSet type that it's going to try to create

If the typed graph tries to assert conflicting values for a foreign key, fail. If no value is specified for a foreign key, the result will have 0's.

Determine the (partial) mapping from Elements to indices for each component E.g. [V,E,V,V,E] ⟶ [V=>{1↦1, 3↦2, 4↦3}, E=>{2↦1, 5↦2}]

presentation(X::AbstractElements)

convert a category of elements into a new schema. This is useful for generating large schemas that are defined as the category of elements of a specified C-Set. For example, the schema for Bipartite Graphs is the category of elements of the graph with 2 vertices and 1 edge. The 2 vertices will get mapped to elements V_1, V_2 and the one edge will be E_1 and the source and target maps will be mapped to src_E_1, tgt_E_1.

Theory of (symmetric) closed monoidal categories

ThClosedMonoidalCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      hom(A, B)::Ob ⊣ [A::Ob, B::Ob]
      ev(A, B)::Hom(otimes(hom(A, B), A), B) ⊣ [A::Ob, B::Ob]
      curry(A, B, f)::Hom(A, hom(B, C)) ⊣ [C::Ob, A::Ob, B::Ob, f::Hom(otimes(A, B), C)]

Theory of preorders

The generalized algebraic theory of preorders encodes inequalities $A≤B$ as dependent types `$Leq(A,B)$ and the axioms of reflexivity and transitivity as term constructors.

ThPreorder

      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:46 =#
      El::TYPE ⊣ []
      Leq(lhs, rhs)::TYPE ⊣ [lhs::El, rhs::El]
      reflexive(A)::Leq(A, A) ⊣ [A::El]
      transitive(f, g)::Leq(A, C) ⊣ [A::El, B::El, C::El, f::Leq(A, B), g::Leq(B, C)]
      (f == g) ⊣ [A::El, B::El, f::Leq(A, B), g::Leq(A, B)]

Theory of a distributive bicategory of relations

References:

• Carboni & Walters, 1987, "Cartesian bicategories I", Remark 3.7 (mention in passing only)
• Patterson, 2017, "Knowledge representation in bicategories of relations", Section 9.2

FIXME: Should also inherit ThBicategoryOfRelations, but multiple inheritance is not yet supported.

ThDistributiveBicategoryRelations

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:33 =#
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      (copair(f, g) == compose(oplus(f, g), plus(C))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      (coproj1(A, B) == oplus(id(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (coproj2(A, B) == oplus(zero(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:68 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:70 =#
      
      dagger(R)::Hom(B, A) ⊣ [A::Ob, B::Ob, R::Hom(A, B)]
      dunit(A)::Hom(munit(), otimes(A, A)) ⊣ [A::Ob]
      dcounit(A)::Hom(otimes(A, A), munit()) ⊣ [A::Ob]
      mmerge(A)::Hom(otimes(A, A), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Relations.jl:90 =#
      create(A)::Hom(munit(), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Relations.jl:92 =#
      coplus(A)::Hom(A, oplus(A, A)) ⊣ [A::Ob]
      cozero(A)::Hom(A, mzero()) ⊣ [A::Ob]
      pair(R, S)::Hom(A, oplus(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, R::Hom(A, B), S::Hom(A, C)]
      proj1(A, B)::Hom(oplus(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(oplus(A, B), B) ⊣ [A::Ob, B::Ob]
      meet(R, S)::Hom(A, B) ⊣ [A::Ob, B::Ob, R::Hom(A, B), S::Hom(A, B)]
      top(A, B)::Hom(A, B) ⊣ [A::Ob, B::Ob]
      join(R, S)::Hom(A, B) ⊣ [A::Ob, B::Ob, R::Hom(A, B), S::Hom(A, B)]
      bottom(A, B)::Hom(A, B) ⊣ [A::Ob, B::Ob]

Theory of a distributive (symmetric) monoidal category

Reference: Jay, 1992, LFCS tech report LFCS-92-205, "Tail recursion through universal invariants", Section 3.2

FIXME: Should also inherit ThCocartesianCategory.

ThDistributiveMonoidalCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:33 =#
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      (copair(f, g) == compose(oplus(f, g), plus(C))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      (coproj1(A, B) == oplus(id(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (coproj2(A, B) == oplus(zero(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Theory of an ℳ-category.

The term "ℳ-category", used on the nLab is not very common, but the concept itself shows up commonly. An ℳ-category is a category with a distinguished wide subcategory, whose morphisms are suggestively called tight; for contrast, a generic morphism is called loose. Equivalently, an ℳ-category is a category enriched in the category ℳ of injections, the full subcategory of the arrow category of Set spanned by injections.

In the following GAT, tightness is axiomatized as a property of morphisms: a dependent family of sets over the hom-sets, each having at most one inhabitant.

ThMCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      Tight(hom)::TYPE ⊣ [A::Ob, B::Ob, hom::Hom(A, B)]
      (t == t′) ⊣ [A::Ob, B::Ob, f::Hom(A, B), t::Tight(f), t′::Tight(f)]
      reflexive(A)::Tight(id(A)) ⊣ [A::Ob]
      transitive(t, u)::Tight(compose(f, g)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(B, C), t::Tight(f), u::Tight(g)]

Theory of partial orders (posets)

ThPoset

      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:46 =#
      El::TYPE ⊣ []
      Leq(lhs, rhs)::TYPE ⊣ [lhs::El, rhs::El]
      reflexive(A)::Leq(A, A) ⊣ [A::El]
      transitive(f, g)::Leq(A, C) ⊣ [A::El, B::El, C::El, f::Leq(A, B), g::Leq(B, C)]
      (f == g) ⊣ [A::El, B::El, f::Leq(A, B), g::Leq(A, B)]
      
      (A == B) ⊣ [A::El, B::El, f::Leq(A, B), g::Leq(B, A)]

Theory of monoidal categories with bidiagonals, in additive notation

Mathematically the same as ThMonoidalCategoryWithBidiagonals but written additively, instead of multiplicatively.

ThMonoidalCategoryWithBidiagonalsAdditive

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      (compose(oplus(plus(A), id(A)), plus(A)) == compose(oplus(id(A), plus(A)), plus(A))) ⊣ [A::Ob]
      (compose(oplus(zero(A), id(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (compose(oplus(id(A), zero(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (plus(A) == compose(swap(A, A), plus(A))) ⊣ [A::Ob]
      (plus(oplus(A, B)) == compose(oplus(oplus(id(A), swap(B, A)), id(B)), oplus(plus(A), plus(B)))) ⊣ [A::Ob, B::Ob]
      (zero(oplus(A, B)) == oplus(zero(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (plus(mzero()) == id(mzero())) ⊣ []
      (zero(mzero()) == id(mzero())) ⊣ []
      
      mcopy(A)::Hom(A, oplus(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:157 =#
      delete(A)::Hom(A, mzero()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:159 =#
      (mcopy(A) == compose(mcopy(A), swap(A, A))) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(mcopy(A), id(A))) == compose(mcopy(A), oplus(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), oplus(id(A), delete(A))) == id(A)) ⊣ [A::Ob]

Theory of a symmetric monoidal copresheaf

The name is not standard but refers to a lax symmetric monoidal functor into Set. This can be interpreted as an action of a symmetric monoidal category, just as a copresheaf (set-valued functor) is an action of a category. The theory is simpler than that of a general lax monoidal functor because (1) the domain is a strict monoidal category and (2) the codomain is fixed to the cartesian monoidal category Set.

FIXME: This theory should also extend ThCopresheaf but multiple inheritance is not yet supported.

ThSymmetricMonoidalCopresheaf

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      El(ob)::TYPE ⊣ [ob::Ob]
      act(x, f)::El(B) ⊣ [A::Ob, B::Ob, x::El(A), f::Hom(A, B)]
      otimes(x, y)::El(otimes(A, B)) ⊣ [A::Ob, B::Ob, x::El(A), y::El(B)]
      elunit()::El(munit()) ⊣ []
      (act(act(x, f), g) == act(x, compose(f, g))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(B, C), x::El(A)]

Theory of cartesian closed categories, aka CCCs

A CCC is a cartesian category with internal homs (aka, exponential objects).

FIXME: This theory should also extend ThClosedMonoidalCategory, but multiple inheritance is not yet supported.

ThCartesianClosedCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:178 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:180 =#
      (compose(mcopy(A), otimes(mcopy(A), id(A))) == compose(mcopy(A), otimes(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), braid(A, A)) == mcopy(A)) ⊣ [A::Ob]
      (mcopy(otimes(A, B)) == compose(otimes(mcopy(A), mcopy(B)), otimes(otimes(id(A), braid(A, B)), id(B)))) ⊣ [A::Ob, B::Ob]
      (delete(otimes(A, B)) == otimes(delete(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (mcopy(munit()) == id(munit())) ⊣ []
      (delete(munit()) == id(munit())) ⊣ []
      
      pair(f, g)::Hom(A, otimes(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, B), g::Hom(A, C)]
      proj1(A, B)::Hom(otimes(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(otimes(A, B), B) ⊣ [A::Ob, B::Ob]
      (pair(f, g) == compose(mcopy(C), otimes(f, g))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(C, A), g::Hom(C, B)]
      (proj1(A, B) == otimes(id(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (proj2(A, B) == otimes(delete(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(f, mcopy(B)) == compose(mcopy(A), otimes(f, f))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(f, delete(B)) == delete(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      
      hom(A, B)::Ob ⊣ [A::Ob, B::Ob]
      ev(A, B)::Hom(otimes(hom(A, B), A), B) ⊣ [A::Ob, B::Ob]
      curry(A, B, f)::Hom(A, hom(B, C)) ⊣ [C::Ob, A::Ob, B::Ob, f::Hom(otimes(A, B), C)]

Theory of monoidal categories

To avoid associators and unitors, we assume that the monoidal category is strict. By the coherence theorem this involves no loss of generality, but we might add a theory for weak monoidal categories later.

ThMonoidalCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]

Syntax for a free cartesian closed category.

See also FreeCartesianCategory.

Theory of an opindexed, or covariantly indexed, monoidal category.

An opindexed monoidal category is a pseudofunctor into MonCat, the 2-category of monoidal categories, strong monoidal functors, and monoidal natural transformations. For simplicity, we take the pseudofunctor, the monoidal categories, and the monoidal functors all to be strict.

References:

• nLab: indexed monoidal category
• Shulman, 2008: Framed bicategories and monoidal fibrations
• Shulman, 2013: Enriched indexed categories

ThOpindexedMonoidalCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:60 =#
      Fib(ob)::TYPE ⊣ [ob::Ob]
      FibHom(dom, codom)::TYPE ⊣ [A::Ob, dom::Fib(A), codom::Fib(A)]
      id(X)::FibHom(X, X) ⊣ [A::Ob, X::Fib(A)]
      compose(u, v)::FibHom(X, Z) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(X, Y), v::FibHom(Y, Z)]
      act(X, f)::Fib(B) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      act(u, f)::FibHom(act(X, f), act(Y, f)) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y), f::Hom(A, B)]
      (compose(compose(u, v), w) == compose(u, compose(v, w))) ⊣ [A::Ob, W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(W, X), v::FibHom(X, Y), w::FibHom(Y, Z)]
      (compose(u, id(X)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (compose(id(X), u) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (act(compose(u, v), f) == compose(act(u, f), act(v, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), f::Hom(A, B), u::FibHom(X, Y), v::FibHom(Y, Z)]
      (act(id(X), f) == id(act(X, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), f::Hom(A, B)]
      (act(X, compose(f, g)) == act(act(X, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), f::Hom(A, B), g::Hom(A, C)]
      (act(u, compose(f, g)) == act(act(u, f), g)) ⊣ [A::Ob, B::Ob, C::Ob, X::Fib(A), Y::Fib(A), f::Hom(A, B), g::Hom(B, C), u::FibHom(X, Y)]
      (act(X, id(A)) == X) ⊣ [A::Ob, X::Fib(A)]
      (act(u, id(A)) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/IndexedCategory.jl:102 =#
      otimes(X, Y)::Fib(A) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]
      otimes(u, v)::FibHom(otimes(X, W), otimes(Y, Z)) ⊣ [A::Ob, W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(X, Y), v::FibHom(W, Z)]
      munit(A)::Fib(A) ⊣ [A::Ob]
      (otimes(otimes(X, Y), Z) == otimes(X, otimes(Y, Z))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A)]
      (otimes(munit(A), X) == X) ⊣ [A::Ob, X::Fib(A)]
      (otimes(X, munit(A)) == X) ⊣ [A::Ob, X::Fib(A)]
      (otimes(otimes(u, v), w) == otimes(u, otimes(v, w))) ⊣ [A::Ob, U::Fib(A), V::Fib(A), W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), u::FibHom(U, X), v::FibHom(V, Y), w::FibHom(W, Z)]
      (otimes(id(munit(A)), u) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (otimes(u, id(munit(A))) == u) ⊣ [A::Ob, X::Fib(A), Y::Fib(A), u::FibHom(X, Y)]
      (compose(otimes(t, u), otimes(v, w)) == otimes(compose(t, v), compose(u, w))) ⊣ [A::Ob, U::Fib(A), V::Fib(A), W::Fib(A), X::Fib(A), Y::Fib(A), Z::Fib(A), t::FibHom(U, V), v::FibHom(V, W), u::FibHom(X, Y), w::FibHom(Y, Z)]
      (id(otimes(X, Y)) == otimes(id(X), id(Y))) ⊣ [A::Ob, X::Fib(A), Y::Fib(A)]
      
      (act(otimes(X, Y), f) == otimes(act(X, f), act(Y, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), f::Hom(A, B)]
      (act(munit(A), f) == munit(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (act(otimes(u, v), f) == otimes(act(u, f), act(v, f))) ⊣ [A::Ob, B::Ob, X::Fib(A), Y::Fib(A), Z::Fib(A), W::Fib(A), f::Hom(A, B), u::FibHom(X, Z), v::FibHom(Y, W)]

Theory of dagger symmetric monoidal categories

Also known as a symmetric monoidal dagger category.

FIXME: This theory should also extend ThDaggerCategory, but multiple inheritance is not yet supported.

ThDaggerSymmetricMonoidalCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      dagger(f)::Hom(B, A) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Theory of monoidal categories with codiagonals

A monoidal category with codiagonals is a symmetric monoidal category equipped with coherent collections of merging and creating morphisms (monoids). Unlike in a cocartesian category, the naturality axioms need not be satisfied.

For references, see ThMonoidalCategoryWithDiagonals.

ThMonoidalCategoryWithCodiagonals

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      (compose(oplus(plus(A), id(A)), plus(A)) == compose(oplus(id(A), plus(A)), plus(A))) ⊣ [A::Ob]
      (compose(oplus(zero(A), id(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (compose(oplus(id(A), zero(A)), plus(A)) == id(A)) ⊣ [A::Ob]
      (plus(A) == compose(swap(A, A), plus(A))) ⊣ [A::Ob]
      (plus(oplus(A, B)) == compose(oplus(oplus(id(A), swap(B, A)), id(B)), oplus(plus(A), plus(B)))) ⊣ [A::Ob, B::Ob]
      (zero(oplus(A, B)) == oplus(zero(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (plus(mzero()) == id(mzero())) ⊣ []
      (zero(mzero()) == id(mzero())) ⊣ []

Theory of a distributive (symmetric) monoidal category

Reference: Jay, 1992, LFCS tech report LFCS-92-205, "Tail recursion through universal invariants", Section 3.2

FIXME: Should also inherit ThCocartesianCategory.

ThDistributiveMonoidalCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:33 =#
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      (copair(f, g) == compose(oplus(f, g), plus(C))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      (coproj1(A, B) == oplus(id(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (coproj2(A, B) == oplus(zero(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Theory of a symmetric rig category

FIXME: Should also inherit ThSymmetricMonoidalCategory.

ThSymmetricRigCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:33 =#

Theory of hypergraph categories

Hypergraph categories are also known as "well-supported compact closed categories" and "spidered/dungeon categories", among other things.

FIXME: Should also inherit ThClosedMonoidalCategory and ThDaggerCategory, but multiple inheritance is not yet supported.

ThHypergraphCategory

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:28 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      (otimes(otimes(A, B), C) == otimes(A, otimes(B, C))) ⊣ [A::Ob, B::Ob, C::Ob]
      (otimes(munit(), A) == A) ⊣ [A::Ob]
      (otimes(A, munit()) == A) ⊣ [A::Ob]
      (otimes(otimes(f, g), h) == otimes(f, otimes(g, h))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, X), g::Hom(B, Y), h::Hom(C, Z)]
      (otimes(id(munit()), f) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (otimes(f, id(munit())) == f) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(otimes(f, g), otimes(h, k)) == otimes(compose(f, h), compose(g, k))) ⊣ [A::Ob, B::Ob, C::Ob, X::Ob, Y::Ob, Z::Ob, f::Hom(A, B), h::Hom(B, C), g::Hom(X, Y), k::Hom(Y, Z)]
      (id(otimes(A, B)) == otimes(id(A), id(B))) ⊣ [A::Ob, B::Ob]
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:87 =#
      (compose(braid(A, B), braid(B, A)) == id(otimes(A, B))) ⊣ [A::Ob, B::Ob]
      (braid(A, otimes(B, C)) == compose(otimes(braid(A, B), id(C)), otimes(id(B), braid(A, C)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(otimes(A, B), C) == compose(otimes(id(A), braid(B, C)), otimes(braid(A, C), id(B)))) ⊣ [A::Ob, B::Ob, C::Ob]
      (braid(A, munit()) == id(A)) ⊣ [A::Ob]
      (braid(munit(), A) == id(A)) ⊣ [A::Ob]
      (compose(otimes(f, g), braid(B, D)) == compose(braid(A, C), otimes(g, f))) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:178 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:180 =#
      (compose(mcopy(A), otimes(mcopy(A), id(A))) == compose(mcopy(A), otimes(id(A), mcopy(A)))) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(delete(A), id(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), otimes(id(A), delete(A))) == id(A)) ⊣ [A::Ob]
      (compose(mcopy(A), braid(A, A)) == mcopy(A)) ⊣ [A::Ob]
      (mcopy(otimes(A, B)) == compose(otimes(mcopy(A), mcopy(B)), otimes(otimes(id(A), braid(A, B)), id(B)))) ⊣ [A::Ob, B::Ob]
      (delete(otimes(A, B)) == otimes(delete(A), delete(B))) ⊣ [A::Ob, B::Ob]
      (mcopy(munit()) == id(munit())) ⊣ []
      (delete(munit()) == id(munit())) ⊣ []
      
      mmerge(A)::Hom(otimes(A, A), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:248 =#
      create(A)::Hom(munit(), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Monoidal.jl:250 =#
      
      dunit(A)::Hom(munit(), otimes(A, A)) ⊣ [A::Ob]
      dcounit(A)::Hom(otimes(A, A), munit()) ⊣ [A::Ob]
      dagger(f)::Hom(B, A) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (dunit(A) == compose(create(A), mcopy(A))) ⊣ [A::Ob]
      (dcounit(A) == compose(mmerge(A), delete(A))) ⊣ [A::Ob]
      (dagger(f) == compose(compose(otimes(id(B), dunit(A)), otimes(otimes(id(B), f), id(A))), otimes(dcounit(B), id(A)))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Theory of a distributive bicategory of relations

References:

• Carboni & Walters, 1987, "Cartesian bicategories I", Remark 3.7 (mention in passing only)
• Patterson, 2017, "Knowledge representation in bicategories of relations", Section 9.2

FIXME: Should also inherit ThBicategoryOfRelations, but multiple inheritance is not yet supported.

ThDistributiveBicategoryRelations

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalAdditive.jl:19 =#
      oplus(A, B)::Ob ⊣ [A::Ob, B::Ob]
      oplus(f, g)::Hom(oplus(A, C), oplus(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      mzero()::Ob ⊣ []
      
      swap(A, B)::Hom(oplus(A, B), oplus(B, A)) ⊣ [A::Ob, B::Ob]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:20 =#
      otimes(A, B)::Ob ⊣ [A::Ob, B::Ob]
      otimes(f, g)::Hom(otimes(A, C), otimes(B, D)) ⊣ [A::Ob, B::Ob, C::Ob, D::Ob, f::Hom(A, B), g::Hom(C, D)]
      munit()::Ob ⊣ []
      
      braid(A, B)::Hom(otimes(A, B), otimes(B, A)) ⊣ [A::Ob, B::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:33 =#
      
      plus(A)::Hom(oplus(A, A), A) ⊣ [A::Ob]
      zero(A)::Hom(mzero(), A) ⊣ [A::Ob]
      copair(f, g)::Hom(oplus(A, B), C) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      coproj1(A, B)::Hom(A, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      coproj2(A, B)::Hom(B, oplus(A, B)) ⊣ [A::Ob, B::Ob]
      (copair(f, g) == compose(oplus(f, g), plus(C))) ⊣ [A::Ob, B::Ob, C::Ob, f::Hom(A, C), g::Hom(B, C)]
      (coproj1(A, B) == oplus(id(A), zero(B))) ⊣ [A::Ob, B::Ob]
      (coproj2(A, B) == oplus(zero(A), id(B))) ⊣ [A::Ob, B::Ob]
      (compose(plus(A), f) == compose(oplus(f, f), plus(B))) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(zero(A), f) == zero(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      
      mcopy(A)::Hom(A, otimes(A, A)) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:68 =#
      delete(A)::Hom(A, munit()) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/MonoidalMultiple.jl:70 =#
      
      dagger(R)::Hom(B, A) ⊣ [A::Ob, B::Ob, R::Hom(A, B)]
      dunit(A)::Hom(munit(), otimes(A, A)) ⊣ [A::Ob]
      dcounit(A)::Hom(otimes(A, A), munit()) ⊣ [A::Ob]
      mmerge(A)::Hom(otimes(A, A), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Relations.jl:90 =#
      create(A)::Hom(munit(), A) ⊣ [A::Ob]
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Relations.jl:92 =#
      coplus(A)::Hom(A, oplus(A, A)) ⊣ [A::Ob]
      cozero(A)::Hom(A, mzero()) ⊣ [A::Ob]
      pair(R, S)::Hom(A, oplus(B, C)) ⊣ [A::Ob, B::Ob, C::Ob, R::Hom(A, B), S::Hom(A, C)]
      proj1(A, B)::Hom(oplus(A, B), A) ⊣ [A::Ob, B::Ob]
      proj2(A, B)::Hom(oplus(A, B), B) ⊣ [A::Ob, B::Ob]
      meet(R, S)::Hom(A, B) ⊣ [A::Ob, B::Ob, R::Hom(A, B), S::Hom(A, B)]
      top(A, B)::Hom(A, B) ⊣ [A::Ob, B::Ob]
      join(R, S)::Hom(A, B) ⊣ [A::Ob, B::Ob, R::Hom(A, B), S::Hom(A, B)]
      bottom(A, B)::Hom(A, B) ⊣ [A::Ob, B::Ob]

Theory of groupoids.

ThGroupoid

      Ob::TYPE ⊣ []
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:24 =#
      Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob]
      
      #= /juliateam/.julia/packages/GATlab/UL4sq/src/stdlib/theories/categories.jl:33 =#
      compose(f, g)::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob, f::Hom(a, b), g::Hom(b, c)]
      
      (assoc := compose(compose(f, g), h) == compose(f, compose(g, h))) ⊣ [a::Ob, b::Ob, c::Ob, d::Ob, f::Hom(a, b), g::Hom(b, c), h::Hom(c, d)]
      
      id(a)::Hom(a, a) ⊣ [a::Ob]
      
      (idl := compose(id(a), f) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      (idr := compose(f, id(b)) == f) ⊣ [a::Ob, b::Ob, f::Hom(a, b)]
      
      inv(f)::Hom(B, A) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(f, inv(f)) == id(A)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]
      (compose(inv(f), f) == id(B)) ⊣ [A::Ob, B::Ob, f::Hom(A, B)]

Theory of lattices as posets

A (bounded) lattice is a poset with all finite meets and joins. Viewed as a thin category, this means that the category has all finite products and coproducts, hence the names for the inequality constructors in the theory. Compare with ThCartesianCategory and ThCocartesianCategory.

This is one of two standard axiomatizations of a lattice, the other being ThAlgebraicLattice.

ThLattice

      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:46 =#
      El::TYPE ⊣ []
      Leq(lhs, rhs)::TYPE ⊣ [lhs::El, rhs::El]
      reflexive(A)::Leq(A, A) ⊣ [A::El]
      transitive(f, g)::Leq(A, C) ⊣ [A::El, B::El, C::El, f::Leq(A, B), g::Leq(B, C)]
      (f == g) ⊣ [A::El, B::El, f::Leq(A, B), g::Leq(A, B)]
      
      (A == B) ⊣ [A::El, B::El, f::Leq(A, B), g::Leq(B, A)]
      
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:92 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:92 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:92 =#
      #= /juliateam/.julia/packages/Catlab/5M12F/src/theories/Preorders.jl:92 =#
      meet(A, B)::El ⊣ [A::El, B::El]
      proj1(A, B)::Leq(meet(A, B), A) ⊣ [A::El, B::El]
      proj2(A, B)::Leq(meet(A, B), B) ⊣ [A::El, B::El]
      pair(f, g)::Leq(C, meet(A, B)) ⊣ [A::El, B::El, C::El, f::Leq(C, A), g::Leq(C, B)]
      top()::El ⊣ []
      delete(A)::Leq(A, top()) ⊣ [A::El]
      join(A, B)::El ⊣ [A::El, B::El]
      coproj1(A, B)::Leq(A, join(A, B)) ⊣ [A::El, B::El]
      coproj2(A, B)::Leq(B, join(A, B)) ⊣ [A::El, B::El]
      copair(f, g)::Leq(join(A, B), C) ⊣ [A::El, B::El, C::El, f::Leq(A, C), g::Leq(B, C)]
      bottom()::El ⊣ []
      create(A)::Leq(bottom(), A) ⊣ [A::El]

Theory of a distributive monoidal category with diagonals