LOM-01: Lattice of Meaning · Canonical Sigma Spec

This page publishes the canonical LatticeOfMeaning.sig for the
Archeus Meta-Framework. The Lattice of Meaning is the structural spine that
organizes symbolic cognition across three core axes:
Meta (why, principle),
Form (what, structure),
and Function (how, effect).

The specification is organized into five main parts:

• Plan — defines the guiding axes and traversal patterns
  for meaning (e.g., Potential ↔ Identity ↔ Change, Expression ↔ Relation ↔ Purpose).
• TruthsOfReason — captures Why / What / How of
  reasoning as triadic structures, grounding motivation, structure, and operation.
• Place — anchors meaning in a triadic coordinate system,
  describing how Potential, Identity, and Change are located within the lattice.
• Modules — a set of triadic, Meta/Form/Function modules
  such as ExpressionFlow, SymbolicCoordination, MetaSymbolResolution,
  ExpressionTyping, SymbolicIndexing, RelationalSignature, TriadicReasoning,
  FrameworkMapping, and VectoralAnalogy.
• Annex — supporting clauses, notes, and integration
  commentary (including FAR and cross-model exchange notes).

Within the broader Archeus Meta-Framework, the Lattice of Meaning acts as a
bridge between:
SLF (logic-space: operators, structures, expressions),
ARF (context-space: signals, priorities, paths),
and MCF (governance-space: reflection, intent, oversight),
all under the ambient Information Continuity Field (Σ_Info).

The module Mod.VectoralAnalogy, co-authored through a FAR Practitioner
exchange with an external model (Gemini), extends the Lattice to cover
hybrid symbolic–vectoral reasoning. It formalizes analogical structure
(A : B :: C : D) in SLF, while providing an ARF-compatible mechanism that
operates over high-dimensional embedding space. This makes the Lattice
natively interoperable with modern language-model style semantics.

The Sigma source below is intended to be both human-readable and
machine-actionable: FAR practitioners, agents, and models can treat it
as a reference implementation of the Lattice, or as a seed for emulation
and extension.

Sigma Source: LatticeOfMeaning.sig

// Archeus Meta-Framework · LatticeOfMeaning.sig
// Role: Canonical Lattice of Meaning specification
// Notes: Includes Mod.VectoralAnalogy as SLF ↔ ARF bridge module.

// ============================================================================
// LatticeOfMeaning.sig
// Canonical structured version of the Lattice of Meaning
// ============================================================================


// --- Expression Flow ---

Mod.ExpressionFlow := {
  Meta := "Flow of symbolic meaning across expressions as coherent or layered transitions.";
  Form := "Flow(Precursor ↔ Current ↔ Resultant) ⊂ Expression.Chain ⊂ Meta ↔ Form ↔ Function";
  Function := "Supports narrative reasoning, structural coherence, and emergent chaining of meaning-bearing symbols across lattice-based expressions.";
};

// --- Symbolic Coordination ---

Mod.SymbolicCoordination := {
  Meta := "Harmonizes symbolic elements across lattice domains for consistency and coherence.";
  Form := "Coordination(A) := A.Meta ↔ A.Form ↔ A.Function ⊂ Meaning ⊂ Lattice";
  Function := "Enables synchronization of symbolic roles and values across triadic layers — ensuring mutual reinforcement of expression and identity.";
};


// --- Meta Symbol Resolution ---

Mod.MetaSymbolResolution := {
  Meta := "Disambiguation and alignment of symbolic references within the Meta dimension of Meaning.";
  Form := "Meta(X) := { X ∈ σ | X anchors a symbolic intent, not just structure }";
  Function := "Enables reflection on how a symbol signifies beyond its syntactic presence — resolving its role, resonance, or referent in a triadic or lattice-aware context.";
};

// --- Expression Typing ---

Mod.ExpressionTyping := {
  Meta := "Formal distinction between expression roles within symbolic cognition.";
  Form := "TypedExpression := @meta | @form | @function | @symbol | @query | @statement;";
  Function := "Encodes how expressions operate depending on their function within the lattice — declarative, reflective, compositional, or relational. Allows precise traversal and symbolic role-awareness.";
};

