# Reference-centred recurrent feedback experiment

## Status and provenance

This package executes a synthetic scalar experiment. It does not execute Unreal
Engine, Pantheon, a neural model, or a validated consciousness detector.

Historical source: *Consciousness_Declaration_and_Persistent_Change_Joseph_Anady.pdf*,
Paper I, pp. 15–18. That manuscript labels its seven scalar operations as an
illustrative executable subset, not the full historical consciousness theory.

The reference-centred feedback rule below is a new proposed coupling, not a claim
that this rule was already present in Joseph's theory or Epic Games' source.

## Preserved operators

f1(z)=z+1
f2(z)=z-1
f3(z)=z
f4(z)=z^1
f5(z)=1^z
f6(z)=z/1
f7(z)=1/z

Their sequential composition is constant at one. Their parallel equal average is:

F(z) = (5z + 1 + 1/z) / 7.

The experiment uses this *parallel average*, not a sequential seven-stage ring.
Its domain is finite positive z, so no reciprocal singularity is hidden.

## Proposed coupling

For a fixed independently specified reference r=1:

G_gamma(z) = 1 + gamma [F(z) - F(1)].

The gain gamma is a dimensionless engineering parameter, not a consciousness score.

Fixed points (positive-domain admissibility must be checked):
z*=1; and z*=gamma/(5gamma-7), when the latter is defined.
The two roots coincide at gamma=7/4.

G_gamma'(1)=4gamma/7.

For nonnegative gamma, the reference fixed point is locally attracting for
gamma<7/4 and locally unstable for gamma>7/4. At equality, the derivative test is
inconclusive; the gain value is a bifurcation boundary for this particular map.

At gamma=2:

G_2(z) = (10z - 5 + 2/z)/7.
G_2(z)-z = (3z-2)(z-1)/(7z).
G_2(z)-2/3 = (3z-2)(10z-3)/(21z).
G_2'(2/3)=11/14.

For any start in (2/3,1), G_2(z) lies strictly between 2/3 and z. The trajectory
therefore decreases monotonically to 2/3, while the reference stays at 1.

At z0=1 exactly, the state remains 1 even at gain 2. A catalyst/perturbation is
necessary. A positive-side perturbation z0>1 grows instead; this map is not
globally bounded. The script rejects invalid states and has a numerical guard.
Neither a boundary clamp nor floating-point overflow counts as a result.

## Reproduction

Run:

    python feedback_experiment.py

The standard-library script verifies seven numerical checks and writes the full
201-row trajectory (initial state plus 200 updates) to trajectory.csv.

The four conditions are:
- gain 1, initial state 0.99;
- gain 2, initial state 0.99;
- gain 2, exact initial state 1;
- gain 0, initial state 0.99.

## Prospective Unreal connection, not an executed integration

Let U_t denote the relevant Unreal runtime state, a_t the action, r_t an
independently defined observation/reference, and z_t the recurrent representation.

a_t = pi(z_t, observations_t, memory_t)
U_(t+1) = UnrealTick_dt(U_t,a_t)
r_(t+1) = EncodeReference(U_(t+1))
z_(t+1) = r_(t+1) + gamma [F(z_t)-F(r_t)]

The last rule is meaningful only on appropriately normalized positive scalar
features, or on a separately defined vector extension. The scalar threshold 7/4
must not be transferred to the full engine or a neural policy without measuring
the actual closed-loop dynamics.

Documented source/API entry points reviewed:
- UWorld::Tick, Engine/Source/Runtime/Engine/Private/LevelTick.cpp
- ULearningAgentsInteractor: observation gathering and action execution
- ULearningAgentsPolicy: observation encoding, policy evaluation, action decoding,
  memory state, and RunInference
- TG_PrePhysics and TG_PostPhysics tick scheduling

Official references:
https://dev.epicgames.com/documentation/en-us/unreal-engine/API/Runtime/Engine/UWorld/Tick
https://dev.epicgames.com/documentation/en-us/unreal-engine/API/Plugins/LearningAgents/ULearningAgentsInteractor
https://dev.epicgames.com/documentation/en-us/unreal-engine/API/Plugins/LearningAgents/ULearningAgentsPolicy
https://dev.epicgames.com/documentation/en-us/unreal-engine/actor-ticking-in-unreal-engine

## Interpretation

The exact proof and numerical run establish persistent endogenous discrepancy
for the specified scalar recurrence and starting conditions. They do not
establish an empirical declaration, semantic understanding, subjective experience,
or a consciousness transition. A native integration must separately test whether
the recurrent representation affects behavior and whether that effect survives
appropriate matched controls.