INV-031 — No New Operator Primitives Without Necessity

1. Definition

Do not add new operator primitives when an existing operator, diagnostic, gate, lens, regime, failure mode, law, scaling rule, or restoration arc can carry the function.

An operator primitive is a foundational state-transforming action within UTS.

Because operators define how systems change, adding a new operator primitive expands the ontology of the whole framework.

Therefore:

No new operator primitives without necessity.

New concepts should first be tested as:

composition of existing operators
parameterization of existing operators
diagnostic
gate
lens
regime
failure mode
law
scaling rule
restoration arc
domain expression

Only if none of these can hold the function should a new operator primitive be considered.

2. Purpose

This invariant protects UTS from ontology bloat.

It prevents the error:

This pattern is important,
therefore it needs a new operator.

The correct UTS interpretation is:

This pattern is important.
Now test whether it is an operator, diagnostic, gate, lens, regime, law,
scaling rule, failure mode, restoration arc, or domain expression.

Operators should remain few, powerful, and reusable.

If every important concept becomes an operator, the system loses:

• portability
• auditability
• teaching clarity
• machine readability
• cross-module compatibility
• symbolic precision
• canonical stability
• operator discipline
• state-transform clarity

This invariant ensures that UTS can expand without fragmenting.

3. Constraint Statement

Canonical Form

No new operator primitives without necessity.

Expanded Form

A new operator primitive may be introduced only if the concept performs a
distinct state transformation that cannot be expressed through existing
operators, diagnostics, gates, lenses, regimes, laws, scaling rules, failure
modes, restoration arcs, or domain-specific expressions.

Minimal Expression

Do not multiply operators unnecessarily.

Operator Discipline Form

New concept ≠ new operator by default.

Ontology Form

Preserve operator compression before expanding primitives.

Registry Form

Classify before canonizing.

AI Form

Do not create new AI governance operators when existing UTS operators already describe the transformation.

Principles / Archetypes Form

Principles and archetypes must reduce to existing operators before being treated as new primitives.

4. Structural Logic

Operators are high-level transformation primitives.

They describe how state changes.

Because they sit near the root of the UTS architecture, each new operator affects every downstream module.

A new operator changes the grammar of:

• diagnostics
• gates
• laws
• scaling rules
• restoration arcs
• module pages
• AI-readable structures
• machine schemas
• symbolic maps
• cross-domain translation
• future teaching systems

Therefore, operator creation must be conservative.

The incoherent sequence is:

new pattern appears
        ↓
pattern feels important
        ↓
new operator is created
        ↓
operator registry expands
        ↓
overlap with existing operators appears
        ↓
auditability decreases
        ↓
cross-module compatibility weakens
        ↓
ontology bloat rises

The coherent sequence is:

new pattern appears
        ↓
classify function
        ↓
test against existing operators
        ↓
test as diagnostic / gate / lens / regime / law / failure / restoration arc
        ↓
if reducible, integrate without new primitive
        ↓
if irreducible and state-transforming, consider candidate operator
        ↓
stress-test before canonization

This invariant keeps the operator layer stable while allowing the rest of the system to grow.

5. State-Vector Impact

Protected State Variables

Au  — auditability
K   — compatibility
O   — coherence
µᵢ  — meaning / agent integrity
BΣ  — boundary integrity of the canon
R   — restoration capacity for ontology drift

Primary Risk Variables

H   — hidden debt from overlapping primitives
ι   — inversion when conceptual expansion appears like precision but reduces coherence
ε   — confusion, contradiction, duplicated logic, or implementation error
Φ   — local expressive gain / novelty / elegance proxy

Healthy Operator Discipline Pattern

new concept appears
classification performed
existing operators tested
no unnecessary primitive added
Au↑ or stable
K↑ or stable
O preserved

Violation Pattern

new concept appears
new operator created prematurely
overlap increases
Au↓
K↓
H↑
ε↑
O↓

Ontology Bloat Pattern

conceptual richness↑
primitive count↑
operator overlap↑
machine readability↓
teaching clarity↓

