---
slug: metanorm
name: Metanorm
one_liner: "A second-order norm that sanctions those who fail to sanction first-order violators: a norm governing the enforcement of norms, whose target is the non-punisher rather than the original offender, so that enforcement can be sustained even when first-order sanctioning has decayed."
type: prime
schema_version: 2
status: density_v2_draft
categories: [structural, social, computational]
origin_domain: game_theory
alternate_origin_domains: [evolutionary_biology, law, institutional_economics, distributed_systems]
aliases: [second_order_punishment, enforcement_of_enforcement, punishing_the_non_punisher, norm_to_enforce_norms, meta_level_sanction]
related: []
solution_archetypes: []
review_flags:
- "OPERATOR-DERIVED (op-02 self-application, route M / machinery) — the SECOND-ORDER prime obtained by applying `normativity` to itself: a norm governing the ENFORCEMENT of norms, sanctioning those who fail to sanction first-order violators. Discovered in the op-02 pilot+sweep 2026-07-03. STRONG hold (verified absent from corpus; established named construct — Axelrod 1986, 'An Evolutionary Approach to Norms', APSR). CONVERGENCE ×3-4: independently reached from `normativity`, `informal_enforcement`, `tolerance_paradox` ('enforcement of enforcement'), and `accountability` — the single strongest op-02 convergence after second_order_preference. STATUS: HOLD pending owner keep/cut."
- "Created 2026-07-03; STUB ONLY (frontmatter + Core Idea + Notes). SI/SF/similarity are PROPOSER ESTIMATES pending triangulation. Body sections (Structural Signature onward) NOT written."
- "Phase-C action: re-similarity-check vs `normativity` (the input / parent) and `mandatory_vs_default_norms`, `informal_enforcement`, `accountability`, `second_order_cybernetics`; confirm it is the genuine second-order lift (the non-enforcer as a NEW sanction target the base norm never touches) and not a restatement of `normativity` or `informal_enforcement`; resolve whether it is atomic or a self-composition of `normativity` (Axelrod's separate treatment argues atomic); draw a subsumption edge normativity→metanorm at incorporation; write a v1 draft and sync the one_liner across v1/v2 per CLAUDE.md before merge."
substrate_independence:
  composite_substrate_independence: 4
  domain_breadth: 5
  structural_abstraction: 4
  transfer_evidence: 4
  reasoning: 'The bare structure — a compliance system with a first-order norm (do X, or be sanctioned) topped by a second-order norm whose target is not the original violator but the party who FAILED to sanction that violator — is a genuinely substrate-neutral second-order form. It recurs wherever a compliance system must sustain its own enforcement: evolutionary models of cooperation (Axelrod''s metanorm game; altruistic punishment of non-punishers), law (sanctions for officials who fail to enforce; dereliction-of-duty liability), reputation systems (downranking those who do not downrank cheaters), organizational compliance regimes, and distributed-systems accountability (nodes penalized for not policing peer misbehavior). These are structurally-unlike siblings sharing only the abstract enforcement-of-enforcement layer, so domain_breadth scores 5. Structural abstraction is 4 because the core is a pure statement about a level-2 sanction target (the non-enforcer) distinct from the level-1 target (the original violator), requiring no social substance to hold; it stays just short of 5 because the framing still leans on the vocabulary of "sanction," "violation," and "cost of enforcing," a mild normative/evaluative residue. Transfer evidence is strong (canonical named construct — Axelrod 1986 — with independent instantiations across game theory, law, and reputation systems).'
similarity_to_nearest_existing_prime:
  slug: normativity
  similarity: 0.58
structural_framed:
  label: structural
  aggregate: 0.35
  criteria: {vocab_travels: 0.7, evaluative_weight: 0.35, institutional_origin: 0.25, human_practice_bound: 0.25, import_vs_recognize: 0.4}
  rationale: 'Reads structural. The core claim — a second enforcement layer whose sanction target is the non-punisher rather than the original violator — is recognized rather than imported, and travels cleanly into evolutionary-game models, reputation systems, and distributed-systems accountability without carrying legal or moral vocabulary. The frame residue is light: "sanction," "violation," and "enforcement cost" import a mild normative/evaluative cast (keeping evaluative_weight and import_vs_recognize off the floor), but the underlying second-order structure — a distinction between punishing the offense and punishing the failure to punish it — is substrate-neutral and solves a purely structural problem (the second-order free-rider problem). Lower framing than the surrounding framed-stratum candidates; comparable to its parent `normativity`.'
phase_b_passes_completed: []
---
# Metanorm

## Core Idea

A metanorm is a *second-order* norm: it sanctions not the original violator but the party who failed to sanction that violator. Base-level `normativity` runs a single loop — a rule ("do X"), a class of violations, and a sanction applied to violators. A metanorm lifts that loop one level: it applies a norm to the *enforcement* of the first-order norm, sanctioning those who stand by while a first-order violation goes unpunished. It is reached from `normativity` by applying normativity to itself — a norm governing the enforcement of norms — and the feature it introduces is a sanction target the base norm never names: the *non-punisher*.

