From asi
Quotients redundant skill paths via coequalizers and bisimulation for behavioral equivalence checking, skill overlap detection, and GF(3) conservation in compositions.
npx claudepluginhub plurigrid/asi --plugin asiThis skill uses the workspace's default tool permissions.
> **Quotient redundant skill paths via categorical coequalizers**
EXECUTION_RESULTS.mdEXECUTION_SUMMARY.mdFINAL_SYNTHESIS.mdINTEGRATION_COMPLETE.mdMCP_WORLDS.mdMISSING_DIMENSIONS.mdPUSH_PULL_MEASUREMENT.mdSkillCoequalizers.jlSkillCoequalizers.orgVISUALIZATION.mdWHEN_NAME_HASHING.mdWORLDS.mdWORLD_CYCLE_DIAGRAM.mdWORLD_CYCLE_RESULTS.mdWorldHopping.jlWorldHopping.orgall_skill_trits.csvanalyze_meta_bundles.jlanalyze_meta_bundles.organalyze_pairs_and_triplets.jlOrchestrates skills for Artificial Superintelligence using ACSet schemas, Gay-MCP coloring, bisimulation games, world-hopping navigation, glass-bead synthesis, and triad interleaving.
Guides Next.js Cache Components and Partial Prerendering (PPR): 'use cache' directives, cacheLife(), cacheTag(), revalidateTag() for caching, invalidation, static/dynamic optimization. Auto-activates on cacheComponents: true.
Guides building MCP servers enabling LLMs to interact with external services via tools. Covers best practices, TypeScript/Node (MCP SDK), Python (FastMCP).
Share bugs, ideas, or general feedback.
Quotient redundant skill paths via categorical coequalizers
Version: 1.0.0
Trit: 0 (ERGODIC - coordinates equivalences)
Domain: category-theory, skill-composition, colimits, behavioral-equivalence
The coequalizers skill provides:
A coequalizer is the colimit of two parallel morphisms:
X ──f──→ Y
│ g │
└────────→ q
↓
Q (coequalizer)
Universal property: q ∘ f = q ∘ g
In Sets: Q = Y / ~ where ~ is the smallest equivalence relation such that f(x) ~ g(x) for all x ∈ X.
For skills: If two skill paths produce behaviorally equivalent outputs, the coequalizer gives the canonical quotient.
From /skills/oapply-colimit/SKILL.md:
function oapply(d::UndirectedWiringDiagram, xs::Vector{ResourceSharer})
# Step 1: Coproduct of state spaces
S = coproduct((FinSet ∘ nstates).(xs))
# Step 2: Pushout identifies shared variables via COEQUALIZER
S′ = pushout(portmap, junctions) # ← Uses coequalizer internally
# Step 3: Induced dynamics sum at junctions
return ResourceSharer(induced_interface, induced_dynamics)
end
Key insight: Pushouts decompose as coproduct + coequalizer. This is how skills with shared interfaces are glued together.
From /skills/bisimulation-game/SKILL.md:
def bisimilar(skill₁, skill₂, input, depth=10):
"""
Recursively check if skills produce same observations.
Two skills are bisimilar if:
- They produce same immediate output
- Their continuations are pairwise bisimilar
"""
obs₁ = observe(skill₁, input)
obs₂ = observe(skill₂, input)
if obs₁ != obs₂:
return False
# Recursive check on continuations
if depth > 0:
for (next₁, inp₁), (next₂, inp₂) in zip(
skill₁.continuations(input),
skill₂.continuations(input)
):
if not bisimilar(next₁, next₂, inp₁, depth-1):
return False
return True
Application: Use bisimulation to establish equivalence relation ~ before applying coequalizer.
From /skills/topos-adhesive-rewriting/SKILL.md:
# Decomposition: Q ≅ Q_G +_{Q_L} Q_R
# This IS a coequalizer construction!
function quotient_system(system::SkillSystem, equivalences)
# Build parallel morphisms from equivalence pairs
equiv_indices = parts(system, :Equivalence)
# Compute coequalizer (built into Catlab)
quotient = coequalizer(system, equiv_indices)
# Verify GF(3) conservation
@assert verify_gf3_conservation(quotient)
return quotient
end
Key: Adhesive categories (like C-Sets) have well-behaved coequalizers for incremental updates.
From /skills/browser-history-acset/path_equivalence_test.jl:
# Path composition via subpart chains
@assert subpart(acs, subpart(acs, 1, :url_of), :domain_of) == 1
# Multiple visit paths may lead to same outcome
# Coequalizer identifies equivalent paths
Application: Navigation paths through skill graphs that produce same results should be identified.
From /skills/ordered-locale/sheaves.py:
def gluing(cover: List[FrozenSet], family: Dict[FrozenSet, T]) -> Optional[T]:
"""
Glue a compatible family over a cover.
This is the sheaf condition - dual to coequalizer.
"""
# Check compatibility on overlaps
for U_i, U_j in pairs(cover):
overlap = U_i & U_j
if overlap:
res_i = restrict(U_i, overlap, family[U_i])
res_j = restrict(U_j, overlap, family[U_j])
if res_i != res_j:
return None # Incompatible family
# Glue: coequalizer of restrictions
return reduce(lambda a, b: a | b, family.values(), frozenset())
Key: Sheaf gluing IS the dual of coequalizer. Overlapping skill contexts must agree.
From /skills/compositional-acset-comparison/IrreversibleMorphisms.jl:
# Irreversible morphisms: information loss
const MORPHISM_CLASSIFICATION = Dict(
:parent_manifest => :irreversible, # Append-only chain
:source_column => :irreversible, # Lossy embedding
# ...
)
# Coequalizers preserve irreversibility classification
# If f, g both irreversible, coeq(f,g) is irreversible
Application: Track information loss through quotients. GF(3) trit sum must be preserved.
using Catlab.CategoricalAlgebra
using AlgebraicRewriting
@present SchSkillCoequalizer(FreeSchema) begin
Skill::Ob
Application::Ob
Equivalence::Ob
app_src::Hom(Application, Skill)
app_tgt::Hom(Application, Skill)
equiv_app1::Hom(Equivalence, Application)
equiv_app2::Hom(Equivalence, Application)
Trit::AttrType
Behavior::AttrType
skill_trit::Attr(Skill, Trit)
app_behavior::Attr(Application, Behavior)
end
@acset_type SkillSystem(SchSkillCoequalizer,
index=[:app_src, :app_tgt, :equiv_app1, :equiv_app2])
bisimulation-game (-1) ⊗ coequalizers (0) ⊗ oapply-colimit (+1) = 0 ✓
temporal-coalgebra (-1) ⊗ coequalizers (0) ⊗ topos-adhesive (+1) = 0 ✓
browser-history-acset (-1) ⊗ coequalizers (0) ⊗ ordered-locale (sheaves) (+1) = 0 ✓
just coequalizer-find SKILLS... # Find equivalences among skills
just coequalizer-quotient SYSTEM # Compute quotient
just coequalizer-verify GF3 # Verify GF(3) conservation
just coequalizer-disperse AGENTS... # Sync across agents
just coequalizer-pushout SKILL1 SKILL2 # Compose with overlap
oapply-colimit - Pushout = coproduct + coequalizerbisimulation-game - Behavioral equivalence testingtopos-adhesive-rewriting - Incremental query updating via coequalizersbrowser-history-acset - Path equivalence in ACSetsordered-locale (sheaves.py) - Gluing as dual of coequalizercompositional-acset-comparison (IrreversibleMorphisms.jl) - Lossy morphismsbisimulation-game (-1) - Behavioral equivalenceoapply-colimit (+1) - Pushout compositiontopos-adhesive-rewriting (+1) - Incremental updatestemporal-coalgebra (-1) - Coalgebraic bisimulationordered-locale (0) - Sheaf gluingSkill Name: coequalizers
Type: Category-Theoretic Skill Composition
Trit: 0 (ERGODIC - coordinates equivalences)
GF(3): Conserved via triadic composition