Just a simple question.

Since you have absolute time and universal time,

Which time are you referring to when discussing relativity phenomena such as beta ?

Do they give the same or different answers ?

@swansont

My apologies, you are entirely right. I got carried away expanding the model before cleanly wrapping up the core objections you and MigL raised regarding energy conservation and time travel. Let's look at that directly.

@MigL is absolutely correct that in General Relativity, the stress-energy tensor obeys a local conservation law (\(\nabla_\mu T^{\mu\nu} = 0\)), and global energy conservation is notoriously ambiguous in a dynamic spacetime. From a purely classical GR standpoint, my initial thermodynamic restriction against past time travel was flawed, and I concede that.

However, my argument shifts from GR thermodynamics to strict information theory constraints within a state-based architecture.

To use a fun thought experiment: let’s say we send MigL himself exactly 1 minute back into the past. Does he exist twice simultaneously within that past universal frame?

In a classical geometric spacetime, you might argue for overlapping worldlines. But in a discrete computational model, "the past" does not physically exist as a parallel layer of storage; the system only holds the active state vector in its current hardware registry. For MigL to occupy that past frame alongside his past self, the Universal Computer would have to execute an illegal "Copy and Paste" operation, duplicating his entire data structure and pointers. If he doesn't explicitly disappear from the present registry (a strict "Cut and Paste" data relocation), the local system matrix faces an instant memory state violation.

Conversely, what if we send MigL 1 minute into the future? In this framework, that is perfectly legal. The processor simply applies a thread sleep or scheduling delay to his data structure. For that 1 minute in the present, he completely disappears from the 3D screen registry (consuming zero local rendering resources). After 1 minute's worth of universal ticks passes, his pointer is re-inserted into the active registry frame, and he instantly reappears. No duplication, no paradox.

So, unless the universe has a way to handle a duplicated "MigL data structure" in the past without crashing its local node allocation boundaries, information theory—rather than global GR energy conservation—strictly forbids past travel while naturally permitting future time skips.

Does this distinction between GR's local geometric conservation and a strict informational state boundary address your objection more clearly?

@studiot

To answer your question directly: when discussing relativistic phenomena such as \(\beta \), we are referring strictly to Local Time (the time measured by observers inside the 3D screen).

Observers inside the simulation have no direct access to the background Universal Time (\(n \to n+1\)); they can only measure intervals using clocks made of local matter-fields, which are themselves subject to the grid's rendering limits.

However, they give mathematically consistent answers because Local Time is a geometric projection of Universal Time.

Think of it this way:
When an observer calculates a discrete velocity \(\beta = \Delta x / \Delta t_{local}\), they are measuring how many grid pixels (\(\Delta x\)) an object shifted relative to a local clock's rendering cycle (\(\Delta t_{local}\)).

Behind the scenes, at the hardware layer, the central processor sees this exact same event in terms of Universal Time ticks (\(\Delta \) t_{universal}). The processor knows that the object required a budget of \(n+k+j\) universal frames to execute that shift.

Because the local clock's update rate drops by exactly the Lorentz factor (\(\gamma \)) relative to the universal clock budget due to the state-conservation law I mentioned earlier, the relativistic math matches perfectly from both perspectives.

So, to summarize: the measurement is done in Local Time (which is why relativity works for us), but the execution happens in Universal Time. They don't give conflicting answers; rather, Universal Time is the objective hardware baseline that explains why Local Time dilates exactly the way Einstein calculated.

I'm not sure about this 'universe as a computational engine' analogy.
What new predictions does it bring; and are they testable ?

2 hours ago, Time Traveler said:

When massive star-remnants collapse and condense into black holes, the system executes a maximum compression routine. Trillions of individual data points (particles) that previously occupied distinct, fragmented memory addresses across separate cells are "zipped" into highly dense, contiguous, localized blocks.
By doing this, the central processor drastically reduces the information entropy of that sector and frees up an immense amount of background operational memory (RAM) that was previously dedicated to tracking those particles individually.

For example
Maybe how an entropic optimization force as governed by the second law of infodynamics produces Newton's Gravity, or even Einstein's Gravity, both of which fail with Black Holes, but you are, nonetheless, extending the infodynamics theory to encompass Black Holes.

Or for another example example
Lossless compression simply rearranges data/information more efficiently.
It gets rid of spaces, place holders, etc.; but the information is all still there.

Lossy compression, like MP3, gets rid of data/information that the human ear can't pick up ( too bad for dogs ), so lossy information is a non-starter, as it violates unitarity of Quantum information at the creation of Black Holes ( not just in the evaporation phase of Hawking-Bekenstein theory ).

