Add Morphic Cognitive Engine: phase-shifting gravitational attention with Octonion embeddings

[Copilot]

Extends LGT from a static physics model into a self-regulating cognitive agent that transitions between four "cognitive phases" (Solid/Fluid/Gas/Singularity) by dynamically adjusting gravitational constant G, spacetime curvature, and information density targets.

New Modules

• octonion_pos_embedding.py — 8D Octonion positional embeddings replacing Euclidean distance in the gravitational force formula. OctonionEmbedding encodes 8 phase-shifted sinusoidal components (real, i, j, k, l, il, jl, kl); GravitationalOctonionPosition produces a full [batch, seq_len, seq_len] pairwise distance matrix.

• polymorphic_attention_orchestrator.py — PolymorphicAttentionOrchestrator replaces dot-product attention with force-based computation using morph(phase) to reconfigure attention physics per phase:

  orch = PolymorphicAttentionOrchestrator(dim_model=256, num_heads=8)
  orch.morph("singularity")          # G=50.0, curvature=-0.1, extreme local focus
  out, diag = orch(x)                # diag includes max_force, mean_force, phase, G

  Phase	G	Curvature	Use
  solid	0.5	0.0	Precise, low-entropy reasoning
  fluid	1.0	0.15	Balanced default
  gas	0.1	0.8	Creative / exploratory
  singularity	50.0	−0.1	Extreme focus, Hawking-clamped

• training_containment.py — MorphicContainmentProtocol stabilises high-G Singularity phases via: (1) Bekenstein Entropy penalty discouraging attention collapse, (2) Hawking Radiation gradient damping when max_force exceeds threshold, (3) stability-based halt signalling.

Modified Files

• victorcos_module.py — Adds MorphicVictorAgent (subclass of LGTVictorOSModule) that autonomously selects cognitive phase from Mirror Layer stability score, applies it to both the orchestrator and underlying LGT attention heads, and logs every phase transition to the VictorOS Ledger:

  agent = MorphicVictorAgent(model=lgt, orchestrator=orch)
  result = agent.process_morphic(x, task_complexity=1.0)
  # → result["phase"] reflects autonomously chosen phase
  # → all transitions logged to agent.ledger as "phase_shift" events

• __init__.py — Exports all new public symbols.

• tests/test_lgt.py — 37 new tests covering all new modules (103 total).

Original prompt

Morphic Cognitive Engine Extension for LGT

This PR introduces a "Morphic Cognitive Engine" to the Lightweight Gravitational Transformer (LGT). It allows the model to transition between different "cognitive phases" (Solid, Fluid, Gas, Singularity) by dynamically adjusting its internal physics—specifically the gravitational constant ($G$), spacetime curvature, and information density targets.

Key Enhancements:

1. Polymorphic Attention Orchestrator:

   • Implements a morph(phase) method that reconfigures attention parameters based on the agent's current state (e.g., "Singularity" for extreme focus, "Gas" for creative exploration).
   • Replaces standard dot-product attention with a force-based calculation: $F_{ij} = \frac{G \cdot m_i \cdot m_j}{\text{dist}(p_i, p_j)^2 + \epsilon}$.

2. Octonion Positional Embeddings:

   • Introduces 8-dimensional non-associative Octonion embeddings in octonion_pos_embedding.py.
   • Provides a richer, non-Euclidean manifold for calculating token distances, enabling stable "curved spacetime" reasoning even at high gravitational constants.

3. Morphic Containment Protocol:

   • Adds MorphicContainmentProtocol in training_containment.py to stabilize high-gravity phases.
   • Implements Bekenstein Entropy penalties to prevent information collapse (singularities) and provides "Hawking Radiation" (force-aware gradient damping).

4. Morphic VictorOS Agent:

   • A new MorphicVictorAgent subclass of LGTVictorOSModule that can autonomously decide when to shift phases based on internal stability scores and task complexity.
   • Full integration with the VictorOS Ledger for auditing phase shifts and containment events.

New Files:

• polymorphic_attention_orchestrator.py: The core morphic attention logic.
• octonion_pos_embedding.py: 8D Octonion distance and embedding logic.
• training_containment.py: Entropy-aware safety protocols.

This extension transforms LGT from a static physics-aware model into an active, self-regulating cognitive agent suitable for AGI research.

The following is the prior conversation context from the user's chat exploration (may be truncated):

User: WHAT IS THIS

Assistant: The Lightweight Gravitational Transformer (LGT) is a physics-aware transformer architecture developed by MASSIVEMAGNETICS. It replaces the standard softmax-based query-key-value attention mechanism with a computation based on Newton's law of gravitation.

Core Concept: Gravitational Attention

Instead of using dot-product similarity, LGT assigns each token a learnable mass ($m$). The attention weight between two tokens is determined by the gravitational force ($F$) between them, calculated as:
$$F_{ij} = \frac{G \cdot m_i \cdot m_j}{\text{dist}(p_i, p_j)^2 + \epsilon}$$

• $G$: A learnable gravitational constant (can be unique per attention head).
• $p_i, p_j$: Token positions in a curved or fractal manifold.
• $\epsilon$: A small constant (event horizon) to prevent division by zero.

Key Features

• Minimalist Design: Optimized for resource-constrained environments and edge deployment, with presets as small as 150k parameters (<1 MB).
• Physics-Aware Stability: Includes a ContainmentProtocol and Hawking regularisation to prevent attention collapse and ensure training stability.
• Fractal & Curved Positions: Uses non-Euclidean geometry for positional embeddings to naturally encode distance-sensitive context.
• VictorOS Integration: Designed as a first-class cognitive module for the VictorOS runtime, featuring:
  • Ledger: An append-only audit trail for inference events.
  • Mirror Layer: Real-time stability monitoring.
• Tri-Model Architecture: Supports a three-stream cognitive fusion of "World", "Self", and "Environment" models.

Project Structure

The repository is structured into several core modules:

• gravitational_attention.py: The core physics-based attention implementation.
• lightweight_gravitational_transformer.py: The main model stack.
• training.py: physics-aware training loops and the ContainmentProtocol.
• export_edge_model.py: Tools for INT8/FP16 quantization and TorchScript export.

For more details, you can explore the README.md or the examples/ directory in the repository.

User: can you build a active intelligence agent with it?

Assistant: Yes, you can absolutely build an Active Intelligence Agent with the Lightweight Gravitational Transformer (LGT). In fact, the project includes a dedicated module, victorcos_module.py, specifically designed to package LGT models as first-class "cognitive agents" for the VictorOS runtime.

An LGT-based active agent ...

This pull request was created from Copilot chat.

---

📍 Connect Copilot coding agent with Jira, Azure Boards or Linear to delegate work to Copilot in one click without leaving your project management tool.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 899cfeeb7f

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".