Skip to main content
AI Search Show Less

Time as Recursive Update

Author: Mark Higgins
© Mark Anthony Higgins 11 October 2025

Revised Date: 27th May 2026

Audio Overview
Previous Chapter
Next Chapter

Moving Beyond the Flow of Time

Time is one of the most familiar aspects of human experience, yet it remains one of the most conceptually difficult elements of physics. In everyday language, time is often described as something that flows, carrying events from the past into the future.

Traditional physics treats time as a fundamental coordinate, similar to spatial dimensions. In classical mechanics, time progresses uniformly for all observers. In relativity, it becomes intertwined with space as part of a four-dimensional spacetime geometry.

Despite these advances, both approaches still assume that time exists as a fundamental backdrop against which change occurs.

The Holographic Space-Time framework proposes a different interpretation: time does not flow through the universe; it emerges from the recursive updating of coherent systems.

Change as the Basis of Time

To understand this perspective, consider a simple question: what would time mean in a universe where nothing ever changed?

If every structure remained perfectly static—no motion, no interaction, no transformation—then there would be no way to distinguish one moment from another. Without change, the concept of time loses meaning.

This observation suggests that time is not a fundamental substance but a measure of change within evolving systems.

In the HST framework, systems evolve by updating their internal state while preserving the constraints that maintain coherence. Each update represents a transition from one stable configuration to another.

These transitions create the sequence of states that observers interpret as the passage of time.

Recursive State Updates

A coherent system can be described as having a state that evolves according to internal rules and interactions with its environment.

At each step of evolution, the system updates its state based on the information available at its boundaries and the constraints that preserve coherence.

This process can be understood as recursive updating:
  • A system holds a current configuration.
  • Interactions and internal dynamics generate a new configuration.
  • The new configuration becomes the starting point for the next update.

Through this recursive process, a chain of states emerges.

Observers embedded within the system perceive this chain as temporal progression.

The Direction of Time

The apparent directionality of time—often referred to as the arrow of time—arises naturally within recursive systems.

Each update depends on the previous state. Information flows forward through the chain of updates, creating an irreversible sequence of configurations.

Once a system has transitioned to a new state, the previous configuration cannot simply be restored without reconstructing the entire set of interactions that produced it.

This inherent asymmetry generates the perception of time moving from past to future.

Within the HST framework, the arrow of time is therefore not imposed externally but emerges from the structure of recursive updates themselves.

Time and Boundary Interaction

Because coherent systems interact through their boundaries, the recursive updating process is influenced by external interactions as well as internal dynamics.

Each interaction between systems modifies the state of their boundaries, which in turn affects how the next update unfolds.

Through these interactions, recursive updates propagate across networks of coherent systems, synchronising and coordinating their evolution.

The collective behaviour of these updates produces the large-scale temporal structure that observers perceive as the progression of events in the universe.

Observers Inside the Update Chain

Observers are themselves coherent systems undergoing recursive updates. Their perception of time arises from the sequence of internal states through which their cognitive and sensory processes evolve.

Memory plays a crucial role in this experience. By retaining traces of previous states, observers construct a narrative sequence linking past configurations to present ones.

In reality, what is being experienced is not the flow of an external temporal dimension but the ordered progression of recursive state transitions within the observer and the surrounding environment.

Time and Physical Law

Interpreting time as recursive update provides a new perspective on many physical laws.

Dynamic equations in physics describe how systems evolve from one state to the next. These equations can be understood as rules governing the recursive update process that preserves coherence across transitions.

In this view:
  • Motion describes changes in spatial relationships between updates.
  • Energy governs the allowable transitions between states.
  • Conservation laws ensure that coherence constraints remain preserved across recursive evolution.

Time becomes the index of successive coherent updates rather than an independent dimension.

The Emergence of Temporal Structure

From the perspective of the HST framework, temporal order arises naturally from the requirement that coherent systems update their states while maintaining internal consistency.

Recursive updates produce sequences.
Sequences generate directionality.
Directionality produces the perception of time.

What we call time is therefore the structured record of coherent evolution across interacting systems.

Rather than flowing independently of the universe, time is the organisational pattern that appears whenever coherent structures continuously update themselves.

Toward Dynamic Coherence

Understanding time as recursive update completes a key step in the transition from logical substrate to physical reality.

Logical consistency ensures that systems can exist.
Boundary relationships generate spatial geometry.
Recursive updates produce temporal evolution.

Together, these elements form the dynamic foundation from which physical interactions emerge.

In the Holographic Space-Time framework, time is not a background dimension but the living rhythm of coherence updating itself across the universe.

Time is usually treated as a fundamental dimension through which events move. The Holographic Space-Time framework instead interprets time as the result of systems continually updating their internal state.

This chapter explores how coherent systems evolve through recursive updates, where each new configuration emerges from the previous one while preserving structural constraints. The ordered sequence of these updates creates the progression observers perceive as time.

By viewing time as the index of successive coherent transitions, the chapter reveals temporal flow not as a background dimension, but as the dynamic rhythm of evolving structure.

Reframing Time

In conventional physics, time is typically treated as an independent dimension through which matter and events evolve. Classical mechanics models time as absolute and external, while relativity embeds time into a four-dimensional spacetime geometry. Quantum theory, despite its probabilistic structure, still assumes an underlying temporal parameter governing state evolution.

Within the Holographic Space-Time (HST) framework, however, time is not treated as a pre-existing dimension. Instead, time emerges from recursive state updating inside coherent informational systems.