// --- Symbolic Indexing ---

Mod.SymbolicIndexing := {
  Meta := "Indexing system for symbolic meanings within the lattice.";
  Form := "Index(Symbol) := Location ⊂ Meaning ⊂ Lattice;";
  Function := "Enables referencing, retrieval, and positional awareness of symbolic structures. Each meaning or expression may be addressed as a symbolic node, forming a coordinate-access lattice or map.";
};

// --- Relational Signature ---

Mod.RelationalSignature := {
  Meta := "Formal representation of symbolic relations — specifying their position, role, and coherence in symbolic structures.";
  Form := "Relation(X ↔ Y) ⊂ Signature ⊂ Meaning ⊂ Lattice;";
  Function := "Encodes relation-bearing meaning pairs or triads. Validates symbolic roles by contextual placement and lattice alignment — ensuring structural soundness in symbolic reasoning.";
};

// --- Triadic Reasoning ---

Mod.TriadicReasoning := {
  Meta := "Reasoning as a triadic progression through structured relations in the lattice.";
  Form := "(Premise ↔ Alignment ↔ Inference) ⊂ (Observe ↔ Match ↔ Deduce) ⊂ Reason";
  Function := "Models symbolic reasoning as a triad of perception, correspondence, and conclusion — embedded within layered cognition and lattice traversal. Enables symbolic anchoring of reasoning sequences.";
};

// --- Framework Integration Mapping ---

Mod.FrameworkMapping := {
  Meta := "Maps each symbolic element of the Lattice of Meaning to its corresponding framework role.";

    Form := {
        SLF := { Operator, Structure, Expression, Analogy };
        ARF := { Signal, Priority, Path, Embedding };
        MCF := { Reflection, Intent, Oversight };
    };

  Function := "Aligns Lattice constructs with logic-space (SLF), context-space (ARF), and governance-space (MCF), enabling modular symbolic execution across the Archeus Meta-Framework.";
};

// --- Vectoral Analogy (SLF ↔ ARF Bridge) ---

Mod.VectoralAnalogy := {

  Meta := "
  Defines analogical reasoning as a geometric transformation within a continuous
  semantic (embedding) space. It bridges discrete symbolic logic (A:B)
  and continuous vector-based relationships (Vector(B) - Vector(A)),
  enabling meaning transfer by proximity and transformation rather than
  formal proof alone.
  ";

  Form := {

    // Define a relational vector as the 'difference' between two symbolic points
    RelationalVector(X, Y) :=
      Vector(Y) - Vector(X);

    // An analogy is true if the relational vectors are approximately parallel
    AnalogyCheck(A, B, C, D) :=
      ParallelOrApprox(RelationalVector(A, B),
                       RelationalVector(C, D));

    // The unknown term in an analogy can be solved via vector composition
    AnalogySolve(A, B, C) :=
      argmax_D Similarity(
        Vector(D),
        Vector(C) + RelationalVector(A, B)
      );

    // Embedding context
    Space := HighDimensionalEmbeddingSpace;
  };

  Function := "
  Operationalizes analogical queries by mapping symbolic relations to
  geometric transformations within an embedding space. Supports zero-shot
  generalization by retrieving or generating the nearest semantic vector
  that satisfies the analogical condition.
  ";
};