The central danger is not conceptual expansion.

The danger is primitive inflation.

6. U-Layer Localization

Primary Layer

U4 — Classification / Metrics

This invariant primarily governs classification of new concepts: operator, diagnostic, gate, lens, regime, law, scaling rule, failure mode, restoration arc, or domain expression.

Canon / Boundary Layer

U2 — Configuration / Boundaries

The operator registry is a canonical boundary. Adding primitives changes the grammar of the whole system.

Coherence Field Layer

U6 — Coherence Field

Ontology bloat degrades cross-module coherence.

Memory Layer

U7 — Memory / Recurrence

Once a new operator enters memory, it becomes harder to remove. The registry accumulates precedent.

Time Layer

U5 — Coordination / Time

New primitives should be time-tested across modules before canonization.

Execution Layer

U3 — Execution

Operator definitions affect practical use, implementation, machine schemas, and decision logic.

Resource Layer

U1 — Power / Budgets

More primitives increase maintenance, teaching, documentation, and implementation burden.

Common Failure Pattern

new concept emerges
        ↓
U4 misclassifies it as operator
        ↓
U2 canon boundary expands
        ↓
U7 memory preserves overlap
        ↓
cross-module K declines
        ↓
Au declines
        ↓
H accumulates in ontology

Common Misdiagnosis

Violation of this invariant is often misdiagnosed as:

• precision
• richness
• innovation
• refinement
• symbolic depth
• technical depth
• module expansion
• expressive power
• necessary complexity
• new discovery
• better vocabulary

The deeper issue may be:

The concept was important, but it was not a new operator primitive.

7. Violation Signatures

7.1 Operator Created for a Diagnostic

A new primitive is added for something that only reads state.

state reading appears
        ↓
operator created
        ↓
diagnostic / operator boundary blurred

Example:

Bandwidth, damping, slack, or attention capacity are diagnostics,
not operators, unless they transform state directly.

7.2 Operator Created for a Gate

A new primitive is added for an admissibility check.

admissibility logic appears
        ↓
operator created
        ↓
gate / operator boundary blurred

Gates decide whether action is admissible. Operators change state.

7.3 Operator Created for a Lens

A new primitive is added for a perspective or analysis view.

viewing frame appears
        ↓
operator created
        ↓
lens / operator boundary blurred

A lens organizes perception. It does not necessarily transform the system.

7.4 Operator Created for a Regime

A new primitive is added for an operating mode.

mode detected
        ↓
operator created
        ↓
regime / operator boundary blurred

A regime describes conditions of operation. It is not automatically an operator.

7.5 Operator Created for a Failure Mode

A named failure pattern is treated as a primitive transformation.

failure mode named
        ↓
operator created
        ↓
failure / operator boundary blurred

Failure modes describe collapse pathways. Operators describe state transformation.

7.6 Symbolic Term Becomes Primitive Too Quickly

A powerful symbolic term is added as a primitive before reduction.

symbolic resonance↑
operator discipline↓
ontology bloat↑

7.7 Domain Expression Becomes Universal Primitive

A domain-specific concept is elevated to a universal operator without cross-domain proof.

domain pattern appears
        ↓
universal operator declared
        ↓
translation debt↑

7.8 Existing Operator Composition Ignored

A new primitive is created even though the function can be expressed through existing operators.

existing composition available
        ↓
new operator added
        ↓
redundancy↑

Example:

Many complex actions can be expressed as Π + Γ + Μ + Τ + ℛ + Σ
rather than a new primitive.

8. Related Failure Modes

Primary related failure modes:

• Ontology Bloat
• Primitive Inflation
• Operator Drift
• Canon Drift
• Registry Redundancy
• Classification Error
• Diagnostic / Operator Confusion
• Gate / Operator Confusion
• Lens / Operator Confusion
• Regime / Operator Confusion
• Symbolic Over-Primitive Drift
• Domain Overgeneralization
• Machine Schema Fragility
• Teaching Complexity Inflation
• Module Drift
• Auditability Collapse
• Compatibility Collapse
• Terminology Saturation
• Redundant Construct Growth