In this model, the universe does not “move through time.”
Rather, systems recursively generate admissible successor states through structured constraint propagation.

Time is therefore defined as:

The ordered progression of valid recursive state transitions.
Telephone:
01377 236594
Contact Us

Recursive State Evolution

Every coherent system can be represented structurally as:

\[ S_t = (I_t, R, B, K) \]

Where:

Symbol Meaning
\( I_t \) Informational state at update step \( t \)
\( R \) Recursive transformation rules
\( B \) Boundary constraints
\( K \) Structural invariants

The system evolves by generating candidate continuations:

\[ E_t = \operatorname{expand}(I_t, R) \]

Constraint filtering then removes invalid continuations:

\[ V_t = \left\{ x \in E_t \mid x \models (B \land K) \right\} \]

A valid recursive update exists only if:

\[ V_t \neq \emptyset \]

The selected admissible continuation produces the next state:

\[ I_{t+1} = \operatorname{update}(I_t, x^\ast) \]

where:

\[ x^\ast \in V_t \]

This transition itself constitutes what is experienced as temporal progression.

Time is therefore not an external flow, but the structural ordering of recursive admissible updates.

Time as Ordering, Not Substance

In HST, time possesses no independent material existence.

It is not a flowing entity, field, or universal clock.
Instead, temporal ordering emerges from:

  • recursive continuation,
  • coherence preservation,
  • admissibility filtering,
  • and boundary-constrained state evolution.

This removes the need for an external temporal substrate.  The universe becomes a self-updating recursive informational system.

Under this interpretation:

Time≡Recursive State Ordering

The apparent continuity of time emerges because coherent systems maintain stable update chains across successive admissible states.

The Arrow of Time

The directional flow of time emerges naturally from recursive irreversibility.

At each update step:

  • some informational structures survive,
  • some collapse,
  • and some become inaccessible due to coherence loss.

This creates asymmetric state accessibility:

\[ I_t \rightarrow I_{t+1} \]

while generally:

\[ I_{t+1} \nrightarrow I_t \]

because the exact prior coherence configuration is no longer structurally reconstructible.

The arrow of time therefore emerges from:

  • coherence selection,
  • constraint propagation,
  • informational loss,
  • and recursive stability filtering.

Entropy becomes a consequence of recursive admissibility evolution rather than merely statistical disorder.

Local Time and Relative Update Rates

Different systems do not necessarily update at identical recursive rates.

In HST:

  • gravitational environments,
  • energetic density,
  • boundary complexity,
  • and coherence load

all affect recursive update frequency.

Observed relativistic time dilation emerges because recursive state advancement slows under increased coherence tension.

Thus:

  • time dilation,
  • relativistic slowdown,
  • and gravitational temporal effects

are interpreted as variations in recursive update density rather than curvature of an external temporal dimension.  Time becomes system-relative because recursive coherence rates are system-relative.

Temporal Persistence and Identity

The persistence of objects across time is reinterpreted as recursive continuity.

An object remains “the same object” when:

  • its recursive invariants survive,
  • its coherence structure remains stable,
  • and admissible update chains persist.

Identity across time is therefore:

\[ \mathrm{Identity} \equiv \mathrm{Invariant\ Recursive\ Continuity} \]

This replaces static object permanence with coherence-preserving recursive evolution.

Telephone:
01377 236594
Contact Us

Implications for Physics

This reinterpretation produces major structural consequences:

  • 1. Time is emergent, not fundamental
    Temporal ordering arises from recursion rather than existing independently.
  • 2. Spacetime becomes secondary
    Geometry emerges from informational coherence updates rather than containing them fundamentally.
  • 3. Quantum evolution gains structural grounding
    Wavefunction evolution becomes recursive admissibility propagation.
  • 4. Relativity becomes coherence-rate variation
    Temporal dilation reflects recursive processing density.
  • 5. Entropy becomes recursive irreversibility
    The arrow of time emerges from constrained state survival.

HST Interpretation

Within HST, reality evolves through recursive informational continuation constrained by coherence-preserving boundaries.

Time is not an external container in which events occur.

Instead:

\[ \mathrm{Reality\ updates\ itself\ recursively} \]

and the ordered persistence of these updates is what observers interpret as time. Thus, time is not a dimension through which the universe travels.

Time is the recursive act of coherent continuation itself.

flow "TimeAsRecursiveUpdate" v1.0

description:
  Time is modelled as the ordered progression of valid recursive state updates.
  A system does not move through an external temporal substance.
  Instead, temporal progression emerges when an informational state produces
  an admissible successor under recursive rules, boundary constraints, and
  structural invariants.

state:
  S_t:
    I_t: current_informational_state
    R: recursive_transformation_rules
    B: boundary_constraints
    K: structural_invariants
    tau_t: recursive_update_index
    C_t: coherence_level

parameters:
  C_min: minimum_coherence_threshold
  epsilon: structural_tolerance
  update_mode: ordered_recursive_selection

