Catlab.jl

Catlab.jl is a Julia-based framework for applied and computational category theory. It provides a programming library and an interactive computing environment for scientific and engineering applications of category theory. While it emphasizes monoidal categories, it is designed to support any categorical structure formalizable as a generalized algebraic theory.

Key capabilities include:

• Programming Library: Provides data structures, algorithms, and serialization for applied category theory. It uses macros for specifying categorical doctrines and type-safe symbolic manipulation. It supports wiring diagrams (string diagrams) with serialization to GraphML and JSON.
• Interactive Computing: Supports Jupyter notebooks with LaTeX rendering for symbolic expressions and visualization of wiring diagrams via Compose.jl, Graphviz, or TikZ.
• Computer Algebra System: Acts as a computer algebra system for categorical algebra, using expressions typed via generalized algebraic theories. It implements algorithms for solving word problems and reducing expressions to normal forms for various doctrines (e.g., categories, symmetric monoidal categories).

Catlab offers three ways to implement acsets depending on whether your schema is known at compile-time or runtime:

1. Static Acset Types (Compile-time)

Best for performance and clear error messages when the schema is fixed.

• @acset_type: Creates custom-derived structs.

  • Pros: Clear names (e.g., Graph) in error messages.
  • Cons: Requires eval if schemas are only known at runtime.
  • Usage: @acset_type MyType(MySchema) g = MyType()

• AnonACSet: Uses AnonACSetType to create types that include the schema and field types in the type signature.

  • Pros: Can be used with schemas passed at runtime without eval.
  • Cons: Very long, complex type names in error messages.
  • Usage: const MyType = AnonACSetType(MySchema) g = MyType()

2. Dynamic Acset Types (Runtime)

• DynamicACSet: The schema is stored as a field within the object.
  • Pros: Faster if the schema is very large compared to the data; handles runtime schemas easily.
  • Cons: Does not benefit from code generation; many high-level constructions (like limits/colimits) currently require the schema to be derivable from the type, so they may not work as a drop-in replacement for static acsets yet.
  • Usage: g = DynamicACSet("MyGraph", MySchema; index=[:src,:tgt])

# Static via @acset_type
@acset_type WeightedGraph(SchWeightedGraph, index=[:src,:tgt])
g = WeightedGraph()

# Static via AnonACSet (for runtime schemas)
const WeightedGraph = AnonACSetType(SchWeightedGraph, index=[:src,:tgt])
g = WeightedGraph()

# Dynamic
g = DynamicACSet("WeightedGraph", SchWeightedGraph; index=[:src,:tgt])

Catlab.jl uses an "Abstract Field Convention" to manage complex type parameters and reduce boilerplate. Instead of defining all fields in an abstract type (which Julia does not support), Catlab defines an abstract type and documents the expected fields in a comment. Subtypes are then expected to implement these fields in the same order.

This convention is used instead of standard Julia field-access methods to:

1. Avoid excessive boilerplate for large numbers of similar structs.
2. Provide a stronger guarantee than a standard interface: it claims that subtypes have precisely these fields in this specific order, which is necessary for operations like copy.

Note: This is a departure from standard Julia wisdom regarding encapsulation; it prioritizes reducing type name length in debug messages and enabling specific structural operations.

# The convention pattern:

"""
Abstract Fields
- x1::A
- x2::A
"""
abstract type Pair{A} end

add(xs::Pair) = xs.x1 + xs.x2

struct IntPair <: Pair{Int}
  x1::Int
  x2::Int
end

# This allows structural operations like:
function copy(p::T) where {T<:Pair}
  T(p.x1, p.x2)
end

An Acset (Attribute Set) is a data structure parameterized by a schema. A schema defines the structure of the acset using four components:

1. Objects (Ob): The primary entities (e.g., Vertices, Edges).
2. Homomorphisms (Hom): Maps between objects (e.g., src and tgt maps).
3. Attribute Types (AttrType): Data types used for attributes.
4. Attributes (Attr): Maps from objects to attribute types (e.g., a weight attribute on an edge).

Workflow Example

To create a weighted graph, you first define a schema using the @present macro, then define an acset type, and finally instantiate the acset with data.

using GATlab, Catlab.CategoricalAlgebra

# 1. Define the schema
@present SchWeightedGraph(FreeSchema) begin
  V::Ob
  E::Ob
  src::Hom(E,V)
  tgt::Hom(E,V)
  T::AttrType
  weight::Attr(E,T)
end

# 2. Define the acset type (using index to store backwards maps)
@acset_type WeightedGraph(SchWeightedGraph, index=[:src,:tgt])

# 3. Construct the acset with data
g = @acset WeightedGraph{Float64} begin
  V = 4
  E = 5
  src = [1,1,1,2,3]
  tgt = [2,3,4,4,4]
  weight = [7.2, 9.3, 9.4, 0.1, 42.0]
end