The idea that can explain how this is possible.
From my earlier post.
I cant access that account. Being locked from the world for 7 years when I got out things changed. However I am what I am.

Thread: Major disturbance in the force



The Great Simulation Structure.

At top of the simulation we have the kernel programm that processes contexts.


Kernel

Individual context
Global context

Local cluster
Global cluster

Information channel



There is simulated global context.

In global context there are many simulated sentient beings.

Each sentient being is simulated within individual context.

Each individual context is then processed by kernel and global context is modified by applying some algorythm to each of the contexts.

Then this updated global context is fed back to each individual context.

Global contexts are simulated in clusters.

The size of the cluster is defined by capacity of information channels that connect them to each other.

When the capacity of information channel between elements of the cluster gets below critical level elements split into different clusters and they are simulated independently of each other. Individual contexts are only processed within element that they belong to.

The data between clusters is synchronized only within the capacity of the existing channel so each new channel connection initiates a process of cluster synchronization which is sensitive to kernel and may lead to global changes.

Kernel precalculates some data in advance.

Each context can be described by matrice of state M(st).

Each sentient being can be described by matrice B(st).

There are certain rules (grammars) by which B(st) interacts with M(st) to produce B(st)+1 and M(st)+1.

There are certain grammars that translate each of the individual M(st) into G(st), and then from G(st)+1 and M(st)+1 and B(st)+1 into (M(st)+1).final.

==

#define
Simulator as S.

Global context as G.

Local context as L.

Individual context as I.

Cluster as C.

State as state.

#

S {
vector<G>
tick
}

G {
vector<state>
}

L {
vector<state>
}

I {
vector<state>
}

C<input> {
vector<input>
}



S.create
S.run {
L.process {
L<temp> L.calculate_transition_context // tick-n..tick..tick+n
}
I.process {
I<temp> I.process_individual_context<L<temp>> // tick-n..tick..tick+n
L<temp> S.finish_transition_context<I<temp>> // tick-n..tick..tick+n
}
G.process {
G G.prepare_global_context<L<temp>,I<temp>> // tick-n..tick..tick+n
L G.update_local_context<L<temp>,I<temp>> // tick-n..tick..tick+n
I G.update_individual_context // tick-n..tick..tick+n
}
}