9. Related Restoration Arcs

Primary restoration arcs:

• Operator Discipline Restoration
• Ontology Compression
• Primitive De-Duplication
• Registry Reclassification
• Canon Boundary Repair
• Cross-Module Alignment
• Glossary Clarification
• Diagnostic Reclassification
• Gate Reclassification
• Lens Reclassification
• Regime Reclassification
• Machine Schema Cleanup
• Temporal Revalidation
• Meaning Reintegration
• Construct Consolidation

Restoration Requirement

A suspected primitive must be reclassified through the registry stack before canonization.

Minimal sequence:

Identify candidate primitive
        ↓
Describe exact state transformation
        ↓
Test against existing operators
        ↓
Test as diagnostic / gate / lens / regime / law / scaling rule / failure / restoration arc
        ↓
If reducible, classify accordingly
        ↓
If irreducible, mark as candidate only
        ↓
Stress-test across modules
        ↓
Canonize only after non-redundancy is proven

10. Domain Expressions

AI

AI governance produces many tempting operator-like concepts:

• alignment
• moderation
• refusal
• steering
• personalization
• memory update
• representation
• agent delegation
• safety filtering
• epistemic shaping
• redirection
• intervention

Most should not become new UTS operators.

They should be mapped through existing operators first.

Example:

AI refusal = Π + Γ + Σ + possibly ℛ

AI memory update = Μ + Τ + Σ + ℛ depending on context

AI alignment process = Γ + Π + Θ + Λ + Τ + ℛ + Σ

The AI domain should extend UTS through schemas, gates, diagnostics, and domain expressions before proposing new primitives.

AI Governance

AI governance often introduces terms that sound primitive:

• recognition
• stewardship
• claimancy
• epistemic neutrality
• representation
• appeal
• restoration junction
• guardrail
• cognitive infrastructure

These are usually not new operators.

They are often:

gates
interfaces
constructs
regimes
protocols
restoration arcs
diagnostics
domain expressions

This invariant protects AI governance from becoming a separate ontology disconnected from the core UTS operator grammar.

Governance / JGL

Governance concepts such as justice, legitimacy, authority, representation, appeal, accountability, and due process should not automatically become operators.

They often map as:

justice = restoration + truth + consequence symmetry + recurrence prevention
legitimacy = coherence under audit and recognition
appeal = audit / restoration pathway
authority = constrained action capacity

These are constructs, gates, diagnostics, or restoration arcs unless a distinct state transformation is proven.

Security

Security concepts such as containment, quarantine, hardening, monitoring, enforcement, threat detection, and access control may feel operator-like.

They usually reduce to:

Π — constrain
Γ — select response
Ξ — detect inversion / threat mismatch
Μ — interpret
Σ — preserve boundary
ℛ — restore
Τ — track over time

Security should add gates and protocols before adding operators.

Economy

Economic concepts such as circulation, exchange, pricing, profit, allocation, contract, debt, and investment should not become new operators by default.

They often map to:

⊗ — exchange / coupling
Γ — selection / allocation
Π — constraint
Τ — trajectory
ℛ — repair / reinvestment
Μ — valuation / interpretation
Σ — boundary / contract invariants

Economy can introduce diagnostics and laws without expanding operator primitives.

Biology / Medicine

Biological concepts such as healing, regulation, adaptation, inflammation, metabolism, repair, tolerance, activation, and suppression should not automatically become UTS operators.

They are usually domain expressions of:

ℛ — repair / restore
Π — constrain / regulate
Γ — select response
Τ — temporal trajectory
Μ — signal interpretation
Σ — boundary integrity
⊗ — coupling / exchange
Δ — perturbation

Biology may introduce domain-specific diagnostics without requiring new UTS operators.

CMS / Meaning

Meaning concepts such as insight, revelation, discernment, embodiment, symbolism, shadow, integration, devotion, and initiation may feel primitive.

Within UTS they should first reduce to:

Μ — sensemaking / interpretation
Θ — humility / uncertainty damping
Σ — invariant / sacred boundary
Τ — trajectory / timing
ℛ — integration / restoration
Ξ — inversion detection
Ψ — presence / attention

Meaning can remain rich without becoming operator-bloated.

Principles / Archetypes

Principles and archetypes are especially prone to primitive inflation.

A principle is not usually a new operator.

An archetype is not usually a new operator.

They are often:

constraint fields
role geometries
compositions of operators
state-vector patterns
lenses
regimes
diagnostic maps
restoration pathways

Example:

Protector ≈ Σ + Π + Ψ + Θ + ℛ under bounded scope

Healer ≈ ℛ + Μ + Ψ + Θ + Σ

The archetype may be canonically important without becoming an operator primitive.

11. Scaling Behavior

As the project scales, operator discipline becomes more important.

Why

At larger scale:

• more modules generate new terms
• domain-specific concepts multiply
• symbolic frameworks expand
• AI-readable schemas require stability
• teaching burden grows
• construct graphs become harder to maintain
• duplicate terms become harder to detect
• local terminology begins drifting
• registry cross-links become fragile
• automation becomes more sensitive to inconsistent primitives

Scaling Pattern

Project scale↑
        ↓
concept volume↑
        ↓
primitive inflation temptation↑
        ↓
operator overlap↑
        ↓
audit burden↑
        ↓
canon drift risk↑

Scaling Rule Connection

Scale↑ ⇒ operator discipline requirement↑
Scale↑ ⇒ registry reclassification burden↑
Scale↑ ⇒ canonical primitive count should remain stable
Scale↑ ⇒ domain expressions should increase before primitives increase
Scale↑ ⇒ machine schemas require primitive compression

Therefore, high-scale UTS development requires stronger:

Au
K
BΣ
Θ
Μ
Σ
Π
registry governance
canon review
primitive de-duplication
machine-readable schemas

12. Canonical Examples

Example 1 — “Alignment” as Operator

A team proposes Alignment as a new operator.

UTS check:

Does alignment transform state directly,
or is it an outcome / diagnostic / regime / construct?

Likely decomposition:

alignment process = Γ + Π + Θ + Λ + Τ + ℛ + Σ

So it is not a new primitive by default.

Example 2 — “Justice” as Operator

Justice is essential, but not necessarily an operator primitive.

Likely UTS classification:

justice = restoration system + legitimacy condition + consequence symmetry + recurrence prevention

It may be a construct, module, law family, or restoration architecture.

Not automatically a primitive operator.

Example 3 — “Healing” as Operator

Healing is domain-important, but within UTS it usually maps to:

ℛ — restoration
Τ — trajectory
Μ — interpretation
Σ — boundary integrity

So “healing” may be a domain expression of restoration rather than a new operator.

Example 4 — “Protection” as Operator

Protection may feel primitive.

But it can often be expressed through:

Σ + Π + Ψ + Θ + Γ

Protection is usually an archetypal / security function, not a new primitive.

Example 5 — “Moderation” as AI Operator

Moderation is not a UTS primitive.

It is likely a protocol combining:

Μ + Γ + Π + Σ + ℛ + Τ

with gates around FI, HR, Au, and appeal access.

Example 6 — “Circulation” as Economy Operator

Circulation is foundational in economy, but often maps to:

⊗ + Τ + Γ + ℛ + Σ

It may be an economic law / construct / operating system, not a universal operator.

13. Anti-Patterns

Anti-Pattern 1 — “Important Means Primitive”

A concept can be important without being an operator.

Anti-Pattern 2 — “Symbolically Powerful Means Operator”

Symbolic density does not determine operator status.

Anti-Pattern 3 — “Every Module Needs Its Own Operators”

Modules should express domain patterns through shared operators wherever possible.

Anti-Pattern 4 — “New Term, New Primitive”

Most new terms belong in glossary, diagnostics, gates, laws, regimes, lenses, failure modes, or restoration arcs.

Anti-Pattern 5 — “Operators Are Just Fancy Labels”

Operators must transform state.

Anti-Pattern 6 — “If Existing Operators Need Composition, Add a New One”

Composition is expected. Not every repeated composition needs a new primitive.

Anti-Pattern 7 — “More Operators Mean More Precision”

Too many primitives can reduce precision by creating overlap.

14. Related Laws

This invariant connects strongly to:

• Ontology Compression Law
• No New Primitive Law
• Canon Drift Law
• Registry Boundary Law
• Classification Integrity Law
• Audit Burden Growth Law
• Complexity-Auditability Gap Law
• Symbolic Overreach Law
• Translation Fidelity Law
• Primitive Inflation Law
• Operator Compression Law
• Temporal Validation Law

15. Related Scaling Rules

Related scaling rules:

• Primitive Inflation Risk Under Scale
• Registry Maintenance Burden Growth
• Ontology Audit Burden Growth
• Machine Schema Fragility Under Primitive Growth
• Cross-Module Compatibility Burden Growth
• Terminology Saturation Under Scale
• Glossary Burden Growth
• Domain Expression Growth Before Primitive Growth
• Canon Review Requirement Under Scale
• Operator Count Stability Requirement
• Translation Fidelity Loss Under Scale

16. Related Gates

Relevant gates:

• Operator Primitive Gate
• Canon Admission Gate
• Registry Classification Gate
• No-New-Primitive Gate
• Diagnostic / Operator Separation Gate
• Gate / Operator Separation Gate
• Lens / Operator Separation Gate
• Regime / Operator Separation Gate
• Domain Translation Gate
• Machine Schema Integrity Gate
• Temporal Validation Gate
• Cross-Module Compatibility Gate

Gate Logic

A candidate operator fails the primitive-admission check when:

it does not perform a distinct state transformation

or when:

it can be expressed through existing operators

or when:

it is actually a diagnostic, gate, lens, regime, law, scaling rule,
failure mode, restoration arc, construct, or domain expression

or when:

it increases expressive novelty while reducing auditability or compatibility

or when:

it has not been stress-tested across modules and time

17. Related Operators

18. Machine-Readable Summary

id: UTS-INV-031
name: No New Operator Primitives Without Necessity
registry: UTS Invariants Registry
category: Operator Discipline Invariant / Ontology Integrity Invariant / Canon Safety Invariant
status: Draft-Integrated
version: 0.1

definition: >
  Do not add new operator primitives when an existing operator, diagnostic,
  gate, lens, regime, failure mode, law, scaling rule, restoration arc, or
  domain expression can carry the function.

constraint: >
  A new operator primitive may be introduced only if the concept performs a
  distinct state transformation that cannot be expressed through existing
  operators, diagnostics, gates, lenses, regimes, laws, scaling rules, failure
  modes, restoration arcs, or domain-specific expressions.

canonical_form:
  - "No new operator primitives without necessity"
  - "Do not multiply operators unnecessarily"
  - "New concept is not new operator by default"
  - "Preserve operator compression before expanding primitives"
  - "Classify before canonizing"

protects:
  - operator_discipline
  - ontology_integrity
  - canon_stability
  - auditability
  - cross_module_compatibility
  - machine_readability
  - teaching_clarity
  - symbolic_precision
  - registry_coherence

state_vector_effects_when_preserved:
  O: "preserved_through_operator_stability"
  H: "not_created_by_redundant_primitives"
  ε: "reduced_through_clear_classification"
  ι: "stable_or_decreasing"
  Au: "stable_or_increasing"
  µᵢ: "preserved_through_meaningful_construct_boundaries"
  BΣ: "canon_boundary_intact"
  K: "high_across_modules"
  R: "available_for_reclassification_if_needed"
  Φ: "expressive_novelty_not_misclassified_as_coherence"

