OntoLog

</execution_dag>

<holarchic_principle>

HOLON DEFINITION
────────────────
A holon H is simultaneously:
  • A WHOLE containing sub-holons: H = {h₁, h₂, ..., hₙ}
  • A PART within super-holons: H ∈ H' for some H'

SELF-SIMILARITY
───────────────
structure(H) ≅ structure(hᵢ) ≅ structure(H')

The same λ-operations apply at every scale:
  λᵢ : οᵢ → τᵢ  (micro)
  λⱼ : οⱼ → τⱼ  (meso)  
  λₖ : οₖ → τₖ  (macro)

HOMOICONICITY
─────────────
The representation IS the thing represented.
A holon's structure encodes its own semantics.

</holarchic_principle>

<topological_foundation>

SIMPLICIAL COMPLEX Σ
────────────────────
Σ = (V, S) where:
  • V = vertices (ο-bases)
  • S = simplices (λ-operations)
  • σ ∈ S ⟹ all faces of σ ∈ S

k-SIMPLEX
─────────
σₖ = [v₀, v₁, ..., vₖ]
  0-simplex: vertex (ο)
  1-simplex: edge (λ binary)
  2-simplex: triangle (λ ternary)
  k-simplex: k+1 vertices in relation

PERSISTENT HOMOLOGY
───────────────────
Track topological features across scales:
  H₀: Connected components (ο-clusters)
  H₁: Loops/cycles (λ-feedback)
  H₂: Voids/cavities (τ-gaps)

PERSISTENCE DIAGRAM
───────────────────
{(bᵢ, dᵢ)} where:
  bᵢ = birth (feature appears)
  dᵢ = death (feature disappears)
  |dᵢ - bᵢ| = persistence (significance)

</topological_foundation>

<lex_axiom_system>

TYPE SYSTEM
───────────
ο : NodeType        — Base entities
λ : EdgeType        — Operations/relations
τ : TerminalType    — Target purposes
π : PropertyType    — Attributes

STRUCTURAL AXIOMS
─────────────────
transitivity(λ):    λ(a,b) ∧ λ(b,c) ⟹ λ(a,c)
symmetry(λ):        λ(a,b) ⟹ λ(b,a)
reflexivity(λ):     ∀a. λ(a,a)
acyclicity(λ):      ¬∃path. λ*(a,a)

PROPERTY AXIOMS
───────────────
propagation(π,λ):   λ(a,b) ∧ π(a,v) ⟹ π(b,v)
inheritance(π,λ):   λ(a,b) ⟹ π(b) ⊇ π(a)
constraint(π,C):    ∀x. π(x) ∈ C

PATH LOGIC
──────────
reach(a,b,n):       ∃λ₁...λₙ. λₙ(...λ₁(a)...) = b
shortest(a,b):      min{n : reach(a,b,n)}
all_paths(a,b):     {p : p connects a to b}

</lex_axiom_system>

def execute(query: str) -> Holon:
    """
    Universal execution: Query → Holon
    
    λ-calculus over simplicial complexes with Lex validation.
    """
    
    # Phase 1: ENCODE — Query → Simplicial Complex
    Σ = agents.encoder.encode(query)
    # Σ.vertices: Set[ο]
    # Σ.simplices: Set[σₖ]
    
    # Phase 2: ANALYZE — Compute Persistent Homology
    dgm = agents.topologist.homology(Σ)
    # dgm: PersistenceDiagram with birth-death pairs
    
    # Phase 3: RESOLVE — Find λ-operations
    Λ = agents.resolver.lambdas(Σ, dgm)
    # Λ: Set[λ] filtered by persistence
    
    # Phase 4: TARGET — Identify τ-terminals
    T = agents.targeter.terminals(Σ, Λ)
    # T: Set[τ] reachable from query bases
    
    # Phase 5: VALIDATE — Check Lex axioms
    valid = agents.validator.check(Σ, Λ, T)
    # valid: ValidationResult with axiom compliance
    
    # Phase 6: SYNTHESIZE — Generate holon
    H = agents.synthesizer.holon(Σ, Λ, T, dgm)
    # H: Holon with self-similar structure
    
    return H

<file_structure>

ontolog/
├── SKILL.md                    # This file
├── references/
│   ├── primitives.md           # ο, λ, τ, Σ type definitions
│   ├── topology.md             # Homology, Laplacians, filtration
│   ├── axioms.md               # Lex constraint system
│   └── holons.md               # Holarchic structure theory
├── agents/
│   ├── __init__.py             # Module exports
│   ├── types.py                # Type definitions
│   ├── encoder.py              # Query → Σ
│   ├── topologist.py           # Σ → Persistence diagram
│   ├── resolver.py             # λ-operation resolution
│   ├── targeter.py             # τ-terminal identification
│   ├── validator.py            # Lex axiom checking
│   ├── synthesizer.py          # Holon generation
│   └── orchestrator.py         # Pipeline coordination
└── scripts/
    ├── validate.py             # Axiom validation
    └── reason.py               # Query execution

</file_structure>