My asking is just making a point.
I'm not asking for another unsupported post taking up half the page; answer questions that have been posed, then move onto falsifiable parts of your 'theory'; don't just present the whole, and expect us to sort through the chaff.

1 hour ago, Time Traveler said:

unless the universe has a way to handle a duplicated "MigL data structure" in the past

I don't know how you got on this time-travel tangent, but duplicating data structures is strictly forbidden in the past, future, or any time.
The Heisenberg Uncertainty Principle dictates how closely you can know, and reproduce, Quantum states.
So there will be no duplicating MigL of any kind ...
(unless you have Star Trek's 'Heisenberg Compensators' in your Transporter )

If this thread is about a Matrix theory (i.e. our universe is a digital computer simulation), then how would we even be able to test its core assertion of that? I can't see bothering with the rest if we have no way to test this.

2 hours ago, Time Traveler said:

To answer your question directly: when discussing relativistic phenomena such as β, we are referring strictly to Local Time (the time measured by observers inside the 3D screen).

Thank you for that clear answer. I will-ponder the implications.

It would be good if you could also address my earlier question about rate of transference of information.

A quick recap

How does your universal master controller access and send data to the extremes of the universe in a consistent manner, since you model incorporates the limitations of Relativity ?

Thank you all for pushing the model into the territory of actual physics. Let’s address the core constraints you’ve raised directly and concisely, shifting from soft analogies to strict architectural specifications.

1. @MigL on Compression and Unitarity:
The compression routine is strictly lossless, fully preserving Quantum Unitarity. Information is never destroyed. Think of a sparse matrix in computing. Tracking trillions of scattered particles requires immense individual coordinate tracking. When gravity clusters them into a black hole, the system switches to a macro-state representation. The fundamental information is safely stored holographically on the 2D boundary (matching Bekenstein-Hawking entropy limits), but the processor no longer wastes clock cycles updating separate individual spatial degrees of freedom on the 3D grid. It’s a reduction in operational indexing overhead, not a loss of data. (And fully agreed on Heisenberg—no cloning of your data structure is permitted!) [1, 2, 3, 4]

2. @TheVat & MigL on Testable Predictions (Falsifiability):
A discrete computational model operating at a granular scale predicts a maximum cutoff frequency for gravitational waves and a subtle dispersive effect in the vacuum for ultra-high-energy cosmic rays (UHECRs). If spacetime is a discrete grid working at a master frame rate, photons of extreme energies (near the Planck scale) must experience a tiny, cumulative phase shift or arrival delay compared to lower-energy photons over cosmic distances, because they probe the pixel limits of the 3D screen. If vacuum propagation is proven to be perfectly continuous to infinity, this model is falsified. [1, 2, 3]

3. @studiot on Information Transference Lag & Temporal Framework:
To clarify the math, let's look at the frequency boundaries. The background clock runs at a quasi-absolute master frequency (\(f_{master} = 10^{65}\) Hz or even \(10^{200}\) Hz). The 3D screen operates at a much lower refresh rate, where vacuum light rendering peaks exactly at the Planck frequency (\(f_{light} = 10^{43}\) Hz). [1]

Therefore, light frequency is a step-down from the master clock: \(f_{light} = f_{master} - K = 10^{43}\) Hz. A massive object introduces a computational overhead parameter (\(Q\)), forcing its local rendering frequency to drop further: \(f_{mass} = f_{master} - K - Q\).

Because of this architecture, the Master Controller does not "send data across space" using signals inside the grid; the processor is non-local. It updates the entire matrix layout in the same global CPU cycle. Relativistic constraints (\(c=1\) pixel per local tick) only exist inside the rendered frontend environment for data structures translating between cells. Background synchronization is quasi-instantaneous at the hardware layer, maintaining quasi-simultaneous baseline updates while perfectly preserving relational Lorentz symmetry for observers trapped inside the local frame rates.

Hmmm, @Time Traveler, it appears to me that you haven't responded to @swansont's three clock scenario. The glaring problem I see with your theory is that it has an absolute rest frame, contrary to relativity. The way you appear to explain time dilation seems to indicate a misunderstanding of how time dilation arises in relativity. Anyway, suppose one observer is at rest and consider two other observers, one moving at β with respect to the observer at rest, and the other moving at –β with respect to the observer at rest. The question @swansont posed is how the two moving observers observe each other's clocks with regards to time dilation.

47 minutes ago, Time Traveler said:

Thank you all for pushing the model into the territory of actual physics.

Yes indeed actual Physics.

Thank you for responding, pity you addressed as different question from the one I asked so let me rephrase it a different way.

My question had nothing to do with frequency or temporal frameworks (whatever they are).

So (Astro) Physics : We know that there is a horizon beyond (in distance) which we cannot see.

You are proposing that nevertheless all cells or whatever you like to call them are pulsed together in time by the same pulse of your master clock.

This seems to me to be a classic 'action at a distance failure' since implies there is communication or commonality between cells beyond our horizon and those within our horizon.

This is the classic and crucial critique regarding the apparent breakdown of reciprocity in an absolute background framework. Let’s address the three-clock scenario and the question of relativity directly by defining what a physical clock actually represents in this computational matrix.

A clock is not a device that measures an independent, flowing dimension called "time." Operationally, a clock is merely a localized template used to compare two distinct types of change: an arbitrary, non-periodic change (the event being timed) against a standardized, quasi-periodic change—whether that is an atomic oscillation, the mechanical sweeping of hands on a classical clockwork face, or the bouncing of a photon in Einstein's light clock.

In the framework you proposed, Observer A is at rest relative to the processing grid. Observer B moves at \(\beta \), and Observer C moves at \(-\beta \).

To understand what happens, we must differentiate between Local Time and Universal Time. Relativistic measurements (like \(\beta = \Delta x / \Delta t_{local}\)) are done strictly in Local Time by observers trapped inside the 3D screen, as they have no direct access to the background Universal Time hardware clock ticks (\(n \to n+1\)).

At the hardware layer, because the state-conservation law depends on the square of the velocity ratio (\(\beta ^{2}\)), the direction of translation is irrelevant. The central processor applies the exact same processing overhead to both moving entities. Therefore, relative to the universal background clock, both B's clock and C's clock are throttled by the exact same Lorentz factor (\(\gamma \)). At the hardware baseline, their intrinsic update rates are identical.

The core of the question is: how do B and C observe each other?

Observers B and C must measure each other exclusively by exchanging information carriers—photons—which are bound to the screen's maximum propagation speed (\(c = 1\) pixel per frame).

When Observer B uses their local clock template to measure the incoming light signals carrying the state updates of Observer C, the discrete pixel-stepping of the information exchange across the grid introduces a cumulative data latency. In Einstein's light clock model, because the screen's maximum refresh rate for light is absolute (\(f_{light} = 10^{43}\) Hz), the photon tracking the diagonal path cannot accelerate to compensate for the displacement vector. A percentage of its frame allocation is consumed by the motion across pixels, leaving fewer ticks for the vertical round-trips.

When B decodes these signals, the relational math of the information transfer perfectly reproduces the standard relativistic result: B measures C's clock as running slower than their own. Because the grid geometry and light propagation rules are uniform, when C measures B, the exact same informational latency occurs in reverse. C measures B's clock as running slower than their own. Reciprocal time dilation is a strict emergent software symmetry governing relational observations, executed on a synchronized, quasi-absolute hardware baseline.

To address @swansont's underlying concern about time travel using a fun thought experiment: let’s say we send MigL himself exactly 1 minute back into the past. Does he exist twice simultaneously within that past universal frame?

In a continuous geometric spacetime, you might argue for overlapping worldlines. But in a discrete state-machine, "the past" does not physically exist as a parallel layer of storage; the system only holds the active state vector in its current registry. For MigL to occupy that past frame alongside his past self, the Universal Computer would have to execute an illegal "Copy and Paste" operation, duplicating his entire data structure and violating the system's memory allocation boundaries. Conversely, sending MigL 1 minute into the future is perfectly legal: the processor simply applies a scheduling delay (thread sleep) to his data structure, turning off his rendering function in the present frame until 1 minute's worth of universal ticks passes. No duplication, no paradox.

So, unless the universe has a way to handle a duplicated data structure in the past without crashing its local node allocation limits, information theory—rather than global GR energy conservation—strictly forbids past travel while naturally permitting future frame skips and reciprocal relativity.

---

@studiot

I see exactly where the disconnect is. You are looking at the synchronization as if it requires a signal to travel through the 3D space from one side of the horizon to the other. If that were the case, it would indeed be a catastrophic "action at a distance" failure.

But in a computational framework, the Master Clock does not send a spatial signal across the grid. The processor is entirely non-local relative to the 3D screen.

Think of a massive multiplayer online game running on a central server. The server updates the state variables of the entire map array in the exact same hardware clock cycle. A player standing on one side of the virtual world cannot see or communicate with a player on the other side because of the game's internal speed-of-light rendering limits (the game's software horizon). Yet, at the hardware layer, both regions are synchronized by the same central CPU pulse.

