npx claudepluginhub plurigrid/asi --plugin asiThis skill uses the workspace's default tool permissions.
**Status**: ✅ Production Ready
Verifies multiple effect interpretations through propagator networks using temporal coalgebra bisimulation and common fixpoint solutions. For constraint propagation and effect coordination in Clojure systems.
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.
Status: ✅ Production Ready Trit: -1 (MINUS - validator/observer) Color: #2626D8 (Blue) Principle: Observe behaviors → Verify equivalence Frame: Final coalgebra with stream coalgebra traces
Temporal Coalgebra is the dual of algebra: where algebra constructs, coalgebra observes. Implements:
Correct by construction: Two systems are equivalent iff they are bisimilar (observationally indistinguishable).
Coalgebra: (X, γ: X → F(X)) # State → Observable structure
Final: νF = lim F^n(1) # Greatest fixpoint
Bisimulation R ⊆ X × Y:
(x, y) ∈ R ⟹ F(R)(γ_X(x), γ_Y(y))
For derivation observation:
# Observe derivation stream
observe(derivation) = { head: current_step, tail: rest_of_derivation }
# Two derivations are equivalent iff:
bisimilar?(d1, d2) == (observe(d1).head == observe(d2).head &&
bisimilar?(observe(d1).tail, observe(d2).tail))
Transform derivations into observations:
functor = TemporalCoalgebra::ObservationFunctor.new(
source: :derivation_chain,
target: :observation_stream
)
observation = functor.apply(derivation)
observation.head # => current observable state
observation.tail # => remaining stream (lazy)
observation.finite? # => false (potentially infinite)
Construct the final coalgebra for type F:
final = TemporalCoalgebra::FinalCoalgebra.new(
functor: stream_functor,
approximation_depth: 100
)
final.carrier # => νF (greatest fixpoint)
final.universal?(coal) # => check if coal maps uniquely
final.unfold(seed) # => generate infinite structure
Verify behavioral equivalence:
checker = TemporalCoalgebra::BisimulationChecker.new
checker.add_system(:system_a, coalgebra_a)
checker.add_system(:system_b, coalgebra_b)
result = checker.check_bisimilar!
result[:bisimilar] # => true/false
result[:distinguishing_trace] # => if false, witness
result[:depth_checked] # => how deep we verified
Work with infinite streams:
stream = TemporalCoalgebra::StreamCoalgebra.new(seed: 0x42D)
stream.head # => first element
stream.tail # => rest of stream
stream.take(10) # => first 10 elements
stream.drop(5).head # => 6th element
stream.map { |x| x * 2 } # => transformed stream
stream.zip(other_stream) # => paired stream
Integration with three-match for game verification:
game = TemporalCoalgebra::ThreeMatchBisimulation.new(
attacker: player_a,
defender: player_b,
three_match_gadget: gadget
)
game.play_round!
game.defender_wins? # => strategies are bisimilar
game.attacker_wins? # => found distinguishing move
game.gf3_conserved? # => trit sum = 0
# Observe derivation chain
just coalgebra-observe
# Check bisimulation
just coalgebra-bisim system_a system_b
# Generate stream from seed
just coalgebra-stream 0x42D 20
# Verify game equivalence
just coalgebra-game
require 'temporal_coalgebra'
# Create observation system
obs = TemporalCoalgebra::Observer.new(
trit: -1,
functor: :stream
)
# Observe derivation
stream = obs.observe(derivation_chain)
# Check equivalence
bisim = obs.bisimilar?(stream_a, stream_b)
# Integrate with three-match
game_result = obs.verify_game(three_match_gadget)
Forms valid triads with ERGODIC (0) and PLUS (+1) skills:
temporal-coalgebra (-1) ⊗ coequalizers (0) ⊗ topos-adhesive-rewriting (+1) = 0 ✓
temporal-coalgebra (-1) ⊗ unworld (0) ⊗ gay-mcp (+1) = 0 ✓
temporal-coalgebra (-1) ⊗ glass-bead-game (0) ⊗ cider-clojure (+1) = 0 ✓
temporal-coalgebra (-1) ⊗ acsets (0) ⊗ rubato-composer (+1) = 0 ✓
coequalizers (0) - Uses coalgebraic bisimulation to establish behavioral equivalence before quotientingbisimulation-game (-1) - Game-theoretic bisimulation testingtopos-adhesive-rewriting (+1) - Rewriting preserves observational equivalenceCoalgebra for F: (X, γ: X → F(X))
- X is carrier (state space)
- γ is structure map (observation)
- F is endofunctor (observation type)
F(X) = A × X (head × tail)
νF ≅ A^ω (infinite sequences)
R is bisimulation ⟺
∀(x,y) ∈ R: (γ_X(x), γ_Y(y)) ∈ F(R)
Behavioral equivalence: x ∼ y ⟺ ∃R bisimulation. (x,y) ∈ R
To prove P(ν F), show:
P is F-consistent: P(x) ⟹ P(tail(x))
P(seed) holds
─── Temporal Coalgebra Observation ───
Source: Derivation chain (length ∞)
Functor: Stream (head × tail)
Observation:
head: { seed: 0x42D, color: #2626D8, trit: -1 }
tail: <lazy stream>
Bisimulation Check:
System A: derivation_chain_1
System B: derivation_chain_2
Depth 0: heads match ✓
Depth 1: tails match ✓
Depth 2: tails match ✓
...
Depth 100: tails match ✓
Result: BISIMILAR (observationally equivalent)
GF(3) Trit: -1 (MINUS/Observer)
─── Three-Match Integration ───
Game: Attacker vs Defender
Rounds: 12
Winner: Defender (strategies bisimilar)
GF(3) conserved: true
Skill Name: temporal-coalgebra Type: Observation / Bisimulation Verification Trit: -1 (MINUS) Color: #2626D8 (Blue) GF(3): Forms valid triads with ERGODIC + PLUS skills Dual: Algebra (construction) ↔ Coalgebra (observation)
This skill connects to the K-Dense-AI/claude-scientific-skills ecosystem:
linear-algebra: 112 citations in bib.duckdbThis skill maps to Cat# = Comod(P) as a bicomodule in the equipment structure:
Trit: -1 (MINUS)
Home: Span
Poly Op: ×
Kan Role: Adj
Color: #FF6B6B
The skill participates in triads satisfying:
(-1) + (0) + (+1) ≡ 0 (mod 3)
This ensures compositional coherence in the Cat# equipment structure.