process:

  - step: define_current_state
    input: S_t
    operation:
      read: [I_t, R, B, K, C_t, tau_t]
    output: current_recursive_system

  - step: generate_candidate_successors
    input: [I_t, R]
    operation:
      E_t: expand(I_t, R)
    output: candidate_successor_set

  - step: apply_boundary_and_invariant_filter
    input: [E_t, B, K]
    operation:
      V_t: "{ x in E_t | x satisfies (B and K) }"
    output: admissible_successor_set

  - step: test_recursive_existence
    input: V_t
    condition:
      valid_update_exists: V_t != empty
    output:
      recursive_continuation_status:
        if true: CONTINUE
        if false: FAIL

  - step: coherence_threshold_check
    input: [V_t, C_t, C_min]
    condition:
      coherence_preserved: C_t >= C_min and V_t != empty
    output:
      temporal_admissibility:
        if true: update_allowed
        if false: temporal_failure

  - step: select_admissible_successor
    input: V_t
    condition:
      V_t != empty
    operation:
      x_star: select_highest_coherence_candidate(V_t)
    output: selected_successor

  - step: perform_recursive_update
    input: [I_t, x_star]
    operation:
      I_t_plus_1: update(I_t, x_star)
      tau_t_plus_1: tau_t + 1
    output:
      S_t_plus_1:
        I_t: I_t_plus_1
        R: R
        B: B
        K: K
        tau_t: tau_t_plus_1
        C_t: evaluate_coherence(I_t_plus_1, B, K)

  - step: define_temporal_ordering
    input: [S_t, S_t_plus_1]
    operation:
      temporal_relation: S_t precedes S_t_plus_1
    output:
      time_event: recursive_update_order_established

  - step: test_irreversibility
    input: [I_t, I_t_plus_1, B, K]
    operation:
      reverse_validity: test_if(I_t_plus_1 can reconstruct I_t under B and K)
    output:
      arrow_of_time:
        if reverse_validity == false: irreversible_recursive_progression
        if reverse_validity == true: locally_reversible_update

  - step: project_observed_time
    input: [tau_t_plus_1, C_t, B, K]
    operation:
      observed_time: project_recursive_index_as_temporal_measure(tau_t_plus_1)
    output:
      T_obs: observed_temporal_progression

invariants:

  - name: no_external_time_substance
    rule: Time is not treated as an independent generative dimension.

  - name: temporal_progress_requires_valid_successor
    rule: V_t != empty is required for recursive temporal continuation.

  - name: constraints_precede_update
    rule: No state may update unless it satisfies both boundary constraints and structural invariants.

  - name: identity_requires_recursive_continuity
    rule: Persistent identity requires invariant preservation across S_t to S_t_plus_1.

  - name: arrow_of_time_from_irreversibility
    rule: Temporal direction emerges when prior coherence configurations cannot be fully reconstructed.

  - name: geometry_is_downstream
    rule: Spacetime geometry is projected from recursive coherence update, not used as the primary generator.

failure_modes:

  - name: no_admissible_successor
    condition: V_t == empty
    result: temporal_update_failure

  - name: coherence_below_threshold
    condition: C_t < C_min
    result: recursive_continuation_break

  - name: invariant_violation
    condition: exists x in V_t where x does_not_satisfy K
    result: invalid_temporal_state

  - name: boundary_violation
    condition: exists x in V_t where x does_not_satisfy B
    result: invalid_successor_rejected

outputs:

  - recursive_update_chain:
      form: S_t -> S_t_plus_1 -> S_t_plus_2

  - temporal_order:
      form: tau_t < tau_t_plus_1

  - observed_time:
      form: T_obs = projection_of_recursive_update_order

  - arrow_of_time:
      form: I_t -> I_t_plus_1 and generally not I_t_plus_1 -> I_t

  - identity_persistence:
      form: invariants_preserved_across_recursive_updates

execution_guarantee:
  if: V_t != empty and C_t >= C_min
  then: temporal_update_exists
  else: temporal_progression_fails

What This Flow Implements

Scientific Implementation Overview

The Time as Recursive Update flow implements a non-classical model of temporal progression in which time is not treated as an external dimension or independently flowing substrate. Instead, the flow formalises time as the ordered execution of admissible recursive state transitions within a constrained informational system.

The implementation replaces the conventional assumption of pre-existing temporal background geometry with a recursive continuation framework governed by:

  • informational state evolution,
  • boundary-constrained admissibility,
  • coherence preservation,
  • invariant continuity,
  • and recursive update ordering.

Under this formulation, temporal progression exists only when structurally valid successor states can be generated and maintained.

Core Structural Principle

The flow establishes the following equivalence:

\[ \mathrm{Time} \equiv \mathrm{Recursive\ Admissible\ State\ Transition} \]

A system progresses temporally only if:

\[ V_t \neq \emptyset \]

where:

\[ V_t = \left\{ x \in E_t \mid x \models (B \land K) \right\} \]

This means:

  • candidate successor states are generated,
  • invalid continuations are removed,
  • and only structurally admissible updates are permitted.

Time therefore becomes the persistence of recursive coherence rather than motion through a universal clock.

Recursive Temporal Generation

The flow implements temporal evolution through sequential recursive operations:

1. Informational State Definition

The system begins with:

\[ S_t = (I_t, R, B, K) \]

which defines:

  • the current informational configuration,
  • recursive transformation rules,
  • boundary constraints,
  • and structural invariants.

This forms the complete recursive state from which temporal continuation may emerge.

2. Candidate Future Expansion

Possible successor states are generated through recursive expansion:

\[ E_t = \operatorname{expand}(I_t, R) \]

This represents all theoretically reachable continuations under the recursive rule system.  Importantly, these are not yet physically admissible states.

3. Constraint Filtering

The flow then implements admissibility filtering:

\[ V_t = \left\{ x \in E_t \mid x \models (B \land K) \right\} \]

This removes:

  • contradictory states,
  • unstable configurations,
  • boundary violations,
  • and invariant-breaking continuations.

Only coherence-preserving successor states survive.  This stage is the structural origin of lawful temporal evolution.

4. Recursive Continuation Test

The flow next evaluates whether temporal progression remains possible:

\[ V_t \neq \emptyset \]

If no admissible successor exists:

Vt​=∅

then recursive continuation fails.  Within the HST framework, this corresponds to:

  • temporal collapse,
  • contradiction termination,
  • or non-surviving recursive structure.

Time therefore cannot continue independently of structural admissibility.

5. Temporal Update Execution

When a valid successor exists, the system performs:

\[ I_{t+1} = \operatorname{update}(I_t, x^\ast) \]

where:

\[ x^\ast \in V_t \]

The transition itself defines temporal progression.  The flow therefore implements time as:

  • recursive update ordering,
  • admissible state continuation,
  • and coherence-preserving structural evolution.

Emergent Arrow of Time

The flow also implements temporal asymmetry.  Because recursive updates generally cannot perfectly reconstruct previous coherence configurations:

\[ I_t \rightarrow I_{t+1} \]

while typically:

\[ I_{t+1} \nrightarrow I_t \]

the system develops irreversible directional evolution.

This produces:

  • entropy increase,
  • causal ordering,
  • memory asymmetry,
  • and temporal directionality.

The arrow of time therefore emerges from recursive irreversibility rather than from an independent thermodynamic law.

Coherence-Based Relativistic Time

The implementation further models variable temporal rates through recursive coherence density.

Systems under:

  • high gravitational load,
  • high energetic curvature,
  • or increased coherence tension

require more recursive stabilization work per update cycle.  This reduces effective recursive advancement frequency.

Observed relativistic time dilation is therefore implemented as:

1

\[ \Delta T \propto \mathrm{Recursive\ Update\ Density} \]

rather than geometric distortion of an independent temporal dimension.

Identity Persistence Across Time

The flow implements persistence of identity through invariant continuity.  An object remains structurally identical across recursive updates when:

  • recursive invariants survive,
  • coherence remains admissible,
  • and update continuity is preserved.

Thus:

Identity≡Invariant Recursive Continuity

Temporal persistence becomes a structural property of recursive survival.

Geometry as Secondary Projection

Importantly, the flow does not use spacetime geometry as the primary generator of temporal evolution.

Instead:

  • recursive informational evolution generates coherence,
  • coherence generates geometric projection,
  • and observed spacetime emerges secondarily.

Thus:

\[ D_t = G(I_t) \]

while:

\[ D_t \nrightarrow (I_t, R, B, K) \]

Geometry is therefore downstream of recursive update structure.

HST-Level Interpretation

Within the Holographic Space-Time framework, this flow implements a universe that recursively updates itself through admissible informational continuation.

Time is not a container through which reality moves.

Instead:

  • reality recursively stabilizes,
  • admissible updates propagate,
  • coherence survives,
  • and ordered recursive continuation is experienced as time itself.

The flow therefore formalises the central HST principle that:

Reality updates itself recursively

and that temporal existence is the ordered persistence of those recursive updates.

How to Read This Flow

Scientific Reading Guide

The Time as Recursive Update flow should not be interpreted as a conventional time-evolution equation operating inside a pre-existing temporal dimension. Instead, the flow itself defines the mechanism through which temporal ordering emerges from recursive informational continuation.

In this framework:

  • the system does not evolve through time,
  • recursive update ordering creates what observers interpret as time.

The flow therefore represents a recursive admissibility engine rather than a clock-based evolution model.

Contact Us

1. Begin with the Recursive State Definition

The flow starts with the total recursive system state:

\[ S_t = (I_t, R, B, K) \]

This defines the complete structural condition of the system at recursive index tt.

Meaning of Each Component
Symbol Meaning
\( I_t \) Informational state at recursive step \( t \)
\( R \) Recursive transformation rules
\( B \) Boundary constraints
\( K \) Structural invariants

This means the system is never described solely by matter or geometry.  Instead, existence is defined through:

  • information,
  • rules,
  • constraints,
  • and invariant-preserving structure.

The recursive state is therefore the true physical substrate of temporal evolution.

2. Read Expansion as Potential Futures

The next operation is:

\[ E_t = \operatorname{expand}(I_t, R) \]

This step generates all possible recursive continuations allowed by the transformation rules.

Importantly:

\[ E_t \]

does not represent physically valid futures yet.  It represents the complete candidate continuation space before structural filtering occurs.

Think of this as:

  • recursive possibility generation,
  • state branching,
  • or informational future expansion.

3. Read Constraint Filtering as Physical Law

The flow next applies:

\[ V_t = \left\{ x \in E_t \mid x \models (B \land K) \right\} \]

This is one of the most important parts of the entire framework.

It means:

  • every candidate future is tested,
  • invalid continuations are removed,
  • only coherence-preserving states survive.
Interpreting the Symbols
Symbol Meaning
\( x \) Candidate successor state
\( x \models (B \land K) \) Candidate satisfies constraints and invariants
\( V_t \) Set of admissible successor states

This stage defines physical law itself. 
Physics becomes:

admissibility filtering over recursive state evolution.

The system does not “choose” arbitrary futures.  It can only continue through structurally valid recursive pathways.

4. Read Non-Empty Admissibility as Temporal Existence

The flow then evaluates:

\[ V_t \neq \emptyset \]

This statement is interpreted as:

A valid recursive continuation exists.

If true:

  • temporal progression may continue,
  • recursive identity survives,
  • coherent existence persists.

If false:

\[ V_t = \emptyset \]

then:

  • no admissible future exists,
  • recursive continuation terminates,
  • and temporal progression fails.
  • This is the structural definition of contradiction collapse within recursive temporal systems.

5. Read the Update Step as Time Itself

The flow then performs:

\[ I_{t+1} = \operatorname{update}(I_t, x^\ast) \]

where:

\[ x^\ast \in V_t \]

This is the core conceptual inversion of the chapter. In conventional physics:

systems evolve inside time.

In this framework:

the recursive update itself generates temporal ordering.

Thus:

\[ I_t \rightarrow I_{t+1} \]

is not occurring within time. It is the mechanism that produces time.

6. Read Recursive Ordering as Temporal Direction

The ordering:

\[ I_t \rightarrow I_{t+1} \]

creates directional temporal structure.  The flow models this as recursive irreversibility.

Generally:

\[ I_{t+1} \nrightarrow I_t \]

because prior coherence configurations cannot usually be perfectly reconstructed.

This generates:

  • entropy,
  • causality,
  • memory direction,
  • and the arrow of time.

Temporal asymmetry therefore emerges naturally from recursive structural evolution.

7. Read Coherence Density as Relative Time Rate

The flow also models variations in temporal speed.

Systems with:

  • higher coherence tension,
  • stronger gravitational load,
  • or increased structural complexity

require greater recursive stabilization effort. This slows recursive update propagation.

Thus:

1

\[ \Delta T \propto \mathrm{Recursive\ Update\ Density} \]

This equation should be interpreted structurally rather than geometrically.

Observed time dilation becomes:

reduced recursive update advancement frequency.

Relativity is therefore reinterpreted through recursive coherence processing.

8. Read Identity as Recursive Persistence

The flow treats persistence across time as invariant continuity.

An object remains “the same object” when:

  • recursive invariants survive,
  • admissible continuation persists,
  • and coherence remains stable across updates.

Thus:

\[ \mathrm{Identity} \equiv \mathrm{Invariant\ Recursive\ Continuity} \]

Identity is not static substance persistence.

It is recursive structural survival.

9. Read Geometry as a Projection Layer

The flow does not treat spacetime geometry as fundamental.

Instead:

\[ D_t = G(I_t) \]

means geometry is projected from recursive informational structure.

Importantly:

\[ D_t \nrightarrow (I_t, R, B, K) \]

This means geometry cannot generate the recursive substrate itself.

Geometry is therefore:

  • observational,
  • emergent,
  • and downstream of recursive informational coherence.

10. Final Interpretation

When reading the full flow, interpret the entire structure as:

a recursive admissibility engine generating ordered coherent continuation.

The system:

  • 1. generates possible futures,
  • 2. filters invalid continuations,
  • 3. selects admissible successors,
  • 4. updates recursively,
  • 5. and projects temporal ordering from recursive survival.

Thus, the flow implements the HST interpretation that:

\[ \mathrm{Time} \equiv \mathrm{Recursive\ Admissible\ Continuation} \]

and that:

Reality updates itself recursively

rather than evolving inside an independently existing temporal dimension.

Flow → Equation Tri-Mapping

Flow Component Flow Algebra Structure Equation Mapping Physical Interpretation
Recursive State Definition \( S_t = (I_t, R, B, K) \) \( \text{State} \equiv (\text{Information}, \text{Rules}, \text{Constraints}, \text{Invariants}) \) Complete recursive system configuration
Informational State \( I_t \) \( I_t \rightarrow I_{t+1} \) Recursive informational evolution
Recursive Rules \( R \) \( E_t = \operatorname{expand}(I_t, R) \) Generates candidate continuations
Boundary Constraints \( B \) \( x \models B \) Enforces admissible structural boundaries
Structural Invariants \( K \) \( x \models K \) Preserves recursive identity and consistency
Candidate Expansion \( E_t \) \( E_t = \operatorname{expand}(I_t, R) \) Full recursive future possibility space
Admissibility Filtering \( V_t = \{ x \in E_t \mid x \models (B \land K) \} \) \( x \in V_t \iff x \models (B \land K) \) Physical law as recursive filtering
Temporal Existence Condition \( V_t \neq \emptyset \) \( \exists x^* \in V_t \) Valid recursive continuation exists
Temporal Failure \( V_t = \emptyset \) \( \nexists x^* \) No admissible future state
Successor Selection \( x^* \in V_t \) \( x^* = \arg\max_{x \in V_t} P(x \mid I_t, R, B, K) \) Highest admissible continuation selected
Recursive Update \( I_{t+1} = \operatorname{update}(I_t, x^*) \) \( I_t \rightarrow I_{t+1} \) Recursive state transition
Time Definition Recursive Update Ordering \( \text{Time} \equiv I_t \rightarrow I_{t+1} \) Time emerges from recursive continuation
Temporal Ordering \( S_t \rightarrow S_{t+1} \) \( \tau_t < \tau_{t+1} \) Ordered recursive progression
Arrow of Time Irreversible Recursive Transition \( I_t \rightarrow I_{t+1} \not\rightarrow I_t \) Temporal asymmetry from irreversibility
Entropy Emergence Coherence Loss Accumulation \( \Delta S \propto \text{Irreversible Update Density} \) Entropy from recursive non-reconstruction
Coherence Threshold \( C_t \geq C_{\min} \) \( C_t < C_{\min} \Rightarrow \mathrm{FAIL} \) Recursive continuation stability condition
Recursive Persistence Invariant Survival \( I_{t+1} \models K \) Identity continuity across updates
Identity Definition Recursive Continuity \( \text{Identity} \equiv \text{Invariant Recursive Continuity} \) Persistence through admissible updates
Relative Time Rate Recursive Density Variation \( \Delta T \propto \frac{1}{\text{Recursive Update Density}} \) Time dilation as slowed recursive advancement
Geometry Projection \( D_t = G(I_t) \) \( D_t \leftarrow I_t \) Geometry emerges from recursive structure
Geometry Non-Generative Principle Geometry Cannot Generate State \( D_t \not\rightarrow (I_t, R, B, K) \) Spacetime is downstream, not fundamental
Recursive Temporal Continuation Sequential Admissible Updates \( S_t \rightarrow S_{t+1} \rightarrow S_{t+2} \) Ordered coherent existence chain
Execution Guarantee Admissible Successor Requirement \( V_t \neq \emptyset \Rightarrow \operatorname{Execution}(S_t) \) Time exists only if recursive continuation exists
Contradiction Collapse Recursive Termination \( V_t = \emptyset \Rightarrow \mathrm{FAIL} \) Temporal progression structurally halts
HST Time Principle Recursive Temporal Emergence \( \text{Time} \equiv \text{Recursive Admissible Continuation} \) Time is emergent recursive ordering

