Epistemic Arbitrage

Epistemic Arbitrage: Propagator-Based Knowledge Synthesis

Epistemic arbitrage exploits knowledge differentials between domains. When concept A in domain X is well-understood, but its isomorphic counterpart A' in domain Y is mysterious, we can arbitrage by transferring understanding.

Core Architecture

Propagator Networks (Radul/Sussman)

A propagator network consists of:

┌─────────┐     ┌─────────────┐     ┌─────────┐
│  Cell A │────▶│ Propagator  │────▶│  Cell B │
│ (known) │     │  (transfer) │     │(derived)│
└─────────┘     └─────────────┘     └─────────┘

• Cells: Containers for partial information
• Propagators: Functions that combine/transform information
• Merging: Monotonic accumulation (information only increases)

SplitMixTernary RNG

For parallel propagation with determinism:

class SplitMixTernary
  GOLDEN = 0x9e3779b97f4a7c15  # Golden ratio constant
  
  def initialize(seed)
    @state = seed
  end
  
  def next_ternary
    # Advance state (SplitMix64)
    @state = (@state + GOLDEN) & 0xFFFFFFFFFFFFFFFF
    z = @state
    z = ((z ^ (z >> 30)) * 0xbf58476d1ce4e5b9) & 0xFFFFFFFFFFFFFFFF
    z = ((z ^ (z >> 27)) * 0x94d049bb133111eb) & 0xFFFFFFFFFFFFFFFF
    z = z ^ (z >> 31)
    
    # Map to ternary: -1, 0, +1
    (z % 3) - 1
  end
  
  def split(index)
    # Create independent child stream
    child_seed = @state ^ (index * GOLDEN)
    SplitMixTernary.new(child_seed)
  end
end

Arbitrage Patterns

Pattern 1: Domain Transfer

# Knowledge in domain A
cell_a = Cell.new(:music, :circle_of_fifths)
cell_a.add_info(:structure, :cyclic_group_12)
cell_a.add_info(:generator, :perfect_fifth)

# Unknown in domain B
cell_b = Cell.new(:number_theory, :modular_arithmetic)

# Propagator transfers structure
propagator = Propagator.new(:domain_transfer) do |source, target|
  if source.has?(:structure)
    target.merge(:structure, source.get(:structure))
    target.merge(:insight, "Z/12Z isomorphic to circle of fifths")
  end
end

propagator.connect(cell_a, cell_b)
propagator.fire!

Pattern 2: Dual Discovery

# Known: Fourier transform on functions
cell_time = Cell.new(:analysis, :time_domain)
cell_freq = Cell.new(:analysis, :frequency_domain)

# Propagator: Fourier duality
duality_propagator = Propagator.new(:fourier_duality) do |time, freq|
  time.each_property do |prop, val|
    dual_prop = fourier_dual(prop)  # convolution ↔ multiplication, etc.
    freq.merge(dual_prop, val)
  end
end

Pattern 3: Triangle Arbitrage

When three domains have pairwise connections, exploit the triangle:

# Three domains with partial knowledge
cell_math = Cell.new(:mathematics, :group_theory)
cell_music = Cell.new(:music, :harmony)
cell_physics = Cell.new(:physics, :symmetry)

# Pairwise propagators
math_music = Propagator.new(:pitch_class_groups)
music_physics = Propagator.new(:overtone_series)
physics_math = Propagator.new(:lie_groups)

# Triangle inequality enables arbitrage:
# d(math, physics) ≤ d(math, music) + d(music, physics)
# 
# If direct math→physics is hard, go via music!

Local Scoped Propagators

Scoping for Parallelism

Each propagator runs in a local scope with:

class ScopedPropagator
  def initialize(name, rng_seed, &block)
    @name = name
    @rng = SplitMixTernary.new(rng_seed)
    @block = block
    @local_cells = {}
  end
  
  def fork(n)
    # Create n parallel scopes with independent RNG streams
    n.times.map do |i|
      child_rng = @rng.split(i)
      ScopedPropagator.new("#{@name}/#{i}", child_rng.state, &@block)
    end
  end
  
  def run(inputs)
    # Execute in isolated scope
    @local_cells = inputs.dup
    @block.call(self, @local_cells)
    @local_cells
  end
end

Parallel Arbitrage Network

# Master network
network = ArbitrageNetwork.new(seed: 1069)

# Add cells for each domain
network.add_cell(:category_theory, knowledge: 0.9)
network.add_cell(:music_theory, knowledge: 0.7)
network.add_cell(:physics, knowledge: 0.5)
network.add_cell(:philosophy, knowledge: 0.3)

# Add arbitrage propagators
network.add_propagator(:category_to_music, [:category_theory], [:music_theory])
network.add_propagator(:music_to_physics, [:music_theory], [:physics])
network.add_propagator(:physics_to_philosophy, [:physics], [:philosophy])

# Run in parallel (SPI-compliant)
results = network.run_parallel(n_workers: 4)

Integration with Music Topos

With World Broadcast

# Each mathematician is a knowledge source
broadcasters = WorldBroadcast::TripartiteSystem.new([:ramanujan, :grothendieck, :euler])

# Create cells from mathematician expertise
cells = broadcasters.agents.map do |agent|
  Cell.new(agent.profile[:domain], 
           knowledge: agent.history.size,
           operations: agent.profile[:operations])
end

# Arbitrage between mathematicians
network = ArbitrageNetwork.from_cells(cells)
network.add_all_pairwise_propagators
network.run!

With Synadia

# Publish arbitrage opportunities
network.on_arbitrage do |source, target, gain|
  SynadiaBroadcast.publish("arbitrage.opportunity", {
    from: source.domain,
    to: target.domain,
    knowledge_gain: gain
  })
end

# Subscribe to external knowledge
SynadiaBroadcast.subscribe("knowledge.*") do |msg|
  domain = msg.subject.split('.').last.to_sym
  network.cells[domain].merge(:external, msg.data)
end

With Glass Bead Game

# Arbitrage opportunities become game moves
network.on_arbitrage do |source, target, gain|
  if gain > threshold
    move = GlassBeadGame::Connect.new(
      from: Bead.new(source.domain, source.best_concept),
      to: Bead.new(target.domain, target.mystery),
      via: :epistemic_transfer,
      value: gain
    )
    game.propose_move(move)
  end
end

Guarantees

1. SPI Compliance: Parallel execution ≡ sequential (bitwise identical)
2. Determinism: Same seed → same arbitrage discoveries
3. Monotonicity: Knowledge only increases (no forgetting)
4. Locality: Propagators only access explicitly connected cells
5. Triangle Inequality: d(A,C) ≤ d(A,B) + d(B,C) for all knowledge transfers

Commands

just arbitrage               # Run arbitrage network
just arbitrage-domains a b   # Arbitrage between specific domains
just propagator-network      # Visualize propagator network
just knowledge-flow          # Show knowledge flow diagram

Scientific Skill Interleaving

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

Graph Theory

• networkx [○] via bicomodule
  • Universal graph hub

Bibliography References

• general: 734 citations in bib.duckdb

SDF Interleaving

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

Primary Chapter: 10. Adventure Game Example

Concepts: autonomous agent, game, synthesis

GF(3) Balanced Triad

epistemic-arbitrage (+) + SDF.Ch10 (+) + [balancer] (+) = 0

Skill Trit: 1 (PLUS - generation)

Secondary Chapters

• Ch7: Propagators
• Ch3: Variations on an Arithmetic Theme
• Ch4: Pattern Matching
• Ch6: Layering

Connection Pattern

Adventure games synthesize techniques. This skill integrates multiple patterns.

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.