Aequator Cognitivus · CE-v1-frozen · 8 Channels · 3 Verdicts

Cognitive Equalizer

Non agens mensurat, sed structura. — Not the agent measures, but the structure.

A standalone module that externalises every agent-dependent decision point into frozen, verifiable structure. Same input + same contract → same verdict, regardless of which AI runs it.

The Spine — Every Evaluation Follows This Path

CONTRACT
freeze thresholds → CANON
5 words → CLOSURES
regime gates → LEDGER
debit/credit → STANCE
verdict

Omnia per spinam transeunt — Everything passes through the spine

Five Externalized Decision Points

1. Thresholds

Frozen — seam-derived, not chosen. ε=10⁻⁸, p=3, α=1.0, tol=0.005

2. Vocabulary

Five words only: Drift · Fidelity · Roughness · Return · Integrity

3. Conclusions

Three-valued: CONFORMANT / NONCONFORMANT / NON_EVALUABLE

4. Methodology

The Spine: Contract → Canon → Closures → Ledger → Stance

5. Ambiguity

NON_EVALUABLE — declared, never guessed away. Tertia via semper patet.

8 Evaluation Channels

Stance (Verdict)

—

Regime: — · Critical: —

Channel Radar

Full Spine Report

Implement the Cognitive Equalizer

The CE is a standalone, zero-dependency module that can be embedded in any system. Three implementations are available — each produces identical results because the contract is frozen: trans suturam congelatum.

🐍 Python

Full implementation with CLI, system prompt, Latin aliases. Part of the UMCP package.

pip install umcp from umcp.cognitive_equalizer import CognitiveEqualizer

📘 TypeScript

Browser-ready module. Same formulas, same frozen parameters, same verdicts. Zero dependencies.

import { engage } from './cognitive-equalizer'

📋 System Prompt

Paste into any AI chat to enable CE mode. No code required — the AI becomes the evaluator.

Download Source Files

🐍

cognitive_equalizer.py

Complete Python implementation — 930 lines, standalone, CLI, system prompt, Latin aliases

↓ .py 📘

cognitive-equalizer.ts

TypeScript module — browser-ready, same kernel, presets, formatting utilities

↓ .ts 📋

ce-system-prompt.txt

Standalone system prompt — paste into any AI to enable CE mode

↓ .txt

Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│                   COGNITIVE EQUALIZER                       │
│            Aequator Cognitivus — CE-v1-frozen               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  INPUT: 8 Channels ∈ [0, 1]                                │
│  ┌─────────┬──────────┬──────────────┬─────────────┐       │
│  │Relevance│ Accuracy │ Completeness │ Consistency │       │
│  ├─────────┼──────────┼──────────────┼─────────────┤       │
│  │Traceab. │ Grounded │ Constraint   │ Return Fid. │       │
│  └────┬────┴────┬─────┴──────┬───────┴──────┬──────┘       │
│       │         │            │              │               │
│       ▼         ▼            ▼              ▼               │
│  ┌──────────────────────────────────────────────────┐      │
│  │  TIER-1 KERNEL  (same formulas as Python + C)    │      │
│  │  F = Σ wᵢcᵢ    κ = Σ wᵢ ln(cᵢ,ε)              │      │
│  │  S = −Σ wᵢ h(cᵢ)   C = σ(c)/0.5               │      │
│  │  ω = 1−F       IC = exp(κ)      Δ = F−IC        │      │
│  └─────────────────────┬────────────────────────────┘      │
│                        │                                    │
│       ┌────────────────┼────────────────┐                  │
│       ▼                ▼                ▼                   │
│  ┌─────────┐   ┌──────────────┐  ┌───────────┐            │
│  │ REGIME  │   │    LEDGER    │  │   CANON   │            │
│  │ GATES   │   │  D_ω = Γ(ω) │  │ 5 Words:  │            │
│  │ Stable  │   │  D_C = α·C  │  │ Drift     │            │
│  │ Watch   │   │  Δκ balance  │  │ Fidelity  │            │
│  │ Collapse│   │  ≤ tol_seam  │  │ Roughness │            │
│  └────┬────┘   └──────┬───────┘  │ Return    │            │
│       │               │          │ Integrity │            │
│       ▼               ▼          └───────────┘            │
│  ┌──────────────────────────────────────────────────┐      │
│  │  VERDICT (three-valued — never boolean)          │      │
│  │  CONFORMANT · NONCONFORMANT · NON_EVALUABLE      │      │
│  └──────────────────────────────────────────────────┘      │
│                                                             │
│  Frozen: ε=1e-8  p=3  α=1.0  tol=0.005                    │
│  Trans suturam congelatum — same rules both sides.         │
└─────────────────────────────────────────────────────────────┘