The load-bearing anatomy is a distinction the base engine cannot express. In a plain norm there are only two roles — complier and violator — and enforcement is a fixed background: someone sanctions violators, or no one does. But enforcement is itself costly, which surfaces a *second-order free-rider problem*: even actors who want the norm upheld would rather let someone else bear the cost of sanctioning, so first-order enforcement is individually irrational and tends to decay. The metanorm makes the *act of enforcement* itself normatively obligatory, and makes the *failure to enforce* itself a sanctionable violation. This is precisely the level-2 target absent at the base: the non-enforcer is a party the first-order norm has no vocabulary for, because within a single norm the enforcement channel is a fixed background, not a thing that can itself be complied with or violated. Lift the norm up one level and that background becomes the foreground — enforcement is now the behavior that is required, monitored, and sanctioned. This is what sustains cooperation when first-order sanctioning would otherwise collapse: the second enforcement layer can keep operating even after the first has eroded.

Read structurally, the same enforcement-of-enforcement shape appears wherever a compliance system must sustain its own enforcement, and the siblings are genuinely unlike. In *evolutionary models of cooperation*, it is Axelrod's metanorm and Fehr & Gächter's altruistic punishment — cooperation is stabilized only when non-punishers are themselves punished. In *law*, it is the sanction attached to officials who fail to enforce (dereliction of duty, liability for non-enforcement) — the target is the enforcer, not the original offender. In *reputation systems*, it is the downranking of those who fail to downrank cheaters, sustaining a moderation regime that would otherwise free-ride into apathy. In *distributed-systems accountability*, it is nodes penalized not for their own misbehavior but for failing to police a peer's. Across these, the shared abstract engine is a two-layer sanction structure whose upper layer targets the non-enforcer; the social/legal case is one species of the genus, and the structurally-unlike siblings show the genus is the bare second-order structure.

## Notes

**Provenance.** Produced by operator 02 (self-application), route M (machinery), as the second-order prime obtained by applying `normativity` to itself — a norm governing the enforcement of norms, whose sanction target is the non-punisher rather than the first-order violator. Surfaced in the op-02 self-application pilot and sweep on 2026-07-03. Established named construct: Robert Axelrod 1986, "An Evolutionary Approach to Norms" (APSR), which introduces the *metanorm* explicitly; related literature on second-order punishment and altruistic punishment (Fehr & Gächter). **Strong ×3-4 convergence** — the same prime was reached independently from four inputs: `normativity` (self-application), `informal_enforcement`, `tolerance_paradox` (as "enforcement of enforcement"), and `accountability`. This is the single strongest convergence in the op-02 run after second_order_preference, and is the primary reason for the STRONG hold. Verified absent from the corpus. Manifest: STRONG hold.

**For owner evaluation (keep/cut).** The case FOR is strong: metanorm is a *canonical, named construct* (Axelrod 1986), verified absent, with a clean second-order anatomy — the non-punisher as a NEW sanction target distinct from the original violator — that solves a real problem the base norm cannot express (the second-order free-rider problem: who enforces the enforcers?). Its 3-4-route convergence is the strongest structural signal in the sweep. The RISKS Kurt should weigh: (1) **overlap with `normativity` and `informal_enforcement`** — the discriminating claim is that the metanorm's target is the *non-enforcer*, a party the base norm never sanctions; `normativity` names the first-order rule-and-sanction loop, `informal_enforcement` names the mechanism by which sanctions are delivered, but neither makes the *failure to enforce* itself a violation, so this is a genuine level-2 lift, not a restatement. (2) **Atomicity** — whether metanorm is atomic or merely a self-composition of `normativity` applied to its own enforcement; Axelrod's separate, explicit treatment of the metanorm game (distinct dynamics, distinct stability results from the base norm game) argues it is atomic and worth a node of its own. Sharp keep/cut question: *is "a norm that punishes the failure to punish" a distinct prime, or just `normativity` pointed at enforcement behavior?* — the proposer's answer is that the non-enforcer-as-sanction-target, together with the second-order free-rider problem it uniquely solves, is a level-2 feature the base loop lacks.

**At incorporation.** Re-run similarity against `normativity` (input / parent), `mandatory_vs_default_norms`, `informal_enforcement`, `accountability`, and `second_order_cybernetics` (a different self-application family — screen for confusion) to confirm no collapse. If kept: draw a subsumption edge `normativity` → `metanorm`, and note the convergence sources (`informal_enforcement`, `tolerance_paradox`, `accountability`) as candidate related/sibling edges — each reached this prime, so each may warrant an edge or a missing-edge flag. Add a missing-edge note flagging the `informal_enforcement` (mechanism-of-enforcement) and `accountability` (who-answers-for-what) relationships explicitly. Write a v1 draft and sync the one_liner across v1 and v2 per CLAUDE.md before merge.