Chapter 25 — Time as Recursive Update

Diagram Overview

This diagram presents the HST reinterpretation of time as an emergent recursive phenomenon rather than an independently existing physical dimension. The illustration formalises temporal progression as the ordered sequence of admissible informational state updates occurring within a recursively constrained coherence system.

Instead of modelling time as a universal background parameter, the diagram shows that temporal existence arises only when recursive continuation remains structurally admissible under boundary constraints and invariant preservation.

The diagram therefore replaces classical clock-based evolution with a recursive admissibility architecture.

1. Recursive State Definition

The diagram begins with the foundational recursive system state:

\[ S_t = (I_t, R, B, K) \]

This block defines the total recursive configuration of the system at update index tt.

Where:

Symbol Meaning
\( I_t \) Informational state
\( R \) Recursive transformation rules
\( B \) Boundary constraints
\( K \) Structural invariants

This establishes the core HST principle that reality is fundamentally informational and recursively constrained rather than fundamentally geometric.

The system state contains all structures required for recursive temporal continuation.

2. Candidate Expansion

The second block defines recursive future generation:

\[ E_t = \operatorname{expand}(I_t, R) \]

This operation generates the complete candidate successor space reachable under the recursive rule system.

Importantly, the diagram shows that this stage produces:

  • possible continuations,
  • not yet valid continuations.

The expansion stage therefore represents recursive possibility generation prior to physical admissibility filtering.

This distinguishes:

  • potential futures,
  • from coherence-preserving futures.

3. Admissibility Filtering

The central filtering stage is represented by:

\[ V_t = \left\{ x \in E_t \mid x \models (B \land K) \right\} \]

This is the structural law-enforcement mechanism of the system.

The diagram illustrates that:

  • every candidate state is tested,
  • invalid continuations are removed,
  • only admissible recursive successors survive.

This operation implements:

  • physical law,
  • coherence preservation,
  • and recursive consistency enforcement.

In HST, physics itself emerges from recursive admissibility filtering.

4. Temporal Existence Test

The decision node evaluates:

\[ V_t \neq \emptyset \]

This represents the existence condition for temporal continuation.

If true:

  • recursive progression survives,
  • temporal ordering continues,
  • coherent existence persists.

If false:

\[ V_t = \emptyset \]

then no admissible future exists.

The diagram labels this as:

FAIL — No admissible future. Temporal progression terminates.

This implements contradiction collapse as recursive temporal failure. Time cannot continue independently of structural admissibility.

5. Successor Selection

When admissible states exist, the system selects:

\[ x^\ast = \operatorname{select}(V_t) \]

The diagram interprets this as:

selecting the highest-coherence admissible successor.

This stage models recursive state stabilization through coherence optimisation.  The system therefore evolves through structurally survivable pathways rather than arbitrary transitions.

6. Recursive Update

The update block performs:

\[ I_{t+1} = \operatorname{update}(I_t, x^\ast) \]

This operation is one of the central conceptual reversals of the chapter.

The diagram demonstrates that:

  • the recursive update is not occurring inside time,
  • the update itself generates temporal progression.

The transition:

\[ I_t \rightarrow I_{t+1} \]

is therefore interpreted as the physical origin of temporal ordering.

7. Time Emerges from Ordered Updates

The lower-right block explicitly states:

\[ I_t \rightarrow I_{t+1} \]

and identifies this ordered recursive progression as:

what is experienced as time.

This is the central HST reinterpretation. Time is not an external flowing dimension.

Instead:

\[ \mathrm{Time} \equiv \mathrm{Ordered\ Recursive\ Continuation} \]

The diagram therefore visualises time as a structural consequence of recursive admissible updates.

8. Temporal Progression Chain

The central horizontal sequence:

\[ S_t \rightarrow S_{t+1} \rightarrow S_{t+2} \]

illustrates recursive temporal persistence across update indices:

\[ \tau_t,\; \tau_{t+1},\; \tau_{t+2} \]

