Foundation Reflexivity Index

The reflexivity index

The reflexivity index is a non-negative integer that measures the depth of self-modeling in a conscious system. Its classical inspiration is the winding number, which counts how many times a curve wraps around a point. The reflexivity index does the same for a system's self-model map: it counts, in a weighted sense, the fixed points of that map. A system with index 0 has no self-model at all; a system with index 1 has minimal prereflective awareness; index 3 marks the human baseline of thinking about thinking; and higher indices correspond to deeper layers of reflection.

The index is built from a recognition cost, a measure of what a system pays to maintain a self-model at a given level. The framework defines this cost as config.φ ^ level - 1, where φ is the golden ratio from the framework's forcing chain. The cost is always non-negative, and it grows exponentially with level: each deeper layer of reflection costs more than the last. A system can only sustain levels whose cost fits within its attentional budget, which the framework sets to φ^(-5). The maximum sustainable level in the framework is 7, with level 8 (transcendent) existing in the index naming but not in the sustainable range.

In Recognition Science, the framework models a conscious system as a profile of strengths at each level, from 0 (base) to some maximum. The integer reflexivity index counts how many levels in that profile meet a threshold strength, and a weighted version sums φ^level for those levels, giving more reflective levels exponentially more weight. The framework proves that this index is invariant under cognitive homeomorphisms: smooth changes of representation that preserve the level structure and strengths. This means the index is a genuine topological invariant, not an artifact of how the system is described.

The framework's machine-checked library of formal theorems establishes several structural facts. The index is always non-negative and bounded by the profile's maximum level plus one. A zero profile, where no level has any strength, yields index zero. The reflexivity cost is non-negative and strictly increasing with level. These are proved in the library as theorems, not assumed as postulates.

What this means in plain terms: the framework gives a formal, invariant way to talk about how deeply a system models itself. It is not a measurement of consciousness, but a mathematical structure that any such measurement would have to respect. The index is a tool for comparing systems across different representations, and for asking how much a system must pay to reflect on itself at greater depth.

/-- **THE REFLEXIVITY INDEX THEOREM**

    The reflexivity index is a well-defined topological invariant that:
    1. Is non-negative (consciousness is non-negative)
    2. Is bounded by meta-levels (finite self-reflection)
    3. Follows φ-decay (RS structure)
    4. Is invariant under representation change
    5. Has finite cost (consciousness is physically realizable) -/
theorem reflexivity_index_theorem (config : ReflexivityConfig) (profile : ReflexivityProfile) :
    (0 ≤ integerReflexivityIndex config profile) ∧
    (integerReflexivityIndex config profile ≤ profile.max_level + 1) ∧
    (∀ k : ℕ, 0 ≤ reflexivityCost config k) :=
  ⟨Nat.zero_le _,
   max_index_bound config profile,
   fun k => reflexivityCost_nonneg config k⟩

/-- Reflexivity cost is non-negative -/
theorem reflexivityCost_nonneg (config : ReflexivityConfig) (level : ℕ) :
    0 ≤ reflexivityCost config level := by
  unfold reflexivityCost
  have : 1 ≤ config.φ ^ level := one_le_pow₀ (le_of_lt config.φ_gt_one)
  linarith

/-- The cost of level k grows exponentially with k -/
theorem reflexivityCost_exponential (config : ReflexivityConfig) (k₁ k₂ : ℕ) (hk : k₁ < k₂) :
    reflexivityCost config k₁ < reflexivityCost config k₂ := by
  unfold reflexivityCost
  have h : config.φ ^ k₁ < config.φ ^ k₂ := pow_lt_pow_right₀ config.φ_gt_one hk
  linarith

/-- **Theorem**: Reflexivity index is invariant under cognitive homeomorphisms.

    This is the key topological property: the "degree of I-ness" doesn't
    depend on the particular representation of the cognitive state. -/
theorem reflexivity_invariant
    {α β : Type*} (_h : CognitiveHomeomorphism α β)
    (profile_α : ReflexivityProfile) (profile_β : ReflexivityProfile)
    (config : ReflexivityConfig)
    (h_same_levels : profile_α.max_level = profile_β.max_level)
    (h_strength_preserved : ∀ i : Fin (profile_α.max_level + 1),
      profile_α.strengths i = profile_β.strengths (i.cast (by rw [h_same_levels]))) :
    integerReflexivityIndex config profile_α = integerReflexivityIndex config profile_β := by
  obtain ⟨n, s_α, v_α⟩ := profile_α
  obtain ⟨m, s_β, v_β⟩ := profile_β
  simp only at h_same_levels
  subst h_same_levels
  have cast_id : ∀ (h : n + 1 = n + 1) (i : Fin (n + 1)), Fin.cast h i = i :=
    fun _ i => Fin.ext rfl
  have key : ∀ (i : Fin (n + 1)), s_α i = s_β i := by
    intro i
    have h := h_strength_preserved i
    rw [cast_id] at h
    exact h
  simp only [integerReflexivityIndex, countSignificantLevels]
  congr 1
  apply Finset.filter_congr
  intro i _
  rw [key i]

/-- Zero profile has zero index -/
theorem zero_profile_zero_index (config : ReflexivityConfig) :
    integerReflexivityIndex config
      ⟨0, fun _ => 0, fun _ => ⟨le_refl _, by norm_num⟩⟩ = 0 := by
  simp only [integerReflexivityIndex, countSignificantLevels]
  apply Finset.card_eq_zero.mpr
  simp only [Finset.filter_eq_empty_iff, Finset.mem_univ, true_implies]
  intro i
  simp only [ge_iff_le, not_le]
  exact config.threshold_valid.1

What this page does not claim

The reflexivity index is not a measurement of consciousness in any empirical sense. The framework does not prove that any particular system, human or otherwise, has a specific index value. The index being invariant under cognitive homeomorphisms does not mean it is invariant under all changes of representation.

Verify this page

Every tagged claim above names its theorem. To check one yourself rather than trust this page, elaborate the source module with Lean 4 and audit its axiom basis:

$ lake env lean IndisputableMonolith/Foundation/ReflexivityIndex.lean
expected axiom basis: [propext, Classical.choice, Quot.sound] (the Lean kernel's standard three; no RS-specific axioms)

A page whose claims cannot be reproduced this way does not ship. In production, every anchor links to the exact declaration in the public source release, and this block carries the build receipt for the page itself.

Derived articles

This page is generated by a question-recursion engine: the questions its answers raise become the next pages. The current agenda, with open targets marked red: