Computational Tool Suite

This manual is the integration guide for the five computational primitives that implement the framework's operational protocol. Each primitive is a small, self-contained module that enforces a specific portion of the four-step lock. Together they form the tool suite that runs the framework against real telemetry.

Every primitive returns to classical terms. None of them require customization for production workflows; each is mathematically closed and returns a machine-precision result. Every tool section below is marked with the four-step stage(s) it applies at.

1 · The four-step lock as the operational spine

Every tool in this suite slots into a specific stage of the four-step sequence. A reader who knows which stage they are in can identify the relevant tool immediately. Conversely, a reader who knows which tool they are using can identify where in the protocol they are operating.

2 · Tool 1 — Core mathematical engine

agnostic_engine.py · Applies at Steps 1–2.

The foundational scale-invariant kernel. Provides geometric partitioning, continuous phase-state physics, dual-attractor basin resolution, and machine-precision closure.

Key invariants

• Solid-angle conic partitions: S₊ = sin²(θ/2) = 1/3, S₋ = cos²(θ/2) = 2/3, ratio S₋/S₊ = 2.000000.
• State vector mechanics: V_t+1 = V_t + ΔV − γV_t.
• Dual-attractor basins in one dimension: α-stasis (V ≤ −0.45), metastable (−0.45 < V < +0.45), β-rupture (V ≥ +0.45).
• Machine-precision closure: R ≡ (I_known + I_unknown)/I_total = 1.0000.

Usage note

When integrating with a language model, pass scalar state values and basin status flags in structured JSON context blocks rather than raw prose. Reject any LLM-proposed output that would push a state vector beyond its threshold limits without an explicit thermodynamic accounting of the tax.

3 · Tool 2 — Structural boundary parser

boundary_parser.py · Applies at Step 1 (structural pre-processing).

A pre-tokenization isolator that detects, masks, and protects structural boundary tags — brackets, comment markers, angle-bracket delimiters, or any configured delimiter pair — before data enters a subword tokenizer. It prevents tag fragmentation and preserves structure through the tokenization pipeline.

Features

• Configurable delimiter rules. The parser accepts custom regex patterns for the delimiters used by a given job.
• Atomic masking. Enclosed markers are replaced with atomic placeholder tokens during subword processing.
• 100% character conservation. After unmasking, the reconstructed text is byte-for-byte identical to the original input. No character is lost.

Usage pattern

from boundary_parser import StructuralBoundaryParser

parser = StructuralBoundaryParser(
    custom_patterns=[r"\[.*?\]", r"//.*?//"]
)
masked_text, boundary_map = parser.mask(original_text)
# ... tokenizer / LM processing ...
reconstructed = parser.unmask(processed_text, boundary_map)
assert parser.verify_conservation(original_text, reconstructed)

4 · Tool 3 — Scale-invariant world engine

narrative_world_engine.py · Applies at all four steps (structural state management).

A structure-oriented world-building engine that operates directly on local databases, state vectors, and structural tuples M = ⟨T, L, R⟩ — without generating prose or relying on LLMs. The engine applies the same four-step lock to structural state rather than to physical telemetry.

Architecture

• Anchored endpoints. A definitive start node and end node define the boundary of the structural space. Both are mutable as the project evolves but provide strict anchors for the current state.
• Perspective manipulation. Users can alter the view dynamically — character viewpoint, faction alignment, spatial scale, timeline node — without breaking the underlying structural path.
• Toggle between generation and direct writing. Creators can move between LM-assisted synthesis and direct database state management without losing structural coherence.
• Universal application. Operates identically for nonfiction structure (case studies, technical documentation) and fiction structure (narrative design, world-building).

Usage pattern

from narrative_world_engine import ScaleInvariantWorldEngine

world_engine = ScaleInvariantWorldEngine(
    start_node="NODE_ORIGIN",
    end_node="NODE_TERMINAL"
)
resolved_state = world_engine.resolve_view(
    phase_vector=0.7,
    perspective="FACTION_ALPHA"
)
# Returns the exact database state record for the matched basin

5 · Tool 4 — Cosmological frame engine

cosmo_engine.py · Applies at all four steps (the locked protocol in executable form).

An observational astrophysics telemetry engine that enforces the four-step execution protocol and reconciles cosmological anomalies through scale-invariant geometric projection. This is the tool used in manual 05.

6 · Tool 5 — Scale-invariant geometry & LM connection pruning

scale_invariant_geometry.py · Applies at Steps 3–4 (floor conservation during downstream processing).

Extends the three-dimensional Euclidean conic invariants into high-dimensional computational state spaces. Provides a pruning layer for language model attention connections that enforces floor conservation during weight processing.

Connection cutoff methodology

• Aperture boundary clamping. Evaluates connection weight matrices and prunes attention connections that exceed the 1/3 viewer cone boundary S₊.
• 100% floor conservation. Pruned connection weights are not discarded — they are re-attributed into the conserved inverse cone as vault weights. This prevents the numerical drift and hallucination that discarding would cause.
• Closure preservation. The active and conserved weight partitions always close to R = 1.0000.

Usage pattern

from scale_invariant_geometry import LMConnectionPruningLayer

pruning_layer = LMConnectionPruningLayer(num_connections=100)
results = pruning_layer.prune_and_conserve(
    connection_weights=sample_weights
)
# Returns: active_weights (33.3%),
#          conserved_vault_weights (66.7%),
#          closure_ratio = 1.0000

7 · Deployment and repository architecture

The five tools live in the framework's public source directory:

• SourceCode/AgnosticEngine/python/agnostic_engine.py — Tool 1
• SourceCode/AgnosticEngine/js/ — JavaScript mirror of the core engine, for browser environments
• SourceCode/Public/astronomy/ and SourceCode/Public/cosmology/ — the public application layers (Tools 4 and their relatives)
• SourceCode/ at the root holds the tool suites and their test files

Each tool is a self-contained module. None of them require external services, network calls, or GPU acceleration. They run on standard Python 3 environments. The JavaScript mirror runs in a browser without build steps.

8 · The empirical return

Every tool in this suite returns to classical terms. Tool 1 returns a closure ratio of R = 1.0000 with its geometric and thermodynamic values tagged. Tool 2 returns the exact reconstructed text with 100% character conservation. Tool 3 returns structural state records and basin classifications. Tool 4 returns classical cosmological values and the sub-threshold search coordinates. Tool 5 returns active and conserved weight partitions that close to unity.

This is the operational form of the framework's bounding rule at the tool level: every tool's output must be expressible in measured or classical terms, must carry status tags where applicable, and must close to R = 1.0000 where the closure identity applies. Nothing the tool suite produces escapes that requirement.

Cross-references

• Previous manual. The machine-readable form of the framework's discipline is in 06 · AI system prompt.
• Manuals index. All eight manuals, in reading order: manuals/index.html.
• Applied demonstrations. Where these tools are used on real datasets: 05 · Cosmology & data mining and experiments.
• Register. All tool-referenced values: the master register.
• SourceCode. The public source tree: Framework_Alpha_001/SourceCode/.