home / skills / plurigrid / asi / rg-flow-acset

rg-flow-acset skill

/skills/rg-flow-acset

This skill analyzes RG Flow ACSet semantics to reveal fixed points, hierarchies, and universal behavior in XY model topological defects.

npx playbooks add skill plurigrid/asi --skill rg-flow-acset

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.8 KB
---
name: rg-flow-acset
description: RG Flow ACSet Skill
version: 1.0.0
---

# RG Flow ACSet Skill

Renormalization Group flow with ACSet categorical semantics, XY model topological defects, and Powers PCT hierarchical control.

## Seed
```
741086072858456200
```

## Triadic Palette (Powers PCT Cascade)
| Color | Hue | Hex | Role |
|-------|-----|-----|------|
| Cyan | 172° | `#23C8B3` | Ordered phase |
| Purple | 292° | `#AA22BE` | Critical/BKT |
| Gold | 52° | `#E0CE51` | Converged fixed point |

## ACSet Schema: RGFlow

```julia
@present SchRGFlow(FreeSchema) begin
  # Objects
  Trace::Ob
  EquivalenceClass::Ob
  RGStep::Ob
  FixedPoint::Ob
  
  # Morphisms
  condenses_to::Hom(Trace, EquivalenceClass)
  transforms_via::Hom(EquivalenceClass, RGStep)
  flows_to::Hom(RGStep, FixedPoint)
  
  # Attributes
  tau::Attr(RGStep, Float64)
  net_charge::Attr(RGStep, Int)
  hue::Attr(EquivalenceClass, Float64)
end

# Predicates (as computed attributes)
NetChargeZero(step) = net_charge(step) == 0
Ordered(step) = tau(step) < 0.893  # Below BKT
Converged(step) = abs(tau(step) - 0.5) < 0.01
```

## XY Model Configuration (τ=0.5)
```
Phase: Ordered (below BKT critical τ_c ≈ 0.893)
Defects: 2 vortex/antivortex pairs
Net topological charge: 0 (conserved)
Phenomenal bisect: τ* ≈ 0.5 (converged)
```

## Hierarchical Control (Powers PCT)

```
Level 5 (Program): "triadic" goal
    ↓ sets reference for
Level 4 (Transition): hue velocities [172°, 292°, 52°]
    ↓ sets reference for
Level 3 (Configuration): complementary angles
    ↓ sets reference for
Level 2 (Sensation): target hues
    ↓ sets reference for
Level 1 (Intensity): lightness 0.55
```

## RG Flow Semantics

The morphism chain `Trace → EquivalenceClass → RGStep → FixedPoint` implements:

1. **condenses_to**: Traces coarse-grain to equivalence classes (irrelevant operators drop)
2. **transforms_via**: Equivalence classes evolve under RG transformation
3. **flows_to**: RG steps converge to fixed points (universality)

## GF(3) Conservation

Triadic colors sum to 0 (mod 3):
- `#23C8B3` → trit 0 (identity)
- `#AA22BE` → trit +1 (creation)
- `#E0CE51` → trit -1 (annihilation)

Net charge: 0 + 1 + (-1) = 0 ✓

## Usage

```julia
using ACSets

@acset_type RGFlowACSet(SchRGFlow)

# Create instance at BKT transition
rg = @acset RGFlowACSet begin
  Trace = 4
  EquivalenceClass = 2
  RGStep = 1
  FixedPoint = 1
  condenses_to = [1, 1, 2, 2]
  transforms_via = [1, 1]
  flows_to = [1]
  tau = [0.5]
  net_charge = [0]
  hue = [172.0, 292.0]
end
```

## Related Skills
- `xy-model`: XY spin dynamics and BKT transition
- `phenomenal-bisect`: Temperature search for critical τ*
- `hierarchical-control`: Powers PCT cascade
- `gay-mcp`: Deterministic color generation



## Scientific Skill Interleaving

This skill connects to the K-Dense-AI/claude-scientific-skills ecosystem:

### Annotated Data
- **anndata** [○] via bicomodule
  - Hub for annotated matrices

### Bibliography References

- `dynamical-systems`: 41 citations in bib.duckdb



## SDF Interleaving

This skill connects to **Software Design for Flexibility** (Hanson & Sussman, 2021):

### Primary Chapter: 9. Generic Procedures

**Concepts**: dispatch, multimethod, predicate dispatch, generic

### GF(3) Balanced Triad

```
rg-flow-acset (○) + SDF.Ch9 (○) + [balancer] (○) = 0
```

**Skill Trit**: 0 (ERGODIC - coordination)


### Connection Pattern

Generic procedures dispatch on predicates. This skill selects implementations dynamically.
## Cat# Integration

This skill maps to **Cat# = Comod(P)** as a bicomodule in the equipment structure:

```
Trit: 0 (ERGODIC)
Home: Prof
Poly Op: ⊗
Kan Role: Adj
Color: #26D826
```

### GF(3) Naturality

The skill participates in triads satisfying:
```
(-1) + (0) + (+1) ≡ 0 (mod 3)
```

This ensures compositional coherence in the Cat# equipment structure.

Overview

This skill models Renormalization Group (RG) flow using ACSet categorical semantics, connecting traces, equivalence classes, RG steps, and fixed points. It encodes XY model configurations, BKT transition behavior, and a Powers PCT hierarchical control cascade with triadic color semantics. The implementation emphasizes conserved GF(3) triads and predicate-driven dispatch for generic procedures.

How this skill works

The skill defines an ACSet schema (SchRGFlow) with objects Trace, EquivalenceClass, RGStep, and FixedPoint and morphisms condenses_to, transforms_via, and flows_to. RGStep attributes (tau, net_charge) and EquivalenceClass hue are used to compute predicates like Ordered, NetChargeZero, and Converged. Instances represent coarse-graining chains that evolve under RG transformations and converge to universality fixed points.

When to use it

  • Model coarse-graining and universality in XY-like systems near the BKT transition
  • Encode topological defect conservation and net charge checks in simulations
  • Prototype predicate-dispatched algorithms for RG analysis and control
  • Integrate hierarchical Powers PCT control signals into model parameterization
  • Demonstrate GF(3)-balanced triads for color semantics and conservation rules

Best practices

  • Keep RGStep tau and net_charge explicit to support predicate dispatch and filtering
  • Use EquivalenceClass hue to annotate phase semantics (ordered/critical/converged) rather than raw numeric labels
  • Represent traces and morphism arrays compactly to enable fast coarse-graining operations
  • Validate GF(3) color trits when composing triadic palettes to ensure conserved net charge
  • Leverage the hierarchical control levels to map program goals to sensory/intensity parameters

Example use cases

  • Instantiate an RG flow ACSet for τ=0.5 to show ordered-phase behavior and converged fixed point detection
  • Run predicate-driven selection to filter NetChargeZero RG steps for topological charge conservation checks
  • Compose hierarchical Powers PCT parameters to generate target hues and intensity for visualization of flow
  • Combine with anndata-like annotated matrices to attach observables to EquivalenceClass nodes
  • Use the schema to teach generic-dispatch patterns from Software Design for Flexibility chapter on multimethods

FAQ

How does GF(3) conservation relate to physical observables?

GF(3) maps triadic colors to trits representing creation/annihilation/identity; summing to zero enforces a conserved net topological charge constraint in examples like vortex/antivortex pairs.

What predicates are computed for RGStep?

Computed predicates include NetChargeZero (net_charge==0), Ordered (tau < 0.893, below BKT), and Converged (abs(tau-0.5)<0.01) to support dispatch and analysis.