RECURSIVE_SIMULATION_OF_THE_COSMOS_CONCEPT_REVISITED
The text in the web page section below was copied from the plain-text file named journal_karbytes_04october2025_p0.txt in the “micro directory” website section named raw_github_files_directory_KARLINA_OBJECT_extension_pack_49 in the “macro directory” website section (named RAW_GITHUB_FILES_MACRO_DIRECTORY) of the website named Karbytes For Life Blog dot WordPress dot Com. Some of the aforementioned copied plain-text was then replaced with relevant hypertext on this web page.
Note that the red text in the journal entry content below denotes content which is determined by karbytes to be erroneous or poorly worded (but kept for the sake of showing how karbytes’ thought process evolved while creating that journal entry).
/**
* file: journal_karbytes_04october2025_p0.txt
* type: plain-text
* date: 04_OCTOBER_2025
* author: karbytes
* license: PUBLIC_DOMAIN
*/
RECURSIVE_SIMULATION_OF_THE_COSMOS_CONCEPT_REVISITED
In yesterday’s journal entry (which is located at the following Resource Locator), I outlined a conceptual model of how a computer could simulate itself simulating itself in a recursive manner without explicitly specifying any limitations to that simulation’s recursive depth. In today’s journal entry, my intention is to fill in such details.
https://karbytesforlifeblog.wordpress.com/recursive_simulation_of_the_cosmos_concept/
* * *
Recall from yesterday’s journal entry the following equation (which describes a recursive self simulation whose recursive depth is two simulation layers):
S(t + x + y) ~= H(t) + S(t + x)
Note that H could be described as a simulation layer, but for the sake of being consistent throughout this journal entry, H is not being counted as a simulation layer. Instead, only S is being counted as one or more simulation layers.
Note also that, while t, x, and y are each positive amounts of time, t, x, and y are not necessarily the same amounts of time. What is implied as that t elapsed before x and x elapsed before y. Hence, the aforementioned equation implicitly denotes three different layers of simulation each occurring at different times:
Firstly, S(t + x) ~= H(t) occurred (at the point in U’s timeline labeled t + x).
x represents the processing time (including signal propagation delay) needed to generate S(t + x).
S(t + x) is an approximate (and simplified) digital replica of H(t).
H(t) is the how the physical hardware running S is configured at the point in U’s timeline labeled t.
Secondly, S(t + x + y) ~= S(t + x) ~= H(t) occurred (at the point in U’s timeline labeled t + x + y).
y represents the processing time (including signal propagation delay) needed to generate S(t + x + y).
S(t + x + y) is a nearly identical replica of S(t + x).
Implicitly, S(t + x + y) is an approximate (and simplified) digital replica of H(t) while H(t) is rendering S(t + x) (which means that the aforementioned equation is contradicting itself unless that expression is interpreted as a computational assignment operation instead of as an algebraic equivalence statement).
Here is a more accurate depiction of that expression:
H(t + x + y).renders := S(t + x). // This assignment operation happens at t + x + y of U’s timeline.
H(t + x).renders := S(t). // This assignment operation happens at t + x of U’s timeline.
The above two statements imply that S is lagging behind H in terms of which point in U’s timeline either S or H is denoted as representing.
S(t + x).renders := S(t). // This assignment operation happens at t + x of U’s timeline.
S(t + x + y).renders := S(t + x). // This assignment operation happens at t + x + y of U’s timeline.
S(t) could be thought of as the base case of the recursive simulation running on H due to the fact that S(t) represents H before H was running S. In other words, S(t) is an abstract representation of H before H was powered on (or perhaps S(t) is an immutable digital replica of H before t occurred in U’s timeline and while H was fully built and ready to be powered on and to run S).
S(t + x) could be thought of as the first “live” (and indirect) recording of H (and that recording was generated while H was powered on and running the same instance of S as the instance which encompasses S(t + x)).
S(t + x) is a direct recording of S(t) and, hence, S(t + x) is implicitly also an indirect recording of H when H was supposedly rendering S(t).
S(t + x + y) could be thought of as the second “live” (and indirect) recording of H (and that recording was generated while H was rendering S(t + x) and after H supposedly rendered S(t)).
S(t + x + y) is a direct recording of S(t + x) and, hence, S(t + x + y) is implicitly also an indirect recording of H when H was supposedly rendering S(t + x).
Pragmatically speaking, there could be indefinitely many layers to the recursive simulation S but physics would ultimately determine the “hard limit” to how many of such layers could be generated and simultaneously stored in H’s memory. It is assumed that H could could only grow large enough to simulate additional layers of S until H uses up all the available physical resources (i.e. matter and energy) inside of U. Then S would cease to grow and would hence become a frozen snapshot of S’s evolution from S(t) to S(n) where n is the point in U’s timeline where H runs out of computational resources to augment S with additional simulation layers.
This web page was last updated on 04_OCTOBER_2025. The content displayed on this web page is licensed as PUBLIC_DOMAIN intellectual property.
KARBYTES_FOR_LIFE_BLOG 