Sheaf Morphisms

Module for morphisms of cellular sheaf complexes.

A sheaf morphism F -> G consists of, for each vertex v, a linear map F(v) -> G(φ(v)) and, for each edge e, a linear map F(e) -> G(ψ(e)), subject to the naturality condition dG ∘ V = E ∘ dF where dF, dG are the coboundary maps of F and G respectively.

This module provides two representations:

• SheafMorphism — a structured specification: per-stalk matrices together with index maps that say which stalk of the target each source stalk maps into. This is the natural form when building morphisms by hand.

• ComplexMorphism — the matrix representation: a pair (V, E) of block matrices V : C⁰(F) → C⁰(G) and E : C¹(F) → C¹(G). This is the form needed for linear-algebraic operations.

The functor ComplexMorphism(F, G, spec::SheafMorphism) assembles the block matrices from the structured spec.

ComplexMorphism

A morphism of cochain complexes C*(F) -> C*(G) represented as a pair of matrices:

• V :: AbstractMatrix — the degree-0 component C⁰(F) → C⁰(G).
• E :: AbstractMatrix — the degree-1 component C¹(F) → C¹(G).

The naturality condition is E * dF == dG * V where dF, dG are the coboundary maps. Use is_morphism to check this numerically.

ComplexMorphism(F, G, Vmap, Emap, Vmaps, Emaps)

Assemble a ComplexMorphism F -> G from explicit index maps and per-stalk matrices.

Arguments

• F, G : source and target AbstractNetworkSheaf.
• Vmap :: AbstractVector{<:Integer} — vertex index map (length = nv(F)).
• Emap :: AbstractVector{<:Integer} — edge index map (length = ne(F)).
• Vmaps :: AbstractVector — per-source-vertex matrices.
• Emaps :: AbstractVector — per-source-edge matrices.

Returns a ComplexMorphism(V, E) where V and E are BlockArrays with the block partitions induced by the stalk dimensions of F and G.

ComplexMorphism(F, G, spec::SheafMorphism)

Convert a SheafMorphism spec into a ComplexMorphism.

This is the functor from the category of structured sheaf-morphism specifications to the category of cochain-complex morphisms on the same objects.

SheafMorphism

A structured specification of a cellular-sheaf morphism F -> G.

Fields

• Vmap :: Vector{Int} — Vmap[i] = j means the i-th vertex stalk of F maps into the j-th vertex stalk of G.
• Emap :: Vector{Int} — Emap[k] = ℓ means the k-th edge stalk of F maps into the ℓ-th edge stalk of G.
• Vmaps :: Vector — one matrix per source vertex stalk; the matrix at index i has size (dim G_vertex[Vmap[i]], dim F_vertex[i]).
• Emaps :: Vector — one matrix per source edge stalk; the matrix at index k has size (dim G_edge[Emap[k]], dim F_edge[k]).

Use ComplexMorphism(F, G, spec) to convert to block-matrix form.

compose(f::ComplexMorphism, g::ComplexMorphism) -> ComplexMorphism

Compose two compatible ComplexMorphisms f : C*(F) -> C*(G) and g : C*(G) -> C*(H) by matrix multiplication.

compose(f::SheafMorphism, g::SheafMorphism) -> SheafMorphism

Compose two compatible SheafMorphisms f : F -> G and g : G -> H to produce g ∘ f : F -> H.

id(::Type{ComplexMorphism}, X) -> ComplexMorphism

Return the identity ComplexMorphism on sheaf X.

V is the identity matrix on C⁰(X) (total vertex-stalk dimension) and E is the identity matrix on C¹(X) (total edge-stalk dimension).

id(::Type{SheafMorphism}, X) -> SheafMorphism

Return the identity SheafMorphism on sheaf X.

Each vertex stalk maps to itself via Vmap[i] = i with a square identity matrix, and likewise for every edge stalk.

is_morphism(cm, F, G; tol=1e-8) -> Bool

Convenience overload: computes coboundary_map(F) and coboundary_map(G) and delegates to the matrix form.

is_morphism(cm::ComplexMorphism, dF, dG; tol=1e-8) -> Bool

Return true if the naturality square E * dF ≈ dG * V holds within tol.

make_sheaf_morphism_spec(Vmap, Emap, Vmaps, Emaps) -> SheafMorphism

Convenience constructor: normalises argument types and returns a SheafMorphism.