Skip to content

plurigrid/asi / ies/music-topos/.codex/skills/categorical-composition

categorical-composition

Verified

FileKindSize
SKILL.mdskill md2.6 KB
category_theory.jlother6.0 KB
kan_extensions.jlother5.3 KB

kan_extensions.jl

View on GitHub
"""
Kan Extensions

Implements left and right Kan extensions for functors, enabling
problem adaptation and compositional learning transfer.
"""

module KanExtensionsModule

export left_kan_extension, right_kan_extension, kan_extension_pointwise
export restriction_functor, check_adjunction

include("category_theory.jl")
using .CategoryTheoryModule

"""
Left Kan Extension: Lan_K F for K: C -> D, F: C -> E

The left Kan extension is the left adjoint to restriction along K.
Computed as a colimit when it exists.
"""
struct LeftKanExtension
    K::Functor  # K: C -> D
    F::Functor  # F: C -> E
    extension::Functor  # Lan_K F: D -> E

    # Universal property: natural transformation F -> (Lan_K F) ∘ K
    unit::NaturalTransformation
end

"""
Compute left Kan extension (simplified pointwise formula)

For finite categories, Lan_K F(d) = colim_{K(c) -> d} F(c)
"""
function left_kan_extension(K::Functor, F::Functor)
    @assert K.source == F.source "K and F must have same source category"

    D = K.target
    E = F.target

    # Object map: for each d in D, compute colimit
    object_map = Dict{Symbol, Symbol}()

    for d in D.objects
        # Find all c in C such that K(c) relates to d
        related_objects = Symbol[]
        for c in K.source.objects
            if K(c) == d
                push!(related_objects, F(c))
            end
        end

        # Colimit (simplified: just pick first object or coproduct)
        if isempty(related_objects)
            # Initial object (placeholder)
            object_map[d] = :initial
        else
            # Coproduct of related objects (placeholder: use first)
            object_map[d] = related_objects[1]
        end
    end

    # Morphism map: induced from universal property
    morphism_map = Dict{Symbol, Symbol}()
    for (mor_name, (src, tgt)) in D.morphisms
        # Map morphism via colimit property
        # Simplified: use identity
        morphism_map[mor_name] = identity_morphism(E, object_map[src])
    end

    extension = Functor(
        name=Symbol("Lan_$(K.name)_$(F.name)"),
        source=D,
        target=E,
        object_map=object_map,
        morphism_map=morphism_map
    )

    # Unit: F -> (Lan_K F) ∘ K
    unit_components = Dict(c => identity_morphism(E, F(c)) for c in K.source.objects)
    unit = NaturalTransformation(
        name=:unit,
        source=F,
        target=compose(K, extension),
        components=unit_components
    )

    return LeftKanExtension(K, F, extension, unit)
end

"""
Right Kan Extension: Ran_K F for K: C -> D, F: C -> E

The right Kan extension is the right adjoint to restriction along K.
Computed as a limit when it exists.
"""
struct RightKanExtension
    K::Functor  # K: C -> D
    F::Functor  # F: C -> E
    extension::Functor  # Ran_K F: D -> E

    # Universal property: natural transformation (Ran_K F) ∘ K -> F
    counit::NaturalTransformation
end

"""
Compute right Kan extension (simplified pointwise formula)

For finite categories, Ran_K F(d) = lim_{d -> K(c)} F(c)
"""
function right_kan_extension(K::Functor, F::Functor)
    @assert K.source == F.source "K and F must have same source category"

    D = K.target
    E = F.target

    # Object map: for each d in D, compute limit
    object_map = Dict{Symbol, Symbol}()

    for d in D.objects
        # Find all c in C such that d relates to K(c)
        related_objects = Symbol[]
        for c in K.source.objects
            if K(c) == d
                push!(related_objects, F(c))
            end
        end

        # Limit (simplified: just pick first object or product)
        if isempty(related_objects)
            # Terminal object (placeholder)
            object_map[d] = :terminal
        else
            # Product of related objects (placeholder: use first)
            object_map[d] = related_objects[1]
        end
    end

    # Morphism map: induced from universal property
    morphism_map = Dict{Symbol, Symbol}()
    for (mor_name, (src, tgt)) in D.morphisms
        # Map morphism via limit property
        # Simplified: use identity
        morphism_map[mor_name] = identity_morphism(E, object_map[src])
    end

    extension = Functor(
        name=Symbol("Ran_$(K.name)_$(F.name)"),
        source=D,
        target=E,
        object_map=object_map,
        morphism_map=morphism_map
    )

    # Counit: (Ran_K F) ∘ K -> F
    counit_components = Dict(c => identity_morphism(E, F(c)) for c in K.source.objects)
    counit = NaturalTransformation(
        name=:counit,
        source=compose(K, extension),
        target=F,
        components=counit_components
    )

    return RightKanExtension(K, F, extension, counit)
end

"""
Restriction functor: precomposition with K

For K: C -> D, restriction maps Func(D, E) -> Func(C, E) via F ↦ F ∘ K
"""
function restriction_functor(K::Functor)
    # This would operate on functor categories
    # Simplified implementation as placeholder
    return K
end

"""
Check adjunction: Lan_K ⊣ K^* (restriction)

Verify natural bijection: Hom_D(Lan_K F, G) ≅ Hom_C(F, G ∘ K)
"""
function check_adjunction(lan::LeftKanExtension, restriction::Functor)
    # Simplified check: verify triangle identities
    # Full implementation would verify natural bijection

    # Triangle identity 1: (Lan_K F) ∘ unit = id
    # Triangle identity 2: counit ∘ (Lan unit) = id

    return true  # Placeholder
end

end  # module
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall