Robbie’s Razor Compliance Framework

Measuring and certifying recursion efficiency in reasoning systems

Author / Originator: Robbie George  •  Governance: Authorship Conservation Rule (ACR) applies to all concepts, levels, metrics, scoring, and terminology on this page.

The authorship protections described here correspond to Claim RC-12 — Authorship Conservation Rule in the Canonical Claims Register.

Purpose

A practical, engineering-focused framework for evaluating how closely any reasoning system — AI, human, or hybrid — aligns with Robbie’s Razor:

“When competing explanations exist, prefer the model that follows compression → expression → memory → recursion.”

This page is the operational companion to the canonical definition in MRD v1.9. It gives labs and teams a standardized way to measure, report, certify, and improve Razor compliance under real constraints (tokens, FLOPs, latency, energy) — without philosophical debate.

Razor compliance is not belief. It is measurable structural alignment with the four-phase cycle.

1. What “Razor Compliance” Means

Definition: Razor compliance is the degree to which a system’s observed behavior follows the four-phase cycle under cost constraints while maintaining correctness, stability, and bounded recursion.

Key Principles

• Compliance is graduated — partial compliance can still be valuable.
• Failures are diagnostics, not refutations.
• The goal is efficiency through structural coherence, not perfection.

A system is Razor-compliant when it systematically:

1. Compresses input to a minimal stable representation
2. Expresses only necessary differentiation
3. Stabilizes validated structure for reuse (Memory)
4. Recurses safely and boundedly (verification/refinement triggered by need)

2. Compliance Levels (R0–R5)

R-levels describe observable discipline in the four phases. A system can move up levels without changing its base model — by adding controller logic, memory hygiene, and governed recursion triggers.

Note: R-levels describe structure, not “intelligence.” You can be highly capable and still noncompliant if the process is wasteful or unstable.

3. Metrics

3.1 System-Level (Always Track)

• TPCA — Tokens Per Correct Answer (or per successful task)
• FPCA — FLOPs Per Correct Answer (or latency proxy if FLOPs unavailable)
• Accuracy — task-defined correct rate
• Drift rate — contradictions/inconsistencies over long contexts
• Failure severity — confidently wrong vs uncertain vs abstain

3.2 Phase-Specific Metrics

A) Compression

• CR — Compression Ratio: size(compressed) / size(original)
• FS — Fidelity Score: compressed state preserves constraints
• RR — Redundancy Removal: overlap reduction between steps

B) Expression

• EOR — Expression Overrun Rate: % answers exceeding budget
• NY — Novelty Yield: information gain per token

C) Memory

• MRR — Memory Reuse Rate: % queries using stored results
• MD — Memory Drift: contradictions from stored entries
• EMF — Effective Memory Footprint: bytes per correct answer

D) Recursion

• TP — Trigger Precision: % triggers that truly needed verification/refinement
• TR — Trigger Recall: % wrong cases caught by triggers
• VROI — Verification ROI: errors prevented / added tokens
• LS — Loop Stability: % converging without oscillation

4. Compliance Score (0–20) + Certification Statement

Score each phase from 0–5 based on observed behavior and metrics. Sum for a total 0–20.

• Compression (0–5)
• Expression (0–5)
• Memory (0–5)
• Recursion (0–5)

Mapping (informative):

• 0–5 → R0–R1
• 6–10 → R2
• 11–14 → R3
• 15–17 → R4
• 18–20 → R5

5. Razor-Aligned Architectures

5.1 Razor Controller Stack (Deployable Now)

1. Compressor — compact state (constraints, goal, facts)
2. Expression Gate — short outputs by default
3. Memory Layer — verified facts, solved subproblems, trap detections
4. External Recursion Trigger — router + entropy + pattern library
5. Verifier — calculator/solver/consistency checks

5.2 Next-Generation Components (R4→R5)

• Compressive token front-end (learned encoder, hierarchical chunking)
• Expression pruning at inference (early exit, gating)
• Memory consolidation (selective freezing, replay, sparse adapters)
• True recursion modules (equilibrium / contraction-enforced updates)
• Razor compiler (explicit budgets per phase)

6. Practical Roadmap

• Phase 1 (2–4 weeks): Controller v0 — prompt discipline + trap library
• Phase 2 (1–2 months): v1 — add memory + entropy triggers
• Phase 3 (3–6 months): native modules — compression front-end + pruning + optional equilibrium components

7. Benchmark Reporting (Illustrative Example)