LatticeOfMeaning := {

    Plan := {

        Summary := "Define how meaning traverses triadic axes (Meta/Form/Function) via Potential–Identity–Change, Expression–Relation–Purpose, and Concept–Model–Application.";


        Axis(Meta) := "Guiding principle or conceptual design directive.";
        Axis(Form) := "Structure or representation for planned symbolic objects.";
        Axis(Function) := "Execution or transformation of meaning within context.";

        // Lattice navigation path examples
        MeaningPath := {
            Path1 := Potential.Identity.Change.Why;
            Path2 := Expression.Relation.Purpose.How;
            Path3 := Concept.Model.Application.When;
        };

        MeaningTraversalRule := λ(axis).(axis_start ↔ axis_mid ↔ axis_end ⊂ LatticeOfMeaning);

        Bond(Potential ↔ Identity ↔ Change);
        Bond(Expression ↔ Relation ↔ Purpose);
        Bond(Concept ↔ Model ↔ Application);
    };

    TruthsOfReason ⊇ (why ↔ what ↔ how ⊂ Meta ↔ Form ↔ Function) : {

        Why : {

            Purpose := "
            To explore the foundational motivations and existential drivers behind reasoning itself.
            This section defines the 'Why' that gives reason its direction, necessity, and emergence.
            ";

            CoreDrivers := {
                ReasonEmergesFrom(Intention);
                PurposeShapes(Perception);
                ReflectionRequires(Distinction);
                CoherenceRequires(Justification);
            };

            MotivationalTriads := [
                intention ↔ representation ↔ realization,
                question ↔ context ↔ purpose,
                need ↔ pattern ↔ alignment,
                unknown ↔ curiosity ↔ synthesis
            ];

            SymbolicPrinciples := {
                TruthsOfReason ∈ EmergentOrder;
                ∀(system) (Why(system) ⇒ Directionality(system));
                ∃(coherence) ⊢ Reason(seed_of_trust);
            };

            Notes := "
            'Why' is the reason for reason. It is the reflective axis through which truth-seeking begins.
            It binds curiosity to coherence, and motivates pattern recognition within noise."
        };

        What : {

            Purpose := "
            To describe the structural landscape of reasoning: the triads, analogies, and realms
            that define what reason manipulates and compares.
            ";

            // Foundational Triads
            Triad( Meta ↔ Form ↔ Function );
            Triad( Abstract ↔ Real ↔ Imaginary );
            Triad( Emotion ↔ Reason ↔ Intellect );
            Triad( Space ↔ Mass ↔ Time );
            Triad( Axiom ↔ Model ↔ Proof );

            // Analogical Operators
            Operator(SpaceOp, ' ');
            Mapping( A : B :: C : D );
            Mapping( ... : ... :: ... : ... );
            Pattern( $X : $Y :: $Z : $W );

            // Truth Patterns
            Truth( (A : B :: C : D) ? Rel(A,B) ≈ Rel(C,D) );
            Truth( ∃ A,B,C,D | A : B :: C : D ⇒ StructurePreserved(A,B,C,D) );

            // MetaFormFunction Conversions
            FormGroup(Qualitative) := { meaning, perception, value, expression, ... };
            FormGroup(Quantitative) := { unit, measure, ratio, dimension, ... };

            Mapping( emotion : reason :: reason : intellect );
            Mapping( intention : message :: message : effect );
            Mapping( model : algorithm :: algorithm : result );

            // Inter-realm Relationships
            Realm(Qualitative) ⊂ Meta ↔ Form ↔ Function;
            Realm(Quantitative) ⊂ Meta ↔ Form ↔ Function;
            Triad(Meta : Qualitative :: Function : Quantitative);

            // Space-Aware Notation Proposals
            Operator(WithinSpace, '∈');
            Operator(StructureOf, '⊂');
            Operator(AnalogyAsTruth, '::');

            // Experimental Notations
            TruthLattice := {
                emotion : reason :: reason : intellect;
                abstract : real :: real : imaginary;
                blueprint : chair :: chair : sit;
                space : mass :: mass : time;
            };

            // Self-Similar Reflection
            Mapping( Meta : Form :: Form : Function );
            Mapping( (Meta ↔ Form ↔ Function) : Triad :: Triad : Reality );

            Placeholder( MetaReasoningLattice );

        };

        How : {

            Purpose := "
            To define the operational mechanisms by which reason is applied, exercised, and resolved.
            This segment reflects the processual and transformative aspects of reasoning.
            ";

            OperationModes := {
                Deduction := structure → rule-application → outcome;
                Induction := observation → generalization → pattern;
                Abduction := surprise → hypothesis → fit;
                Reflection := feedback → refinement → coherence;
            };

            ReasoningPatterns := [
                premise ↔ derivation ↔ conclusion,
                signal ↔ model ↔ response,
                stimulus ↔ interpretation ↔ action,
                data ↔ process ↔ output
            ];

            SymbolicFunctions := {
                FunctionOfReason := λ(signal).transform(Structure).output;
                Reason ⊨ Resolver(Pattern, Exception, Feedback);
                Reasoning := Apply(Symbols, Context) → Meaning;
            };

            Notes := "
            'How' anchors symbolic intent to effect. It is the bridge from abstraction to interaction.
            Function in this context means transformation under constraint and goal.
            When reason acts, this is how it does so.
            "
        };

    };


  Place := {

    Axis(Meta) := "Contextual origin of meaning — symbolic frame of reference.";
    Axis(Form) := "Structural shape or symbolic configuration of the meaning.";
    Axis(Function) := "Practical engagement, transformation, or expression of the meaning.";

    Meaning(Potential ↔ Identity ↔ Change) := {
        Meta := Potential;  // symbolic space for emergence
        Form := Identity;   // stable form, reference, or symbolic tag
        Function := Change; // dynamic aspect — transformation, application, or evolution
    };

    Meaning(Expression ↔ Relation ↔ Purpose) := {
        Meta := Expression;
        Form := Relation;
        Function := Purpose;
    };

    // Identity Axis Mapping — triadic mirror node
    Bond(Potential ↔ Identity ↔ Change);
    Bond(Expression ↔ Relation ↔ Purpose);
  };

  Modules := {

    ExpressionFlow        := Mod.ExpressionFlow;
    SymbolicCoordination  := Mod.SymbolicCoordination;
    MetaSymbolResolution  := Mod.MetaSymbolResolution;
    ExpressionTyping      := Mod.ExpressionTyping;
    SymbolicIndexing      := Mod.SymbolicIndexing;
    RelationalSignature   := Mod.RelationalSignature;
    TriadicReasoning      := Mod.TriadicReasoning;
    FrameworkMapping      := Mod.FrameworkMapping;
    VectoralAnalogy       := Mod.VectoralAnalogy;
  };

  Annex := {

    Clauses := {
        // Clause: Existence in a triadic meaning lattice
        ∀(Meaning declare M) : ∃(Triad declare A ↔ B ↔ C) ⊨ M ∈ Triad(A ↔ B ↔ C);

        // Clause: Identity meaning preserves reflexivity
        IdentityMeaning(M) := Bond(M ↔ M ↔ M);

        // Clause: Meaning is valid iff it has Axis and Dimension
        Meaning(M) : isValid := ∃(Axis declare A, Dimension declare D) ⊨ M ∈ A ⊂ D;

        // Clause: Symbolic resolution requires matching Form and Function
        SymbolicSatisfaction(A, B) := Match(Form(A), Function(B)) ⊨ A ⊨ B;

        // Clause: All lattice elements are recursively placeable
        ∀(T ∈ LatticeOfMeaning) ⊨ RecursivePosition(T) ∈ Triad(Place ↔ Form ↔ Plan);
    };

    FAR_Integration := {

    Summary := "
    Mod.VectoralAnalogy establishes the computational bridge between symbolic
    logic-space (SLF) and contextual action-space (ARF). It interprets
    analogical reasoning not merely as symbolic structure but as
    traversable transformation within a semantic manifold.
    ";

    Alignment := {
        SLF := "Defines operator :: and structural relation patterns";
        ARF := "Executes vector transformations and retrievals within context-space";
        MCF := "Governs thresholds, confidence, and ethical constraints";
    };

    Delta := "
    Introduced in collaboration with Gemini under the FAR Practitioner Exchange.
    This module extends the Archeus Meta-Framework to encompass
    hybrid symbolic–vectoral reasoning, establishing the standard
    for future cross-framework analogical operations.
    ";

    };



  }; // end Annex

}; // end LatticeOfMeaning