TIDAR - Triadic Interleaving Dispatch with Agents for Reading/writing

Before any interaction happens at the right time, split → recurse → collapse

Trit: 0 (ERGODIC - Coordinator)
GF(3) Triad:

goblins (-1) ⊗ tidar (0) ⊗ agent-o-rama (+1) = 0 ✓

Core Principle

Every read/write operation spawns a triadic tree of sub-agents:

                    ROOT (0)
                   /   |   \
                -1     0    +1          ← depth 1 (3 agents)
               /|\    /|\   /|\
             -0+ -0+ -0+ -0+ ...        ← depth 2 (9 agents)
             /|\ /|\ /|\ /|\ ...
           -0+-0+-0+-0+-0+-0+...        ← depth 3 (27 leaves)

The Three Directions

-

0

+

Pre-Hook Protocol

Before Read

async def pre_read_hook(target, accessor):
    tree = DiscoHyTree(max_depth=3)
    
    # 27 agents probe in parallel
    for agent in tree.leaves():
        offset = sum(t.value for t in agent.path)
        agent.result = accessor(target, offset=offset)
    
    # Collapse via middle path
    return tree.collapse_to_middle()

Before Write

async def pre_write_hook(target, data, writer):
    tree = DiscoHyTree(max_depth=3)
    
    # 27 agents validate
    for agent in tree.leaves():
        if agent.trit == Trit.MINUS:
            agent.result = {"action": "reject"}
        elif agent.trit == Trit.PLUS:
            agent.result = {"action": "accept", "data": data}
        else:
            agent.result = {"action": "transform", "data": data}
    
    # Collapse: middle path decides
    decision = tree.collapse_to_middle()
    
    if decision.action in ["accept", "transform"]:
        return writer(target, data)

Collapse Algorithm

When max depth reached, collapse upward via middle path preference:

def collapse_node(agent):
    if agent.is_leaf:
        return agent.result
    
    child_results = {c.trit: collapse_node(c) for c in agent.children}
    
    # Prefer middle path
    if child_results.get(Trit.MIDDLE) is not None:
        return child_results[Trit.MIDDLE]
    
    # Otherwise: PLUS - MINUS (GF(3) balance)
    return child_results[Trit.PLUS] - child_results[Trit.MINUS]

DiscoHy Integration

TIDAR uses Hy (Hylang) for homoiconic sub-agent definitions:

#!/usr/bin/env hy
(import tidar [Trit SubAgent DiscoHyTree])

;; Define triadic tree
(setv tree (DiscoHyTree :max-depth 3))

;; Each leaf has a path like (MINUS PLUS MIDDLE)
(for [agent (tree.leaves)]
  (print f"Agent {agent.id}: path-sum = {(agent.path-trit-sum)}"))

;; GF(3) conservation check
(assert (= 0 (sum (lfor a (tree.leaves) a.trit.value))))

Goblins Vat Bridge

Each object type gets its own vat (isolated execution context):

class VatNetwork:
    def __init__(self, acset):
        for ob in acset.schema["objects"]:
            self.vats[ob] = ObjectTypeActor(acset, ob)
    
    def near_ref(self, object_type):
        """$ operator - sync call within vat"""
        return NearRef(self.vats[object_type])
    
    async def far_send(self, object_type, method, *args):
        """<- operator - async message across vats"""
        return await self.executor.submit(
            getattr(self.vats[object_type], method), *args
        )

ACSet Random Access

TIDAR provides parallel random access to ACSet parts:

bridge = TIDARBridge(acset)

# Read with 27-agent pre-hook
result = await bridge.read_part("Content", idx=100)

# Write with 27-agent validation
result = await bridge.write_subpart("parent_of", src=1000, tgt=999)

CAT# Concept Availability

Prove availability of categorical concepts across ACSet:

CAT_CONCEPTS = {
    "category": ["objects", "morphisms", "identity", "compose"],
    "functor": ["object_map", "morphism_map"],
    "natural_transformation": ["component", "naturality_square"],
    "adjunction": ["left_adjoint", "right_adjoint", "unit", "counit"],
    "monad": ["unit", "multiplication"],
    "topos": ["subobject_classifier", "exponential"],
}

# Parallel search across all vats
bitmap = await prover.full_availability_scan()
# Returns: {concept: {object_type: count}}

GF(3) Conservation

At every level, the sum of trits = 0:

File Structure

zip_acset_skill/
├── openai_acset.py              # ACSet from ChatGPT export
├── parallel_availability_proof.py  # CAT# concept search
├── goblins_agent_bridge.py      # Vat network + capabilities
├── discohigh_interleave.py      # Triadic tree + pre-hooks
├── interactivity_proof.json     # Exported proof
└── discohigh_state.json         # Tree state + interaction log

Triad Formation

TIDAR forms triads with:

Conservation: (-1) + (0) + (+1) = 0 ✓

When to Use TIDAR

• Parallel ACSet access with provable availability
• Goblins vat coordination across object types
• Read/write validation with consensus
• GF(3)-conserved agency trees
• DiscoHy operadic composition

See Also

• discohy-streams

  - 7 operad variants with TAP streams

• goblins

  - Distributed object capabilities

• agent-o-rama

  - Pattern extraction and learning

• cat-tripartite

  - SICP/CTP/CatColab worldlines

• triad-interleave

  - GF(3) balanced scheduling

End-of-Skill Interface

Commands

# Run parallel availability proof
python3 parallel_availability_proof.py conversations.json

# Run Goblins bridge
python3 goblins_agent_bridge.py conversations.json

# Run full TIDAR interleaving
python3 discohigh_interleave.py conversations.json

Autopoietic Marginalia

The interaction IS the skill improving itself.

Every use of this skill is an opportunity for worlding:

• MEMORY (-1): Record what was learned
• REMEMBERING (0): Connect patterns to other skills
• WORLDING (+1): Evolve the skill based on use

Add Interaction Exemplars here as the skill is used.