This chain represents:

  • coherent recursive survival,
  • ordered informational continuation,
  • and temporal persistence.

The recursive index does not represent an external clock.

It represents ordered update progression within the recursive system itself.

9. Arrow of Time

The left-side block models temporal asymmetry:

\[ I_t \rightarrow I_{t+1} \]

while generally:

\[ I_{t+1} \nrightarrow I_t \]

The diagram explains this as:

irreversibility arising because prior coherence configurations generally cannot be reconstructed.

This generates:

  • entropy,
  • causal direction,
  • memory asymmetry,
  • and irreversible temporal flow.

The arrow of time therefore emerges naturally from recursive structural irreversibility.

10. Relative Time Rate

The lower-left equation:

1

\[ \Delta T \propto \mathrm{Recursive\ Update\ Density} \]

models relativistic temporal variation.

The diagram explains that:

  • higher coherence tension,
  • stronger recursive stabilization load,
  • or increased structural complexity

reduce effective recursive update frequency. This produces slower observed temporal progression.

Thus, relativistic time dilation is reinterpreted as recursive update-density variation rather than deformation of an independently existing temporal dimension.

11. Identity Persistence

The identity block defines:

\[ \mathrm{Identity} \equiv \mathrm{Invariant\ Recursive\ Continuity} \]

The diagram shows that objects persist across time only when their structural invariants survive recursive updates.

Identity is therefore not static substance permanence.  It is recursive coherence continuity across admissible state transitions.

12. Geometry as Projection

The geometry block presents:

\[ D_t = G(I_t) \]

while also stating:

\[ D_t \nrightarrow (I_t, R, B, K) \]

This means geometry is generated from recursive informational structure but cannot generate the recursive substrate itself.

Spacetime therefore becomes:

  • emergent,
  • observational,
  • and downstream of recursive coherence evolution.

13. Execution Guarantee

The bottom execution guarantee formalises the system survival condition:

\[ V_t \neq \emptyset \quad \text{and} \quad C_t \geq C_{\min} \]

If satisfied:

  • recursive update exists,
  • time continues,
  • coherence survives.

Otherwise:

  • recursive continuation fails,
  • and temporal progression terminates.

This defines temporal existence itself as a consequence of recursive admissibility preservation.

Final Scientific Interpretation

The complete diagram should be interpreted as a recursive temporal-generation engine.

The system:

  • 1. defines recursive informational structure,
  • 2. generates candidate futures,
  • 3. filters invalid continuations,
  • 4. selects admissible successors,
  • 5. recursively updates,
  • 6. and projects ordered continuation as temporal experience.

The diagram therefore formalises the HST principle that:

Reality recursively updates itself

and that:

Time is the ordered persistence of admissible recursive continuation.

Diagram → Flow Mapping Table

Diagram Element Flow Algebra Component Equation Mapping Structural Meaning
Recursive State Definition Block S_t = (I_t,R,B,K) \( S_t = (I_t,R,B,K) \) Defines the complete recursive system state
Informational State I_t \( I_t \) Current informational configuration
Recursive Rules R \( E_t = \operatorname{expand}(I_t,R) \) Generates recursive candidate continuations
Boundary Constraints B \( x \models B \) Restricts invalid structural states
Structural Invariants K \( x \models K \) Preserves coherence and identity continuity
Candidate Expansion Box expand(I_t,R) \( E_t = \operatorname{expand}(I_t,R) \) Generates all possible recursive futures
Candidate Successor Space E_t \( x \in E_t \) Full pre-filtered continuation set
Admissibility Filtering Box V_t construction \( V_t = \{ x \in E_t \mid x \models (B \land K) \} \) Removes incoherent or contradictory continuations
Admissible State Set V_t \( x \in V_t \iff x \models (B \land K) \) Physically survivable recursive states
Temporal Existence Decision Node V_t != empty \( V_t \neq \emptyset \) Tests whether recursive continuation exists
FAIL Block temporal_update_failure \( V_t = \emptyset \Rightarrow \mathrm{FAIL} \) No admissible future exists
Successor Selection Box x_star = select(V_t) \( x^* \in V_t \) Selects highest admissible continuation
Coherence Optimisation select_highest_coherence_candidate(V_t) \( x^* = \arg\max_{x \in V_t} P(x \mid I_t,R,B,K) \) Stabilises recursive continuation
Recursive Update Box update(I_t,x_star) \( I_{t+1} = \operatorname{update}(I_t,x^*) \) Performs recursive state transition
Temporal Ordering Arrow S_t -> S_t+1 \( I_t \rightarrow I_{t+1} \) Ordered recursive progression
Time Emergence Box Ordered Update Chain \( \text{Time} \equiv I_t \rightarrow I_{t+1} \) Time emerges from recursive continuation
Temporal Progression Chain S_t -> S_t+1 -> S_t+2 \( S_t \rightarrow S_{t+1} \rightarrow S_{t+2} \) Persistent recursive survival chain
Recursive Index Labels tau_t \( \tau_t < \tau_{t+1} < \tau_{t+2} \) Ordered recursive update indexing
Arrow of Time Block Irreversible Update Structure \( I_t \rightarrow I_{t+1} \not\rightarrow I_t \) Temporal asymmetry from irreversibility
Entropy Emergence Recursive Information Loss \( \Delta S \propto \text{Irreversible Update Density} \) Entropy from non-reconstructible updates
Relative Time Rate Box Recursive Density Variation \( \Delta T \propto \frac{1}{\text{Recursive Update Density}} \) Time dilation as slowed recursive advancement
Coherence Density Effect C_t regulation \( C_t \geq C_{\min} \) Stability threshold for recursive continuation
Identity Persistence Box Invariant Continuity \( \text{Identity} \equiv \text{Invariant Recursive Continuity} \) Persistence through recursive invariant survival
Geometry Projection Box D_t = G(I_t) \( D_t = G(I_t) \) Geometry emerges from recursive information
Geometry Non-Generative Statement Projection Constraint \( D_t \not\rightarrow (I_t,R,B,K) \) Geometry cannot generate recursive substrate
Recursive Feedback Arrows Recursive Coupling \( S_t \leftrightarrow V_t \leftrightarrow S_{t+1} \) Continuous recursive stabilization
Execution Guarantee Box Recursive Survival Condition \( V_t \neq \emptyset \land C_t \geq C_{\min} \Rightarrow \mathrm{Execution} \) Conditions required for temporal continuation
Recursive Failure Condition Contradiction Collapse \( V_t = \emptyset \Rightarrow \text{Temporal Collapse} \) Recursive temporal termination
Entire Diagram Structure Recursive Temporal Engine \( \text{Time} \equiv \text{Recursive Admissible Continuation} \) Full HST temporal emergence model