Integration Examples

Python — Score an AI response

from umcp.cognitive_equalizer import CognitiveEqualizer, CEChannels

ce = CognitiveEqualizer()
channels = CEChannels(
    relevance=0.90, accuracy=0.85, completeness=0.80,
    consistency=0.95, traceability=0.70, groundedness=0.88,
    constraint_respect=0.92, return_fidelity=0.75,
)
report = ce.engage("Explain entropy", channels)
print(report.stance)           # CONFORMANT / NONCONFORMANT / NON_EVALUABLE
print(report.full_report())    # Full Spine report

TypeScript — Browser evaluation

import { engage, formatReport } from './cognitive-equalizer';

const report = engage({
  relevance: 0.90, accuracy: 0.85, completeness: 0.80,
  consistency: 0.95, traceability: 0.70, groundedness: 0.88,
  constraintRespect: 0.92, returnFidelity: 0.75,
});
console.log(report.stance);      // 'CONFORMANT'
console.log(formatReport(report)); // Full text report

CLI — Command line

# Score 8 channels directly
umcp-ce --channels 0.90,0.85,0.80,0.95,0.70,0.88,0.92,0.75

# Run built-in demo
umcp-ce --demo

# Print system prompt for embedding
umcp-ce --prompt

# Latin alias works too:
aequator-cognitivus --demo

Deep Explorations

Geometric Slaughter Lab

Trucidatio Geometrica — One dead channel kills multiplicative coherence

Drag the kill slider to zero. Watch how F (arithmetic mean) barely moves while IC (geometric mean) collapses to near-zero. The heterogeneity gap Δ = F − IC explodes. This is why averages lie and IC tells the truth.

Kill channel:

Kill value 0.50

0.00 (dead)0.501.00 (alive)

Other 7 channels fixed at 0.90

F (Fidelity) —

IC (Integrity) —

Δ (Gap) —

F vs IC Sweep (killed channel 0→1)

F (arithmetic) IC (geometric) Δ = F − IC current

⟷

Comparison Mode

Side-by-side evaluation — see how two responses differ structurally

Response A

Response B

Δκ

Integrity Ledger Deep Dive

Debit Drift + Roughness, credit Return — the account must reconcile

The ledger is the proof that the evaluation is well-formed. Every engagement debits D_ω = Γ(ω) = ω^p/(1−ω+ε) for drift and D_C = α·C for roughness. The balance Δκ = κ − D_ω − D_C must satisfy |Δκ| ≤ tol_seam for BALANCED status.

Drift Debit D_ω

—

Γ(ω) = ω³ / (1−ω+ε)

Roughness Debit D_C

—

α · C (α = 1.0 frozen)

Balance Δκ

—

|Δκ| ≤ 0.005

Γ(ω) Drift Cost Curve — the cost of collapse proximity

Γ(ω) = ω³/(1−ω+ε). Near ω=0 the cost is negligible; near ω=1 it diverges to ∞ (the pole). The frozen guard band ε = 10⁻⁸ prevents numerical singularity without affecting any measurement to machine precision. The cyan dot marks the current evaluation's ω.

↻

Session History

Continuitas Diachronica — Track your evaluations across this session

Each evaluation from the interactive panel is logged here. Watch the trajectory — is quality improving, stable, or degrading? Historia numquam rescribitur; sutura tantum additur.

No evaluations yet. Run the CE Spine above to start logging.

🗿

Rosetta Cross-Domain Lens

Significatio stabilis manet dum dialectus mutatur — meaning stays stable while dialect changes

The five CE words map identically across disciplines. The same evaluation produces different prose but identical structure in every lens. Select a lens to see how:

Word	CE Meaning	Epistemological Reading

∫