The cosmic horizon limits communication inside the frontend environment (from pixel to pixel), but it does not restrict the backend hardware architecture from updating all registry addresses simultaneously. There is no information "traveling" across the universe to achieve this synchronization; every single node in the matrix is directly adjacent to the central processor at the hardware level.

Edited Thursday at 09:46 PM2 days by Time Traveler
Corrected 'quasi-absolute' spelling

7 minutes ago, Time Traveler said:

---

@studiot

I see exactly where the disconnect is. You are looking at the synchronization as if it requires a signal to travel through the 3D space from one side of the horizon to the other. If that were the case, it would indeed be a catastrophic "action at a distance" failure.

But in a computational framework, the Master Clock does not send a spatial signal across the grid. The processor is entirely non-local relative to the 3D screen.

Think of a massive multiplayer online game running on a central server. The server updates the state variables of the entire map array in the exact same hardware clock cycle. A player standing on one side of the virtual world cannot see or communicate with a player on the other side because of the game's internal speed-of-light rendering limits (the game's software horizon). Yet, at the hardware layer, both regions are synchronized by the same central CPU pulse.

The cosmic horizon limits communication inside the frontend environment (from pixel to pixel), but it does not restrict the backend hardware architecture from updating all registry addresses simultaneously. There is no information "traveling" across the universe to achieve this synchronization; every single node in the matrix is directly adjacent to the central processor at the hardware level.