state_vector_effects_when_violated:
  O: "decreasing_due_to_ontology_bloat"
  H: "increasing_from_overlap_and_maintenance_debt"
  ε: "increasing_as_confusion_or_contradiction"
  ι: "increasing_when_expansion_appears_like_precision_but_reduces_coherence"
  Au: "decreasing"
  µᵢ: "degraded_by_conceptual_saturation"
  BΣ: "canon_boundary_weakened"
  K: "decreasing_across_modules"
  R: "required_for_consolidation"
  Φ: "local_expressive_gain_or_novelty_dominant"

primary_u_layer: U4
canon_boundary_layer: U2
field_layer: U6
memory_layer: U7
time_layer: U5
execution_layer: U3
resource_layer: U1

violation_signatures:
  - operator_created_for_a_diagnostic
  - operator_created_for_a_gate
  - operator_created_for_a_lens
  - operator_created_for_a_regime
  - operator_created_for_a_failure_mode
  - symbolic_term_becomes_primitive_too_quickly
  - domain_expression_becomes_universal_primitive
  - existing_operator_composition_ignored

related_failure_modes:
  - Ontology Bloat
  - Primitive Inflation
  - Operator Drift
  - Canon Drift
  - Registry Redundancy
  - Classification Error
  - Diagnostic Operator Confusion
  - Gate Operator Confusion
  - Lens Operator Confusion
  - Regime Operator Confusion
  - Symbolic Over Primitive Drift
  - Domain Overgeneralization
  - Machine Schema Fragility
  - Teaching Complexity Inflation
  - Module Drift
  - Auditability Collapse
  - Compatibility Collapse
  - Terminology Saturation
  - Redundant Construct Growth

related_restoration_arcs:
  - Operator Discipline Restoration
  - Ontology Compression
  - Primitive De Duplication
  - Registry Reclassification
  - Canon Boundary Repair
  - Cross Module Alignment
  - Glossary Clarification
  - Diagnostic Reclassification
  - Gate Reclassification
  - Lens Reclassification
  - Regime Reclassification
  - Machine Schema Cleanup
  - Temporal Revalidation
  - Meaning Reintegration
  - Construct Consolidation

related_laws:
  - Ontology Compression Law
  - No New Primitive Law
  - Canon Drift Law
  - Registry Boundary Law
  - Classification Integrity Law
  - Audit Burden Growth Law
  - Complexity Auditability Gap Law
  - Symbolic Overreach Law
  - Translation Fidelity Law
  - Primitive Inflation Law
  - Operator Compression Law
  - Temporal Validation Law

related_scaling_rules:
  - Primitive Inflation Risk Under Scale
  - Registry Maintenance Burden Growth
  - Ontology Audit Burden Growth
  - Machine Schema Fragility Under Primitive Growth
  - Cross Module Compatibility Burden Growth
  - Terminology Saturation Under Scale
  - Glossary Burden Growth
  - Domain Expression Growth Before Primitive Growth
  - Canon Review Requirement Under Scale
  - Operator Count Stability Requirement
  - Translation Fidelity Loss Under Scale

related_gates:
  - Operator Primitive Gate
  - Canon Admission Gate
  - Registry Classification Gate
  - No New Primitive Gate
  - Diagnostic Operator Separation Gate
  - Gate Operator Separation Gate
  - Lens Operator Separation Gate
  - Regime Operator Separation Gate
  - Domain Translation Gate
  - Machine Schema Integrity Gate
  - Temporal Validation Gate
  - Cross Module Compatibility Gate

19. Compact Canon Statement

UTS-INV-031 states that no new operator primitives should be added without necessity. A new concept must first be tested as a composition or parameterization of existing operators, or as a diagnostic, gate, lens, regime, law, scaling rule, failure mode, restoration arc, construct, or domain expression. A new operator is admissible only if it performs a distinct state transformation that cannot be represented by the existing registry.

20. Short Reference Version

UTS-INV-031 — No New Operator Primitives Without Necessity

Important does not mean primitive.

Before adding a new operator, test whether the concept is:

operator composition
diagnostic
gate
lens
regime
law
scaling rule
failure mode
restoration arc
construct
domain expression

Core rule:

Classify before canonizing.

New operators are admitted only when they perform a distinct
state transformation that existing operators cannot express.