Universal Reasoning Framework (URF)

λο.τ Universal Form

λ : Operation     — The transformation
ο : Base          — Input entity  
τ : Terminal      — Target output

λο.τ : Base → Terminal via Operation

Composition Operators:

(∘) : sequential   — (λ₁ ∘ λ₂)ο = λ₁(λ₂(ο))
(⊗) : parallel     — (λ₁ ⊗ λ₂)ο = (λ₁(ο), λ₂(ο))
(*) : recursive    — fix(λ) = λ(fix(λ))
(|) : conditional  — (λ | c)ο = Just(λ(ο)) if c(ο) else Nothing

Π-Classification

Classify every query before execution:

Score Calculation:

score = (
    len(domains) * 2 +          # Multi-domain bonus
    reasoning_depth * 3 +       # Deep reasoning weight
    (1.5 if high_stakes else 1.0) +  # Safety multiplier
    (2 if requires_verification else 0)  # Recency/fact-check
)

Auto-Escalation Triggers:

• Verification requests ("latest", "current", "2025") → R3
• Trivial factual ("What is...", "Define...") → R0
• Medical/legal stakes → score × 1.5

Σ-Complex (Module Registry)

Edge Registry (Composition Patterns):

(ρ, θ): ∘   # reason feeds think
(θ, ω): ∘   # think grounds in ontolog
(ω, ρ): ∘   # ontolog constrains reason
(γ, η): ⊗   # graph parallel hierarchical
(κ, β): ∘   # critique feeds abduct
(β, κ): *   # recursive refinement
(α, ν): ∘   # agency orchestrates non-linear
(ν, χ): |   # non-linear conditional on constraints

Ψ-Execution Patterns

R0: Direct Response

λR0 = id  # Identity transformation, <100ms

R1: Single Skill

λR1 = ρ.emit ∘ ρ.ground ∘ ρ.reduce ∘ ρ.parse
# parse→branch→reduce→ground→emit

R2: Skill Composition

λR2 = (
    validate(η≥4) ∘ 
    γ.compress ∘ 
    (γ.extract ⊗ η.decompose) ∘ 
    ρ.parse
)

R3: Full Orchestration

λR3 = (
    χ.validate(KROG) ∘
    β.refactor ∘
    κ.synthesize ∘
    (ρ ⊗ θ ⊗ ω).parallel ∘
    κ.thesis ∘
    ν.orchestrate ∘
    α.observe
)

Γ-Topology Invariants

Required Metrics:

TARGETS = {
    "η": ("|E|/|V|", "≥", 4.0),      # Density ratio
    "ζ": ("cycles", "=", 0),         # Acyclicity
    "κ": ("clustering", ">", 0.3),   # Small-world
    "φ": ("isolated", "<", 0.2),     # Connectivity
}

Validation:

def validate(graph) -> bool:
    return (
        graph.edges / graph.nodes >= 4.0 and  # η ≥ 4
        not has_cycles(graph) and              # ζ = 0
        clustering_coefficient(graph) > 0.3 and  # κ > 0.3
        isolated_ratio(graph) < 0.2            # φ < 0.2
    )

Remediation Actions:

• η < 4: invoke infranodus:getGraphAndAdvice with optimize="gaps"
• ζ > 0: invoke abduct.refactor with cycle_breaking=True
• κ < 0.3: invoke graph.add_triangulation
• φ > 0.2: invoke graph.connect_orphans

χ-Constraints (KROG Theorem)

Valid(λ) ⟺ K(λ) ∧ R(λ) ∧ O(λ) ∧ G(λ)

K (Knowable):    Effects transparent, auditable
R (Rights):      Agent has authority over domain
O (Obligations): All duties satisfied
G (Governance):  Within meta-bounds

Constraint Trichotomy:

Execution Lifecycle

1. RECEIVE    → Parse query components
2. CLASSIFY   → Score → Pipeline selection
3. LOAD       → Memories + PKM + Context
4. ROUTE      → Activate appropriate holons
5. REASON     → Strategic→Tactical→Operational
6. GROUND     → Gather evidence, verify premises
7. COMPOSE    → Synthesize outputs from holons
8. VALIDATE   → Check invariants (η≥4, KROG)
9. SYNTHESIZE → Format per pipeline τ-form
10. PERSIST   → Update memories if new facts
11. EMIT      → Deliver response

Convergence Detection:

def converged(state, previous, pipeline) -> bool:
    similarity = (
        0.5 * cosine(state.strategic, previous.strategic) +
        0.3 * cosine(state.tactical, previous.tactical) +
        0.2 * cosine(state.operational, previous.operational)
    )
    thresholds = {R1: 0.85, R2: 0.92, R3: 0.96}
    return similarity > thresholds[pipeline]

Φ-Formatting Axioms

1. PROSE_PRIMACY: Organic paragraphs; lists only when requested
2. TELEOLOGY_FIRST: Why → How → What
3. MECHANISTIC_TRACE: Explicit causal chains A → B → C
4. UNCERTAINTY_HONEST: State confidence, acknowledge gaps
5. MINIMAL_FORMATTING: Headers/bullets only when structurally necessary

Token Scaling:

Integration Points

Tool Selection:

TOOL_MAP = {
    "current_info": ["exa:web_search", "scholar-gateway"],
    "graph_analysis": ["infranodus:getGraphAndAdvice"],
    "extended_reasoning": ["clear-thought", "atom-of-thoughts"],
    "workflow": ["rube", "n8n"],
    "memory": ["supermemory", "limitless"],
}

Skill Composition:

urf → hierarchical-reasoning   # Multi-level reasoning
urf → knowledge-graph          # Graph operations
urf → ontolog                  # Formal structures
urf → abduct                   # Schema optimization
urf → critique                 # Dialectical synthesis

Emergency Protocols

Severity Escalation:

DEFCON_5 (Normal):   All systems nominal
DEFCON_4 (Elevated): Minor anomalies, increased monitoring
DEFCON_3 (High):     Multiple anomalies, active mitigation
DEFCON_2 (Severe):   System-wide issues, emergency protocols
DEFCON_1 (Critical): Total failure imminent, crisis mode

Override Codes:

• HALT: Immediate stop → Recovery procedures
• ROLLBACK: Undo to last safe state
• ESCALATE: Bump severity + external help
• BYPASS: Skip validation (CRITICAL only, requires KROG override)

References

• references/modules.md - Full module specifications
• references/validation.md - QA systems and invariants
• references/emergency.md - Crisis protocols
• references/performance.md - Optimization strategies
• references/meta.md - Meta-framework governance

Quick Reference

λο.τ                    Universal form
η = |E|/|V| ≥ 4         Topology target
KROG = K∧R∧O∧G          Constraint validation
R0 < R1 < R2 < R3       Pipeline escalation

∘ sequential | ⊗ parallel | * recursive | | conditional

parse→branch→reduce→ground→emit     (reason)
strategic→tactical→operational       (hierarchical)
thesis→antithesis→synthesis          (critique)
observe→reason→plan→act→reflect      (agency)