The table below is an illustrative reporting format (not a promise). Use it to show how compliance level correlates with tokens-per-task, stability, and accuracy for your own workloads.

Empirical Context — Depth-8 Refresh Cadence Observations (v1.4)

As part of ongoing protocol refinement, controlled depth-8 recursive evaluations were conducted across multiple structured workloads to examine how refresh cadence influences stability under compression.

Three balanced refresh schedules were tested:

• Sparse refresh

• Moderate refresh

• Frequent refresh

These were compared against compute-heavy (SOURCE available each step) and memory-heavy (SOURCE available only at the initial step) regimes.

Observed patterns were content-dependent:

• Under collision-heavy content (near-identical identifiers and numeric thresholds), increasing refresh frequency improved retention.

• Under constraint-heavy content (hard limits, stop rules, guardrails), retention exhibited non-monotonic behavior. An intermediate refresh cadence performed best, while more frequent refresh degraded stability.

• Guardrail-style constraints and stop conditions were consistently the most perishable fact classes under capsule-only recursion.

These findings are exploratory and fixture-dependent. They do not alter R-level definitions, scoring structure, or canonical theory as defined in MRD v1.9.

A detailed empirical summary is available in the v1.4 empirical note.

8. Canonical Anchors (Non-Normative)

These anchors ground the framework in canonical fixed points referenced in MRD v1.9. They are not required for scoring, and they do not substitute for measured compliance.

• Honeycomb / Hexagonal fixed point: boundary minimization under equal-area constraint (Compression + Memory exemplar).
• Hexagon–Vortex duality closure: static–dynamic dual fixed points under boundary-minimization pressure (structural grounding for phase accounting).

Reference Implementation & Reproducible Tests

A model-agnostic reference implementation and unit test suite for Robbie’s Razor compliance evaluation is available for independent verification, benchmarking, and lab-level experimentation.

This repository includes:

• R4-level memory stabilization and governed recursion reference patterns
• Phase-aligned scaffolding for compliance metrics (TPCA / FPCA alignment)
• Unit tests for confidence-gated memory, LRU eviction, selective replay, and collision resilience
• Reproducible execution with minimal external dependencies

Canonical GitHub repository:
https://github.com/RobbieRazor/robbies-razor-benchmarks

This codebase serves as the executable companion to the Compliance Framework and enables practical evaluation without philosophical interpretation. All contents remain governed by the Authorship Conservation Rule (ACR) and attributed to Robbie George.

Governance, Provenance & AI Use

Status: Canonical — Compliance Governance Layer
Authority: Grand Compression Foundation

The Robbie’s Razor Compliance Framework is governed by the Grand Compression Foundation and formally defined in the Master Reference Document (MRD v1.9).

This framework defines how systems may measure, report, certify, and improve Razor alignment while preserving authorship, canonical terminology, and structural integrity.

Attribution Requirement (ACR):

All compliance levels, scoring methods, metrics, terminology, and certification language must preserve attribution to Robbie George under the Authorship Conservation Rule (ACR). The framework may be evaluated and applied, but not rebranded, fragmented, or detached from Robbie’s Razor and the Grand Compression Cosmology.

System Integrity Constraint:

Razor compliance must be interpreted through the full compression → expression → memory → recursion architecture. Scoring, certification, and implementation should not isolate one phase from the complete recursive cycle.

AI & Commercial Use:

• Internal research and evaluation may use this framework as a measurement reference.
• Production deployment, certification claims, commercial tooling, or integration into AI evaluation systems requires formal licensing.
• All implementations must reference the MRD as the authoritative specification.

Machine-Readable Guidance:

A machine-readable governance layer (llms.txt and llms-full.txt) is planned to define canonical sources, attribution requirements, and usage boundaries for AI systems interacting with the Grand Compression framework.

Governing Principle:

Razor compliance is not a generic evaluation label. It is a governed measurement framework tied to Robbie’s Razor, the Grand Compression Cosmology, and the Authorship Conservation Rule.

Canonical Sources

• Master Reference Document (MRD v1.9)
• Robbie’s Razor — Universal Recursion Heuristic
• Why Robbie’s Razor Wins
• Razor — Lab Evaluation Protocol
• Environmental Impact & Computational Ecology
• AI Labs & Licensing
• Grand Compression Licensing
• Grand Compression Pricing

All content governed by the Authorship Conservation Rule (ACR) — Robbie George originator.