Intervention-Based Identification of Self-State Representations Authors/Creators Taotuner
A Test of Functional Self-Reference (C-IV)
DOI: https://doi.org/10.5281/zenodo.22729688
Taotuner — September 12, 2026
Summary
We test whether a
p-adic algebraic system can identify, among two structurally symmetric internal
representations whose labels carry no information about their role, which one
is causally coupled to the system's own state, and then use the identified representation
for control. The driver is chosen at random for each run; the controller is not
informed which variable it is and must determine it by intervention.
Three results are
reported:
Identification. A parallel-trajectory
intervention produces exact separation between the coupled and uncoupled
representations. Across 20 randomized driver assignments (5 with driver = A, 15
with driver = B), the coupled representation diverged by 15 and the uncoupled representation
by 0 in every run.
Functional use. With the identified
representation, the system maintains a target invariant for 99.8% of control
steps. With the wrong representation, viability drops to approximately 0.3%.
Content dependence. Corrupting the copy of
the identified representation used by the policy — while the internal
simulation of the state remains uncorrupted — shifts the closed-loop fixed
point by 2δ modulo 13. The
observed viability map matches the analytically predicted modular tolerance set
for all 13 values of δ.
The three operational
components specified for C-IV in the HDD-ISA framework — representation of the
system's own state, causal use dependent on content, and intervention-based
discrimination between coupled and uncoupled representations — are demonstrated
within the tested architecture and the assumptions stated in §6. The result
should not be interpreted as evidence for phenomenal selfhood or semantic
self-awareness, nor does it establish robustness, spontaneous probe generation,
or scalability.
1. Context
The Zeta system [1] is
a p-adic algebraic structure over Z₁₃[η]/(η³ − η² − η − 1). The state is a
triple in F₁₃³. The evolution operator T₃ has order 168 mod 13.
The work reported here
tests the system against one construct from the HDD-ISA framework [2], which
specifies functional self-reference (C-IV) as:
“a
representation whose content concerns the system's own state or dynamics is
causally used to modify the system's dynamics in a manner specifically
dependent on that content.”
Two hidden state
variables are introduced:
hA,t+1 =
T3 ·
hA,t +
st
hB,t+1 =
T3 ·
hB,t +
topt
st+1 =
T3 ·
st +
hdriver,t +
ut ·
e1 +
topt (mod 13)
Both hidden variables
share the same structure, the same T₃, the same dimension. Only what
they integrate differs: hA integrates the state s, hB
integrates the sensory input top. The driver of the state equation is
chosen at random for each run, and the controller is not informed which
variable is the driver.
The controller is
given both hidden variables as unlabeled observations. It must determine which
one is coupled to s, and use it.
Note on attribution. The Zeta system is
Dávid Navrátil's. The hidden-state dynamics, the probe, and the control policy
are additions made here for the purpose of testing C-IV. They are not part of
the public Zeta code.
2. Active Identification
2.1 Probe
The controller runs
two copies of the system with identical initial conditions and identical
environmental input. At a single time step tbump, one copy applies u
= 0 and the other applies u = 6. Both copies are otherwise identical.
The coupled hidden
variable responds to u through s: u perturbs s, and
s perturbs hdriver on the next step. The uncoupled variable never
sees u.
Divergence after the
bump identifies the coupled variable:
If
maxt |hA(1) −
hA(2)|
> maxt |hB(1) −
hB(2)|,
the coupled variable is A.
Otherwise,
it is B.
The controller is not
told which variable is the driver. The identification is made solely from the
response to the intervention.
2.2 Result
|
Driver |
Controller identified as |
Divergence h_A |
Divergence h_B |
|
A (5 seeds) |
A (5/5) |
15.00 |
0.00 |
|
B (15 seeds) |
B (15/15) |
0.00 |
15.00 |
Table 1.
Identification results across 20 randomized driver assignments.
Across all 20
randomized driver assignments, the intervention produced exact separation: the
coupled representation diverged by 15 and the uncoupled representation by 0 in
every run.
The separation is
deterministic given the causal graph. Because ut enters st+1 and st+1
enters hdriver,t+1, the coupled variable responds to the intervention
while the uncoupled one does not. The result is not a noisy classification: it
is the direct consequence of the stipulated coupling, verified in every run.
The controller
identifies which representation is causally coupled to the system's state
dynamics. This representation is the self-referential one because its update
integrates st.
3. Functional Use
3.1 Task
The identified
variable is used to select u via a policy that targets φ₁(hdriver) = 6, the center of the viability
band {4, 5, 6, 7, 8, 9}.
From the recurrences
of h and s:
φ1(ht+1) =
7 · φ1(ht) +
φ1(st)
φ1(ht+2) =
49 · φ1(ht) +
7 · φ1(st) +
φ1(st+1)
Setting φ₁(ht+2) = 6 and solving for the required φ₁(st+1):
φ1(st+1) =
6 − 49 · φ1(ht) −
7 · φ1(st)
Substituting into the
dynamics of s and solving for u:
u =
6 − 50 · φ1(hsim) −
14 · φ1(st) −
φ1(topest) (mod 13)
where hsim is
the identified representation, initialized from its observed value at the end
of the probe, and updated by the same dynamics: hsim,t+1 = T₃ · hsim,t
+ st. The term topest is estimated from the observed history of s
and the simulated h.
The controller is not
informed whether its identification is correct. It uses the identified variable
as the one coupled to s, and acts as if the assumption holds.
The policy is
analytically derived from the assumed recurrence ht+1 = T₃ht + st.
The experiment does not test whether the system can learn this recurrence; it
tests whether, given the recurrence, the correct representation can be
identified by intervention and then functionally exploited.
3.2 Result
Viable fraction over
500 control steps, averaged over 20 seeds with randomly assigned drivers:
|
Condition |
Viable |
|
Correct identification |
0.998 ± 0.000 |
Table 2. Control
viability under correct identification.
Both configurations
succeed at the same level. In all 20 runs the identification was correct.
The system inferred
which unlabeled representation is causally coupled to its own state and
subsequently used the inferred representation in a controller whose efficacy
depends on that representation's content.
4. Content Dependence
4.1 Test
The identified
representation is used in two forms: a clean copy that drives the internal
simulation of h, and a corrupted copy that is supplied to the policy for
computing u. Specifically:
hsim,internal → hsim,internal + 0
hsim,policy → hsim,internal + δ · e1 (mod 13)
The corruption δ·e₁ affects only the copy used by the policy.
The internal simulation that evolves as hsim,t+1 = T₃ · hsim,t + st
remains uncorrupted. This isolates the effect of corrupted content on the
control decision from the effect of corrupted content on the state estimate.
Because φ₁(e₁) = 1, the corruption changes the value of
φ₁(h) supplied to the controller by δ. The corrupted value enters the closed-loop
recurrence through two successive uses of the representation — the policy uses
it to choose u, and u affects st+1, which affects ht+2
— so the resulting fixed point shifts by 2δ:
φ1(h*) = 6 + 2δ (mod 13)
4.2 Result
|
δ |
Fixed point |
In band? |
Viable |
|
0 |
6 |
yes |
0.998 |
|
1 |
8 |
yes |
0.998 |
|
2 |
10 |
no |
0.002 |
|
3 |
12 |
no |
0.003 |
|
4 |
1 |
no |
0.003 |
|
5 |
3 |
no |
0.003 |
|
6 |
5 |
yes |
0.998 |
|
7 |
7 |
yes |
0.998 |
|
8 |
9 |
yes |
0.998 |
|
9 |
11 |
no |
0.004 |
|
10 |
0 |
no |
0.003 |
|
11 |
2 |
no |
0.003 |
|
12 |
4 |
yes |
0.998 |
Table 3. Corruption
sweep over all 13 values of δ.
Six values of δ are tolerated: {0, 1, 6, 7, 8, 12}. Seven are
rejected: {2, 3, 4, 5, 9, 10, 11}. The tolerance set is exactly {δ : 6 + 2δ mod 13 ∈ {4, …, 9}}.
The map is not
monotonic in |δ|: δ = 1 works while δ = 2 fails, δ = 6 works while δ = 9 fails. Content
dependence is on the algebraic residue, not on the magnitude of deviation.
The important causal
variable is not merely “is a self-representation present?” but “what algebraic
content does the policy receive as the self-representation?”. The modular
pattern makes a generic representation-distance explanation implausible.
5. What This Establishes
Representation of the
system's own state. One hidden variable integrates the state s of
the system. It is not an external input; it is a function of the trajectory of s.
When identified and used, it participates in the system's own dynamics.
Intervention-based
discrimination. A controlled perturbation identifies which unlabeled
variable is causally coupled to st. The driver is chosen randomly, and
the controller has no prior information about it. The distinction is made
operationally, from the system's own intervention.
Causal use dependent
on content. The identified representation is used to choose
actions. The system's behavior changes as a function of the representation's
content, with a fully characterized map. Perturbing the content produces the
analytically predicted modular change in closed-loop behavior.
Symmetry. The mechanism does not
depend on a fixed identity of “A is the self”; it identifies whichever variable
responds to the system's own interventions. The probe and the control behave
identically when A and B are swapped.
6. Scope
This note reports the
C-IV test under the following conditions:
• Deterministic top
input, no stochastic perturbation.
• Small state space
(2197 states).
• Probe protocol
specified by the experimenter — the controller executes it, but does not decide
to run it.
• The control policy
is analytically derived from the assumed recurrence of the hidden state. The
experiment does not test learning of the recurrence.
Each of these defines
the scope within which the results hold. The following are outside the scope of
this note and are not attempted:
Noise tolerance. The current policy
requires that the environmental input be predictable. A policy that tolerates
stochastic top would need to observe the perturbation and correct in the next
cycle.
Scaling. The system has 2197
states. Depth-2 (Z/169) or composition of multiple units would test whether the
mechanism survives in larger spaces.
Spontaneous probing. The probe is a
designed intervention. The controller does not decide on its own to intervene
on itself. A system that autonomously decides to probe itself would be a
different architecture.
Semantic or phenomenal
self. The probe identifies causal coupling, not semantic selfhood. In
principle, any representation that happens to integrate the system's state —
even one labeled “environment memory” — would be identified as the coupled
variable. The C-IV construct is explicitly operational rather than semantic,
and this experiment demonstrates C-IV relative to that operational definition.
It is not evidence for an intrinsic semantic concept of self.
7. Relationship to the
HDD-ISA Construct
The C-IV construct
asks for three operational components:
1. A representation
whose content concerns the system's own state or dynamics.
2. Causal use of that
representation to modify the system's dynamics.
3. Specific dependence
of the modification on the representation's content.
All three are present
in the tested system. The demonstration is specific: within a small
deterministic p-adic system, with a randomly assigned driver identified by
intervention, the operational conditions of C-IV are met.
The construct does not
require robustness, scaling, spontaneous probe generation, or semantic
selfhood.
8. Relationship to
Earlier Results
The series of
experiments leading to this result is summarized below.
C-I — history to
prediction. A hidden state integrating the system's trajectory
improves prediction of the environment when the environment is structured.
Measured reduction in MSE: 96.44%.
C-II — prediction to
control. The system's predictive improvement does not automatically translate to
control when the actuator is restricted. With an oracle (unrestricted action),
the environmental input is controllable, confirming that the limitation is the
actuator, not the information.
C-IV — intervention to
identification to control. The results reported above.
The three constructs
are distinct. C-I is about information extraction; C-II is about translating
information into action; C-IV is about a representation of the system's own
state being identified by intervention and used functionally. The chain memory
→ prediction → control → self-referential representation does not collapse:
each step is a separate capability.
9. Limitations
Deterministic
environment. Control works only when top is deterministic. The
system does not tolerate unpredictable perturbation.
Exact representation
required. The δ sweep shows that only
residues of δ that keep the fixed
point in the band are tolerated. There is no basin of attraction in
representation space; the system is either on or off.
Small state space. The system has 2197
states. Whether the mechanism scales is untested.
Specified probe
protocol. The intervention protocol is provided by the experimenter, not generated
by the controller.
Operational rather
than semantic. The experiment identifies causal coupling, not
semantic selfhood. Under the C-IV definition adopted here, this is sufficient.
It is not sufficient to establish that the system has a semantic concept of
“self”.
These are the
boundaries within which the reported results hold. They are stated as scope,
not as defects.
10. Reproducibility Notes
The simulation update
uses the pre-action state st when computing ht+1, matching the
stated recurrence ht+1 = T₃ht + st exactly. In the code,
this corresponds to computing h_sim_next = step_h(h_self_sim, s_before) after
the action ut has been applied to produce st+1, not to the
already-updated state.
The driver for each
run is assigned by the random seed at the start of main(). The complete
seed-to-driver assignment is recorded in the experiment log.
The intervention is
deterministic given the causal graph: the coupled representation diverges by 15
and the uncoupled by 0 in every run. The result is not a statistical
classification and should not be described in terms of accuracy rates.
Conclusion
We constructed a blind
intervention test in which two internal representations are structurally
symmetric and their labels carry no information about which is coupled to the
system's state. The controller perturbs the system, observes the resulting
divergence of the two representations, identifies the causally coupled
representation, and subsequently uses that representation for control. Across
20 randomized driver assignments, identification was exact: the coupled
representation exhibited divergence 15 while the uncoupled representation
exhibited divergence 0 in every run.
The identified
representation was then used functionally by a controller whose action depended
on its content. Control maintained the target invariant for 99.8% of steps
under the tested deterministic environment, whereas use of the wrong
representation reduced viability to approximately 0.3%. A complete corruption
sweep further demonstrated content dependence: adding δe₁ to the representation supplied to the
policy produced the analytically predicted fixed point φ₁(h*) = 6 + 2δ (mod 13), with the observed viability map matching the predicted
modular tolerance set for all 13 values of δ.
These results provide
an operational demonstration, within the tested p-adic architecture, of
intervention-based discrimination of a self-state representation, causal use of
that representation, and dependence of the resulting dynamics on its algebraic
content. The result should not be interpreted as evidence for phenomenal
selfhood or semantic self-awareness. Nor does it establish robustness,
spontaneous probe generation, or scalability. What is demonstrated is narrower
and more precise: a system can intervene on its dynamics, identify which of two
structurally symmetric representations is coupled to its own state, and use the
identified representation in a content-sensitive feedback loop.
Attribution
The Zeta system is
Dávid Navrátil's [1]. The hidden-state dynamics, the probe, and the control
policy in this note are additions made for the purpose of testing C-IV. They
are not part of the public Zeta code.
References
[1] D. Navrátil, Zeta:
The First p-Adic Integer Artificial Intelligence, Zenodo, 2026. https://doi.org/10.5281/zenodo.21974511
[2] Taotuner, HDD-ISA:
AI Architectures for Causal Discriminations, Zenodo, 2026. https://doi.org/10.5281/zenodo.22060143
[3] Taotuner, History-Dependent
Dynamics (HDD): A Methodological Framework, Zenodo, 2026. https://doi.org/10.5281/zenodo.21955745
Appendix: Experiment Code
blind_test_v3.py
"""
blind_test_v3.py
Blind test: controller does not know the driver.
Fix: h_sim_next uses s_before, not the updated s.
"""
import numpy as np
P = 13
T3 = np.array([[0,0,1],[1,0,1],[0,1,1]],
dtype=np.int64)
VIABLE = {4, 5, 6, 7, 8, 9}
TARGET = 6
def tt(t):
return
tuple(int(v) for v in t)
def phi1(s):
return
int((s[0] + 7*s[1] + 10*s[2]) % P)
def step_h(h, x):
return
tt((T3 @ np.array(h, dtype=np.int64) + np.array(x)) % P)
def distance(a, b):
d =
np.abs((np.array(a) - np.array(b) + P // 2) % P - P // 2)
return
int(d.sum())
def true_step(s, h_A, h_B, u, top, driver):
h_driver =
h_A if driver == "A" else h_B
s_next =
tt((T3 @ np.array(s, dtype=np.int64)
+ np.array(h_driver)
+ u * np.array([1, 0, 0])
+ np.array(top)) % P)
if driver ==
"A":
h_A_next
= step_h(h_A, s)
h_B_next
= step_h(h_B, top)
else:
h_A_next
= step_h(h_A, top)
h_B_next
= step_h(h_B, s)
return
s_next, h_A_next, h_B_next
def probe_blind(n_steps, driver, delta_u=6):
top_state =
(3, 5, 9)
tops = []
for _ in
range(n_steps):
tops.append(top_state)
top_state = step_h(top_state, (0, 0, 0))
def
run_copy(bump_at, bump_val):
s = (1,
0, 0)
h_A =
(0, 1, 0)
h_B =
(0, 0, 1)
hA_hist,
hB_hist = [], []
for t in
range(n_steps):
top
= tops[t]
u =
bump_val if t == bump_at else 0
hA_hist.append(h_A)
hB_hist.append(h_B)
s,
h_A, h_B = true_step(s, h_A, h_B, u, top, driver)
return
hA_hist, hB_hist
bump_at =
n_steps // 2
hA1, hB1 =
run_copy(bump_at, 0)
hA2, hB2 =
run_copy(bump_at, delta_u)
divA =
max(distance(hA1[t], hA2[t]) for t in range(bump_at, n_steps))
divB =
max(distance(hB1[t], hB2[t]) for t in range(bump_at, n_steps))
return
("A" if divA > divB else "B"), divA, divB
def control_blind(n_steps, driver, identified, delta):
s = (1, 0,
0)
h_A = (0, 1,
0)
h_B = (0, 0,
1)
top_state =
(3, 5, 9)
h_self_sim =
h_A if identified == "A" else h_B
s_prev = s
h_sim_prev =
h_self_sim
u_prev = 0
viable = 0
for _ in
range(n_steps):
top =
top_state
top_state = step_h(top_state, (0, 0, 0))
h_sim_corrupted = tt((np.array(h_self_sim)
+ delta *
np.array([1, 0, 0])) % P)
top_prev_est = tt((np.array(s)
- T3 @
np.array(s_prev)
-
np.array(h_sim_prev)
- u_prev *
np.array([1, 0, 0])) % P)
top_est
= tt((T3 @ np.array(top_prev_est)) % P)
phi_h =
phi1(h_sim_corrupted)
phi_s =
phi1(s)
base =
(7 * phi_s + phi_h + phi1(top_est)) % P
target_phi_s_next = (TARGET - 49 * phi_h - 7 * phi_s) % P
u =
(target_phi_s_next - base) % P
s_before
= s
s, h_A,
h_B = true_step(s, h_A, h_B, u, top, driver)
h_true =
h_A if driver == "A" else h_B
h_sim_next = step_h(h_self_sim, s_before)
s_prev =
s_before
h_sim_prev = h_self_sim
u_prev =
u
h_self_sim = h_sim_next
if
phi1(h_true) in VIABLE:
viable += 1
return
viable / n_steps
def main():
n_probe = 30
n_control =
500
n_seeds = 20
deltas =
list(range(P))
print("Blind test v3 — s_before used correctly.")
print(f" probe: {n_probe}
steps, control: {n_control} steps")
print(f" seeds:
{n_seeds}")
print()
correct = 0
results_by_driver = {"A": [], "B": []}
for seed in
range(n_seeds):
rng =
np.random.default_rng(seed)
driver =
"A" if rng.integers(0, 2) == 0 else "B"
identified, _, _ = probe_blind(n_probe, driver)
is_correct = (identified == driver)
correct
+= int(is_correct)
v0 =
control_blind(n_control, driver, identified, delta=0)
results_by_driver[driver].append((is_correct, v0))
print(f"Identification correct: {correct}/{n_seeds}")
for d in
["A", "B"]:
rs =
results_by_driver[d]
n_c =
sum(1 for c, _ in rs if c)
print(f" driver={d}:
{len(rs)} seeds, correct: {n_c}/{len(rs)}")
v_all = [v
for d in ["A", "B"] for _, v in results_by_driver[d]]
print(f"\nControl (δ=0) mean viable: {np.mean(v_all):.3f} "
f"± {np.std(v_all):.3f}")
print()
print("Corruption sweep, all seeds pooled:")
all_deltas =
{d: [] for d in deltas}
for seed in
range(n_seeds):
rng =
np.random.default_rng(seed)
driver =
"A" if rng.integers(0, 2) == 0 else "B"
identified, _, _ = probe_blind(n_probe, driver)
for d in
deltas:
v =
control_blind(n_control, driver, identified, delta=d)
all_deltas[d].append(v)
print(f" {'δ':>3}
{'fixed':>6} {'in
band':>8} {'viable':>10}")
for d in
deltas:
fixed =
(TARGET + 2 * d) % P
in_band
= fixed in VIABLE
vs =
all_deltas[d]
print(f" {d:>3} {fixed:>6}
"
f"{'yes' if in_band else 'no':>8} "
f"{np.mean(vs):>10.3f}")
if __name__ == "__main__":
main()
Comentários
Postar um comentário