Execution Guarantee Statement

Chapter 25 — Time as Recursive Update

The Time as Recursive Update flow guarantees that temporal progression can occur only if a structurally admissible recursive successor state exists and coherence preservation remains above the minimum stability threshold.

Formally, recursive temporal continuation is guaranteed only when:

\[ V_t \neq \emptyset \]

where:

\[ V_t = \left\{ x \in E_t \mid x \models (B \land K) \right\} \]

and simultaneously:

\[ C_t \geq C_{\min} \]

Under these conditions:

\[ \exists x^\ast \in V_t \]

allowing recursive update execution:

\[ I_{t+1} = \operatorname{update}(I_t, x^\ast) \]

This guarantees:

  • valid recursive continuation,
  • preservation of structural invariants,
  • coherence-stable temporal ordering,
  • and persistence of admissible informational evolution.

The system therefore guarantees:

\[ S_t \rightarrow S_{t+1} \]

and recursively:

\[ S_t \rightarrow S_{t+1} \rightarrow S_{t+2} \rightarrow \cdots \]

producing observable temporal progression through ordered recursive state updates.

Temporal Existence Guarantee

Within this framework:

Time Exists⟺Vt​=∅

Time is therefore not independently guaranteed as a background dimension.  Temporal existence itself depends upon recursive admissibility preservation.

If no valid successor exists

\[ V_t = \emptyset \]

then:

\[ \nexists x^\ast \]

and therefore:

\[ \nexists I_{t+1} \]

which produces:

\[ \mathrm{Execution}(S_t) = \mathrm{FAIL} \]

This corresponds to:

  • recursive contradiction collapse,
  • temporal termination,
  • or non-surviving informational structure.
Telephone:
01377 236594
Contact Us

Coherence Stability Guarantee

The flow further guarantees that temporal continuation cannot proceed through unstable coherence configurations.

If:

\[ C_t < C_{\min} \]

then recursive stabilization fails, producing:

Recursive Continuation Failure

Thus, admissible recursive continuation requires both:

  • 1. structurally valid successor states,
  • 2. and sufficient coherence preservation.

This prevents:

  • unconstrained recursive divergence,
  • invariant collapse,
  • and invalid temporal propagation.

Arrow of Time Guarantee

The flow guarantees directional temporal ordering through recursive irreversibility.  Because prior coherence configurations are generally non-reconstructible:

\[ I_t \rightarrow I_{t+1} \]

while:

\[ I_{t+1} \nrightarrow I_t \]

the recursive system naturally generates:

  • entropy increase,
  • causal asymmetry,
  • memory direction,
  • and irreversible temporal progression.

The arrow of time therefore emerges automatically from recursive update structure.

Identity Persistence Guarantee

The framework guarantees persistence of identity only when invariant continuity survives recursive updates.

Formally:

\[ I_{t+1} \models K \]

must remain true across recursive continuation.

Thus:

Identity≡Invariant Recursive Continuity

Objects persist through time only if recursive invariants survive admissible state evolution.

Geometry Constraint Guarantee

The flow guarantees that geometry remains secondary to recursive informational structure.

Geometry may emerge through:

\[ D_t = G(I_t) \]

but geometry itself cannot generate recursive continuation:

\[ D_t \nrightarrow (I_t, R, B, K) \]

Thus:

  • spacetime remains emergent,
  • recursive structure remains primary,
  • and temporal progression is generated informationally rather than geometrically.

Final Guarantee Statement

The Time as Recursive Update flow guarantees that:

Temporal progression exists if and only if recursive admissible continuation exists.

Therefore:

\[ V_t \neq \emptyset \;\land\; C_t \geq C_{\min} \]

guarantees:

Recursive Temporal Continuation

while:

\[ V_t = \emptyset \]

guarantees:

Temporal Failure

The framework therefore formalises the HST principle that:

Time is not fundamental existence
but instead:
Time is the ordered persistence of admissible recursive updates.
Section Chapters
Privacy Policy
Site Map
Kireth Research
38 Thorndale Croft, Wetwang, Driffield
East Riding of Yorkshire YO25 9XZ
Telephone: 01377 236594
Designed By
Kireth Web Design
Audio Explainer RSS Feed