Mathematical Foundations

The exact formulas computed client-side — identical to Python and C implementations

Tier-1 Kernel (4 primitives + 2 derived)

F = Σ w_i c_i // fidelity — arithmetic mean

κ = Σ w_i ln(max(c_i, ε)) // log-integrity

S = −Σ w_i [c_i ln c_i + (1−c_i) ln(1−c_i)] // Bernoulli entropy

C = σ(c) / 0.5 // normalised curvature

ω = 1 − F // drift (derived)

IC = exp(κ) // integrity composite (derived)

Structural Identities (always true)

F + ω = 1 // duality identity

IC ≤ F // integrity bound

IC = exp(κ) // log-integrity relation

Seam Budget

D_ω = Γ(ω) = ω³ / (1 − ω + ε) // drift cost

D_C = α · C // curvature cost

Δκ = κ − D_ω − D_C // must ≤ tol_seam

Regime Gates (frozen)

Stable: ω < 0.038 ∧ F > 0.90 ∧ S < 0.15 ∧ C < 0.14

Watch: 0.038 ≤ ω < 0.30 (or gates not all met)

Collapse: ω ≥ 0.30

Critical: IC < 0.30 (overlay, any regime)

How It Works — FAQ

Plain-language answers to common questions

▶ What is the Cognitive Equalizer?

A mathematical protocol that evaluates AI responses using the same GCD kernel that analyses particle physics, atomic structure, and 21 other domains. It scores 8 dimensions of quality, computes structural invariants (fidelity, integrity, entropy, curvature), classifies the regime (Stable/Watch/Collapse), and derives a three-valued verdict. The key innovation: the verdict is derived from frozen structure, never asserted by the agent. Two different AIs, given the same channel scores, MUST produce the same verdict.

▶ Why IC (geometric mean) instead of F (arithmetic mean)?

Averages lie. A response can have high F = 0.83 (looks good!) while having IC = 0.001 (structurally obliterated) — because one channel is dead. IC uses the geometric mean which is dragged to zero by any single dead channel. This is geometric slaughter (trucidatio geometrica). The gap Δ = F − IC reveals the hidden structural weakness. Try the Slaughter Lab above to see this in action.

▶ What are the three verdicts?

CONFORMANT — the engagement passes all gates and the ledger balances. Quality is structurally verified.
NONCONFORMANT — either the regime is COLLAPSE (ω ≥ 0.30) or the seam budget is unbalanced. Structural failure detected.
NON_EVALUABLE — input is invalid or insufficient. The system refuses to guess — tertia via semper patet (the third way is always open). This is never boolean. There is always a third state.

▶ Why "frozen" parameters?

In traditional systems, thresholds are chosen by convention (p < 0.05, 3σ, etc.). In GCD, the parameters are discovered by the mathematics: p = 3 is the unique integer where the drift trap is a Cardano root of x³+x−1=0. ε = 10⁻⁸ is where the pole at ω=1 does not affect measurements to machine precision. tol_seam = 0.005 is where IC ≤ F holds at 100% across all 23 domains. These are trans suturam congelatum — frozen across the seam, consistent on both sides of every collapse-return boundary.

▶ Can I use this to evaluate ChatGPT / Claude / Gemini?

Yes — that's exactly what it's for. Three approaches:
1. Manual scoring — Read the AI's response, score the 8 channels yourself using the sliders above, and run the Spine.
2. System prompt — Paste the CE System Prompt into the AI, and it will self-audit using the protocol.
3. Programmatic — Use the Python SDK (pip install umcp) or TypeScript module to build automated evaluation pipelines. The same formulas run in all three approaches — trans suturam congelatum.

▶ How is this different from other AI evaluation frameworks?

Most frameworks use scoring rubrics that depend on human judgment or ML classifiers — the result varies with the evaluator. The CE is a cognitive equalizer: same channels + same contract → same verdict, regardless of agent. It uses the same kernel that measures particle physics confinement, atomic coherence, and consciousness — because quality has structure, and that structure is domain-independent. The five-stop Spine protocol, three-valued verdicts, and frozen thresholds eliminate evaluator variance by construction.

Aequator numquam dormit — The equalizer never sleeps.

GitHub Repository PyPI: pip install umcp