There is no disconnect.

Yes indeed the central server updates state variables in one clock cycle.

But this is only possible because the distances involved, even in the largest datacentre, are negligible compared to the time to parse the lot.

You may not know that as electronic hardware design developed processor speeds have been limited by the need to synchronise signals that appear on different sides of the chips because the path lengths are different. I used to know the theory of all this but have not kept up with the latest computer clock speeds; I let others do it these days.

But you are claiming that these updates are carried out over distances the size of the universe.

2 hours ago, studiot said:

But you are claiming that these updates are carried out over distances the size of the universe.

If I'm following this, I think they are posting that our universe simulation runs on hardware which is many orders of magnitude smaller than its simulation appears to be. I.e. of a size where global updates may take place within a clock cycle. This "higher shell" of universe (a metauniverse from our perspective) is where the "nonlocality" is effectuated.

Some very non-Ockham speculation, it would seem, and then invites also questions of whether or not higher universe shells all operate with the same physical constants. For example, one could speculate that we are merely a toy universe loaded for pedagogical purposes. A problem with all this is it pulls out the rug from under honest attempts at "actual physics." Grr.

4 hours ago, Time Traveler said:

Think of a massive multiplayer online game running on a central server. The server updates the state variables of the entire map array in the exact same hardware clock cycle. A player standing on one side of the virtual world cannot see or communicate with a player on the other side because of the game's internal speed-of-light rendering limits (the game's software horizon). Yet, at the hardware layer, both regions are synchronized by the same central CPU pulse.

That may be fine and dandy in a game, but, in the actual universe involving horizons determined by the speed of light/causality, information transfer would necessitate superluminal transfers.
Last I checked that was impossible.

@studiot would like to know how the 'state variable' can be communicated to regions that are beyond the observable ( causality determined ) horizon.
If no superluminal speeds are involved, you cannot have a global 'central cpu pulse' ( for the entire universe ).

