Terminology

Recursion, Recursive and Recurrent

People conflate four distinct things:

• Recursion (CS/math) -> self-call on smaller case with base case + decreasing measure.
• Recursive, Representational (RR) -> self appears as object in content; no control requirement.
• Recursive, Control (RC) -> self appears as process; self-estimates change policy.
• Recurrent (dynamics/process) -> stateful feedback over time; no self-model.

If no base case -> not recursion (CS).

If no self-as-object -> not RR.

If no self-estimates driving policy -> not RC.

If only state_{t+1}=F(state_t, input_t) -> recurrent.

1) The four meanings, cleanly split

Recursion (CS/math)

• Definition -> self-call on strictly smaller input + base case + well-founded measure.
• Example -> factorial, divide-and-conquer.
• Test -> show base case and the decreasing measure.

Recursive, Representational (RR)

• Definition -> the system represents itself as object (state/trait) in content. No control requirement.
• Form -> content tokens C_t about “me” present; policy ignores them.
• Test -> self-as-object present, but no (attention, confidence, pred_error) used to drive policy.

Recursive, Control (RC)

• Definition -> the system represents its own operations and computes on them to change behavior.
• Form -> s_{t+1}=F(x_t, s_t, Z_t) where Z_t=(attention, confidence, pred_error, policy_id); logs show Δpolicy caused by Z_t.
• Test -> outputs self-estimates -> explicit policy/attention/memory update.

Recurrent (dynamics)

• Definition -> next state depends on previous state/output; may loop forever; no self-model required.
• Form -> h_{t+1}=F(h_t, x_t).
• Test -> only state updates; no self tokens; no policy changes driven by self-estimates.

Heuristic: pronouns don’t prove recursion; policy updates from self-estimates do (RC).

2) Minimal ontology for self-inclusion

• Self-as-object -> explicit “me” content (state/trait).

Examples: “I am angry.” “I, Jan, am the one seeing.” “I believe that I believe p.”

• Self-as-process -> representation of my operations (attention, confidence, policy, prediction error) used for control.

Examples: “I monitor my attention.” “Confidence low -> switch policy.”

Mapping -> RR requires self-as-object. RC requires self-as-process + control change.

3) RSM ladder (operational)

• RSM-0 world-only: “Tree.” -> recurrent at most.
• RSM-1 first-order perception: “I see a tree.” -> index only; no self model.
• RSM-2 awareness-of-perceiving: “I am seeing a tree.” -> presence; not meta.
• RSM-3 awareness-of-seeing-as-state: “I am aware that I see a tree.” -> minimal self-as-object (weak RR).
• RSM-4 explicit self-as-object: “I notice myself being aware that I see a tree.” -> RR; clear “me,” no mechanism monitoring required.
• RSM-5 explicit self-as-process:

“I track my attention while noticing myself being aware of seeing a tree; confidence=0.6 and drifting -> adjust policy.” -> RC (meta-attention, meta-uncertainty, policy monitoring).

• RSM-6 social operator:

“I model your attention/identity hooks and steer them -> predict your confidence=0.3; reframe to raise it.” -> RC + ToM (own self-estimates still drive control).

• RSM-7+ operator default: continuous audit/edit of own operations -> RC defaulted.

Border cases -> quoting a number (e.g., “confidence=0.6”) without consequent action stays RR; action linked to it upgrades to RC.

4) Why “recursive” is misused online

• LLM mirroring -> type “recursive,” get recursive-sounding prose.
• “Reflect -> revise -> reflect” is recurrent unless self-estimates drive policy (RC).
• “I thought about thinking” remains narrative unless tied to operational variables (attention, confidence, error) that alter control.

Quick classification

1. Ask for base case + decreasing measure -> if absent, not recursion (CS).
2. Ask for self-as-object -> if absent, not RR.
3. Ask for attention/confidence/error and the policy change they trigger -> if absent, not RC.
4. If only state updates -> recurrent.

5) Instrumentation for real self-inclusion

• State vars -> attention_map, confidence, pred_error, policy_id, goal_stack.
• Update rule -> thresholds on pred_error↑ or confidence↓ trigger policy_id switch and attention reallocation.
• Logging -> every step prints (attention, confidence, error, policy_change, trigger, t).

No logs -> unverifiable -> slop.

6) Examples

Recurrent (not recursive)

“I describe the tree better each pass.”

• Iterations only; no self-estimates; no policy control.

RR (self-inclusion, representational)

“I notice myself being aware I see a tree. Confidence=0.6.”

• Self-as-object present; number not used -> no control change.

RC (self-inclusion, control)

“Confidence=0.42 on ‘there is a tree’. Error forecast high -> +20% attention to edges, switch to policy_3, defer conclusion.”

• Self-as-process present; behavior changes because of it.

Recursion (CS/math)

fact(n)=n*fact(n-1), base fact(0)=1.

• Self-call + base case + decreasing n.

7) Common failure modes

• Pronoun fallacy -> assuming “I” implies recursion.
• Reflection theater -> meta-sounding prose without operational variables.
• One-shot meta -> mentions confidence once, never used.
• ToM-only -> models others without modeling/controlling self.

8) How CIS uses the terms

• Recursion (CS/math) -> reserved for algorithms with base cases.
• RR -> self-as-object appears; no control claim.
• RC -> self-as-process used; logs show self-estimates -> policy/memory/attention updates.
• RSM-6 -> RC + ToM steering with logged intents/outcomes.
• Recurrent -> anything lacking the above.

9) Publishable definitions

• Recursion (CS/math): self-call on a smaller case with a base case and a decreasing measure.
• Recursive, Representational (RR): cognition with explicit self-as-object content that does not necessarily alter control.
• Recursive, Control (RC): cognition with explicit self-as-process whose estimates modify behavior (policy, attention, memory).
• Recurrent dynamics: stateful feedback over time without a self-model.