Skip to content
gay-fokker-planck-staging logo

Gay Fokker-Planck Staging

gay-fokker-planck-staging

Two Fokker-Plancks per staging gate, conditioned on (rama OR goblins)

plurigrid/asi0installs67starsOther

SKILL.md

Full skill instructions

Gay Fokker-Planck Staging

"Each staging gate requires two independent convergence checks"

Trit: 0 (ERGODIC - coordinator) Color: #26D826 (Green) Condition: (rama OR goblins) - distributed capability requirement


Overview

Every skill activation MUST:

  1. Pass through two Fokker-Planck equilibrium checks
  2. Provide accessible counterfactual worlds (rama-path, goblins-path, both-path)
  3. Satisfy triangle inequality for world accessibility
  4. Conserve GF(3) across staging gates

Staging Gate Protocol

(defn staging-gate [skill seed]
  (let [;; Two independent Fokker-Planck checks
        fp1 (fokker-planck-check skill :temperature 0.01)
        fp2 (fokker-planck-check skill :temperature 0.001)

        ;; Condition: rama OR goblins available
        rama-accessible? (check-capability :rama)
        goblins-accessible? (check-capability :goblins)
        condition-met? (or rama-accessible? goblins-accessible?)]

    {:skill skill
     :fp1-converged (:converged fp1)
     :fp2-converged (:converged fp2)
     :staging-pass (and (:converged fp1)
                        (:converged fp2)
                        condition-met?)
     :condition {:rama rama-accessible?
                 :goblins goblins-accessible?}}))

Counterfactual Worlds (Mandatory)

Each skill MUST declare accessible counterfactual worlds:

class SkillWithWorlds
  attr_reader :actual_world, :counterfactuals

  def initialize(skill_name, seed)
    @actual_world = PossibleWorld.new(seed: seed, skill: skill_name)

    # MANDATORY: Three counterfactual paths
    @counterfactuals = [
      rama_world(seed),      # W₁: rama-only execution
      goblins_world(seed),   # W₂: goblins-only execution
      both_world(seed)       # W₃: rama + goblins
    ]
  end

  def rama_world(seed)
    PossibleWorld.new(
      seed: derive(seed, :rama),
      variant: :rama,
      accessible: true,
      distance_from_actual: 1.0
    )
  end

  def goblins_world(seed)
    PossibleWorld.new(
      seed: derive(seed, :goblins),
      variant: :goblins,
      accessible: true,
      distance_from_actual: 1.0
    )
  end

  def both_world(seed)
    PossibleWorld.new(
      seed: derive(derive(seed, :rama), :goblins),
      variant: :both,
      accessible: true,
      distance_from_actual: 1.414  # √2, composed path
    )
  end
end

Triangle Inequality Verification

        actual
         /\
    1.0 /  \ 1.0
       /    \
   rama ---- goblins
        1.0

Triangle: d(actual, goblins) ≤ d(actual, rama) + d(rama, goblins)
          1.0 ≤ 1.0 + 1.0 = 2.0 ✓

Two Fokker-Plancks Per Staging

Why Two?

  1. Temperature sensitivity: Different T reveals different equilibria
  2. Mixing time validation: Second check confirms first wasn't premature
  3. Gibbs distribution verification: Two independent samples

Implementation

def dual_fokker_planck_gate(skill_trajectory):
    # FP1: Higher temperature (exploration)
    fp1 = fokker_planck_check(
        trajectory=skill_trajectory,
        temperature=0.01,
        mixing_threshold=100
    )

    # FP2: Lower temperature (exploitation)
    fp2 = fokker_planck_check(
        trajectory=skill_trajectory,
        temperature=0.001,
        mixing_threshold=500
    )

    # Both must converge
    return fp1.converged and fp2.converged

Random Walk Agent Protocol

Three agents walk skills, each with counterfactual worlds:

(def agent-seeds [0xDEAD01 0xBEEF02 0xCAFE03])

(defn agent-walk [seed]
  {:agent-trit (- (mod seed 3) 1)
   :skills (for [step (range 3)]
             (let [skill (walk-step seed step)
                   worlds (counterfactual-worlds skill seed)]
               {:skill skill
                :trit (- (mod step 3) 1)
                :worlds worlds
                :staging (dual-fokker-planck-gate skill)}))})

GF(3) Conservation

Each staging gate maintains:

Σ(skill trits) ≡ 0 (mod 3)

Agent 1: covariant-modification(-1) + cybernetic-immune(0) + X(+1) = 0 ✓
Agent 2: mdm-cobordism(-1) + tailscale-file-transfer(0) + Y(+1) = 0 ✓
Agent 3: discohy-streams(-1) + code-review(0) + Z(+1) = 0 ✓

Commands

# Run staging gate
just gay-staging skill_name

# Check dual Fokker-Planck
just fp-dual-check trajectory.json

# List counterfactual worlds
just worlds-list skill_name

# Verify triangle inequality
just triangle-check skill_name

PR Template

When committing to plurigrid/​asi:

## Summary
- Add gay-fokker-planck-staging skill
- Two FP equilibrium checks per staging gate
- Mandatory counterfactual worlds (rama/​goblins/​both)

## Test plan
- [ ] Dual Fokker-Planck convergence
- [ ] Counterfactual world accessibility
- [ ] Triangle inequality verification
- [ ] GF(3) conservation across agents

🤖 Generated with [Claude Code](https://claude.com/​claude-code)

Skill Name: gay-fokker-planck-staging Type: Staging Gate Coordinator Trit: 0 (ERGODIC) Condition: (rama OR goblins) FP Gates: 2 per staging Counterfactual Worlds: 3 per skill (rama, goblins, both)

More Other skills

Delegate independent tasks to specialized agents working concurrently with isolated context.

295.4K 206.3K
View

Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.

179.7K 100.1K
View

Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.

179.7K 89.5K
View

A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).

179.7K 76.1K
View

Fundamental design principles for writing maintainable, testable Python code.

40.2K 21.9K
View

Modern responsive layouts using container queries, fluid typography, CSS Grid, and mobile-first strategies.

40.2K 20K
View

Generate Playwright tests from scenarios using interactive browser exploration and validation.

39.7K 18.2K
View

Modern React state management with Redux Toolkit, Zustand, Jotai, and React Query for every state category.

40.2K 14.7K
View

GDPR-compliant data handling with consent management, data subject rights, and privacy controls.

40.2K 14.3K
View

Python error handling patterns including input validation, exception hierarchies, and partial failure handling. Use when implementing validation logic, designing exception strategies, handling batch processing failures, or building robust APIs.

40.2K 13.5K
View

Detailed multi-file refactor planning with safety checks and rollback guidance.

39.7K 13K
View