So are you wrong, or is relativity wrong ?
( I know which of the two has passed a hundred years of testing, and it's not your 'theory' )

@TheVat caught the core architectural concept perfectly, even if he dislikes the philosophical implications.

@studiot & @MigL – You are still making a fundamental category error. You are assuming that if the simulated 3D space measures billions of light-years across, the underlying physical hardware hosting the simulation must also stretch across billions of light-years. This is not how computer graphics or matrix architectures work.

Distance is an output of the software, not a constraint of the hardware.

In a matrix model, the 3D coordinate system we call "space" is just a mathematical index inside a data array. Two pixels that appear to be on opposite sides of the cosmic horizon (Frontend) are actually stored in adjacent, microscopic memory cells inside the central registry (Backend).

Therefore:

1. The Master Controller does not carry out updates "over distances the size of the universe." The physical size of the host machine is completely independent of the virtual size of the map it renders.

2. No information travels at superluminal speeds through our space to synchronize the horizon. The synchronization happens vertically (from the non-local CPU directly down into the memory address), not horizontally (from pixel to pixel across the 3D screen).

To answer MigL's ultimate question: Relativity is not wrong. Relativity is the absolute, unbroken law governing how data structures interact locally inside the rendered screen (Frontend). But the master clock synchronization is a non-local backend property operating outside the simulation's coordinate systems.

This is exactly why Quantum Mechanics allows non-local quantum entanglement (instantaneous correlation) while Special Relativity forbids superluminal communication. Quantum Mechanics is a glimpse into the shared backend memory array, while Relativity is the rigid law of the frontend rendering engine. They don't contradict each other; they operate on two completely different layers of the system architecture

---

8 hours ago, MigL said:

That may be fine and dandy in a game, but, in the actual universe involving horizons determined by the speed of light/causality, information transfer would necessitate superluminal transfers.
Last I checked that was impossible.

@studiot would like to know how the 'state variable' can be communicated to regions that are beyond the observable ( causality determined ) horizon.
If no superluminal speeds are involved, you cannot have a global 'central cpu pulse' ( for the entire universe ).

So are you wrong, or is relativity wrong ?
( I know which of the two has passed a hundred years of testing, and it's not your 'theory' )

I must be going soft in the head.

I thought that's the line I have been pushing.

2 hours ago, Time Traveler said:

model,

This is the only word you got correct in that last post.

Have you ever built a computer ?

Did you read my (physics) point about signal propagation time in real actual computers (and other systems) ?

Did you know that there are quite a few other 'models' of computer architecture.

The use of the word 'vertically' implies a vertical coordinate axis, which of course must conform to all the laws the other axes conform to.

4 hours ago, studiot said:

I thought that's the line I have been pushing.

Yes you were.
And I thought it was an excellent point; so I jumped in.

6 hours ago, Time Traveler said:

The Master Controller does not carry out updates "over distances the size of the universe." The physical size of the host machine is completely independent of the virtual size of the map it renders.

Now, however, he seems to be pushing the concept that this 'computer' architecture does not underlie the universe, but in fact, is the universe.
IOW, forget about reality ( what ontology ? ), it is all just a computer program, where change is just a 'shuffling' of memory locations, and the universe, including us, is just a virtual map.
All without a single shred of evidence that points to such a conclusion.

My priest has a similar theory about the universe, also without any evidence whatsoever.
He calls his computer 'God'.
( it's easy to claim whatever you imagine; providing evidence for such claims is the hard part )

Edited Friday at 03:33 PM2 days by MigL

9 hours ago, Time Traveler said:

To answer MigL's ultimate question: Relativity is not wrong.

And yet you’ve proposed an absolute reference frame

20 hours ago, Time Traveler said:

At the hardware layer, because the state-conservation law depends on the square of the velocity ratio (β²), the direction of translation is irrelevant. The central processor applies the exact same processing overhead to both moving entities. Therefore, relative to the universal background clock, both B's clock and C's clock are throttled by the exact same Lorentz factor (γ). At the hardware baseline, their intrinsic update rates are identical.

The core of the question is: how do B and C observe each other?

Observers B and C must measure each other exclusively by exchanging information carriers—photons—which are bound to the screen's maximum propagation speed (c=1 pixel per frame).

When Observer B uses their local clock template to measure the incoming light signals carrying the state updates of Observer C, the discrete pixel-stepping of the information exchange across the grid introduces a cumulative data latency. In Einstein's light clock model, because the screen's maximum refresh rate for light is absolute (f_light=10⁴³ Hz), the photon tracking the diagonal path cannot accelerate to compensate for the displacement vector. A percentage of its frame allocation is consumed by the motion across pixels, leaving fewer ticks for the vertical round-trips.

When B decodes these signals, the relational math of the information transfer perfectly reproduces the standard relativistic result: B measures C's clock as running slower than their own. Because the grid geometry and light propagation rules are uniform, when C measures B, the exact same informational latency occurs in reverse. C measures B's clock as running slower than their own. Reciprocal time dilation is a strict emergent software symmetry governing relational observations, executed on a synchronized, quasi-absolute hardware baseline.

This is handwaving. You say that "When B decodes these signals, the relational math of the information transfer perfectly reproduces the standard relativistic result: B measures C's clock as running slower than their own." but do not say how much slower or give any indication beyond a mere assertion that it perfectly reproduces the standard relativistic result. For example, what is the Doppler effect observed by B of C's clock? Also, what is the Doppler effect observed by B of A's clock? Is the Doppler effect observed by B of A's clock the same as the Doppler effect observed by A of B's clock? I don't see how they can be same if B's clock rate is throttled by Lorentz factor γ relative to A's clock. Special relativity is based on the principle that all inertial frames are equivalent. This has implications that I fail to see as fully implementable in a model with a preferred rest frame.