Explaining the ReverseTimeOrdering of Light
Part 1 of 3:
Introduction and Prerequisites of Digital Physics as demonstrated in
introductory VB programming language
Part 2 of 3: The
digitized operation of light: The fish in the Ocean
(Marty, 28Apr2016)
.
This ebook is entirely free of charge from TheTruthmachine.com. Enjoy and share!
TheTruth machine: Functional Specification
By Marty Wollner
14May2014 a
RIGHTCLICK PURPLE LINKS (open in new window), for
YouTube PLAY LISTS
__c0_1a.wav
CLICK RED LINKS FOR BYCHAPTER AUDIO NARRATION
Digital
physics describes the Universe as consisting of changing sets of
INFORMATION.
This book describes my
rendition of the TheoryOfEverything (T.O.E.); the simple instructions for
the digital physics that operates our Universe.
It explains how the Universe functions at the most
fundamental levels, and how this emerges into the shared reality that we
observe and measure.
This is described as a very simple computer algorithm
that is based upon only one requirement…
COMPUTABILITY!
TheTruth machine is a futuristic invention, unachievable with our present technology. However, if the T.O.E. is both deterministic and reproducible, then it’s only a matter of time until ultrafast computing technology makes it possible.
PLEASE be openminded and
give these ideas some serious consideration.
There is no magic or intentional bulljive in any of this… everything
presented is strictly scientificbased postulation; all of it stems from
feasible computer programming concepts. Several JAVA demos are included to
help visualize the concepts.
Click HERE for the Table of Contents, reading instructions, directions for YouTube PLAY LISTS and Audio narrations, alternative format downloads, prerequisites, and disclaimers.
My
best solution to man’s inhumanity to man, and an important message for the world:
I
know it sounds far fetched, however, much of our present technology sounded
farfetched very recently…
Based upon the concept of virtual reality and upon my simple
theoryofeverything explanation (#5, described below), I contend that the Universe
is 100% deterministic and therefore it is 100% reproducible.
I also contend that by running the simple theoryofeverything program, it is theoretically
possible to simulate our own Universe with 100% accuracy and thus we can
actually see what happened in our own past.
I envision TheTruth machine as being a computer application program that
will sit upon the desk of a judge.
TheTruth machine
shows what really happened then and there; The Truth, right there on the
viewing screens for all to see…
If anyone accuses anyone of wrongdoings, the judge and jury
can use TheTruth machine and simply see THE TRUTH… what really happened, and
pass judgment upon it.
It’s
THAT SIMPLE!!
Do YOU understand it?
(of course you do)
OK, BUT, DO YOU BELIEVE IT’S POSSIBLE???
IF
you do believe this invention IS POSSIBLE,
THEN,
Don’t you think you should
change your ways? Try to be a better person?
Please
think about it again…
If you knew this machine was definitely going to be
invented, would you still do wrong?
TheTruth machine is, at last, A
NONRELIGIOUS REASON FOR ACCOUNTABILITY… something the world needs more than
anything else!
The simple knowledge of the potential
creation of TheTruth machine should make everyone who has now read these words
immediately begin following the golden rule, and I am dead serious about this.
No amount of money or afterthefact redemption can buy you a reprieve; your wrongdoings are plain to see and straightforward to convict and sentence. The process isn’t hindered nor prejudiced by false witnesses or incorrect investigations… nobody can argue with the truth.
It is now time for everyone reading this to make a decision, right or wrong.
My
number one goal in life is to prove that this machine can actually be invented
and to make people aware of this FACT.
I contend that any scientific proof
of the virtualreality basis proves the potential creation of this machine IS
POSSIBLE!
Please research this proof of basis … read
The Physical World as a Virtual
Reality
(http://brianwhitworth.com/BWVRT1.pdf)
by
Brian Whitworth
Massey University, Albany,
Auckland, New Zealand
It really is
possible for TheTruth machine to be created (as the rest of this document ANALYTICALLY
describes… PLEASE CONTINUE READING; NO I’M NOT KIDDING).
My important message to the world is simple:
From now on, always
assume that you are being watched, and that you will be held accountable for
your wrongdoings.
Don’t be a jerk… just follow
the golden rule… think about how the other guy feels… never harm children or animals,
don’t turn a blind eye to unfortunate ones you can help, don’t kill anyone, do I need to
spell it all out for you?
It
wouldn’t hurt to follow the golden rule in any case, now, would it?
I AM SERIOUS ABOUT THIS, PLEASE GIVE MY 100% SCIENTIFIC EXPLANATIONS A CHANCE.
Again, please KEEP IN MIND WHAT I SAID ABOUT MODERN TECHNOLOGY:
I know it sounds far fetched, however, much of our present technology sounded farfetched very recently…
As of 20Oct2013, I have come up with some alternatives to my original design, which I will discuss right here.
There are three distinct
approaches to creating a TheTruthmachine. The first two are somewhat obvious, and the third is
a unique approach based upon the concepts of a virtual and computable universe.
The first approach is a LIE DETECTOR. I will not waste time explaining how these devices works or the reliability of the results yielded. However, I will point out that this approach is NOT ACCURATE and SUBJECT TO COERCION AND CORRUPTION. OBVIOUSLY!!!
The second approach is by observation, and this includes witnesses, observers, and investigation results. Again, this is NOT ACCURATE and SUBJECT TO COERCION AND CORRUPTION. OBVIOUSLY!!!
It would be nice if someone would invent a real machine that could accept streams of video and audio inputs that are timestamped and location specified. The machine would create a huge database of these recorded datastreams and also be able to combine the data into a “bigpicture”, from which computergenerated viewing aspects could be generated upon demand. TheTruthmachine would then be operated by the judge exactly as shown above!
The task that then presents itself is to obtain as many of these feeds as possible, and archive them into the “bigpicture”, and keep this data forever and assure it never gets corrupted.
I have recently heard about new technologies that could actually make much of this possible! For example, there are brandnew nanotechnologies in which very small swarms of selfreplicating flying observation devices could be created such that every squareinch of inhabitable terrain is under constant observation and all of the data collected is archived forever in the “bigpicture”.
The problem, again and as always, is CORRUPTION of the truth.
The only way to really make a real TheTruthmachine is my unique approach, based upon the idea that the Universe is virtual and computable and 100% reproducible. In order to explain this, we need to understand how the Universe operates and why I believe that it operates deterministically. And so, a good place to start is
_C2 RIGHTCLICK PURPLE LINKS (open in new window), for YouTube PLAY LISTS
Start with 1 in the center, and continue to write integer numbers in a counterclockwise rotational pattern…
Then remove all the nonprime numbers…
This “physical structure” that results from the spacing apart of the prime numbers amongst the integers can be shown as:
(Ulam’s prime spiral)
(Kluaber’s triangle)
(Sacks’s sphere)
Please research: Ulam’s spiral, also called The
PRIME SPIRAL
Click here
for a JAVA program demonstrating the construction of Ulam’s spiral (it might
ask you to give it some extra time to compute 49,000 prime numbers). Look
at the diagonal lines that appear, revealing an intrinsic relationship
between them that was previously overlooked.
“If I were a baby God,
given all of the integers
as my TOYS
to somehow wrangle,
I could roll Sacks’s sprial
down a ramp of Klauber's triangle,
and onto a traintrack
made of Ulam’s rectangle.
The angles of the rails
look mighty well alighned,
as the sphere rolls along
and the tangential slack grinds.
Look. Looky, LOOK!
The train makes clicking noises
as Eulerlines cross the tracks,
rolling along
to the very end,
and then back up Kluaber’s ramp!!
And for each and every big bang
I can muster
I’ll let out a booming …”(see book for
preadolecent conclusion)
My obvious point:
These are PHYSICAL shapes and structures that were implicitly created from
these natural numerical sequences, and they can be “physically combined” like
the widgets that make a machine.
I contend that:
Some of the
substructures of this physical arrangement function as “widgets” that comprise
a primitive physical computing device (like a mechanical adding machine), and it
performs a very simple set of computations… the theoryofeverything –
either my version (described below) or one similar to it.
(This
part is KEY!)…
These computations are performed upon a
simple list of numbers:
1:
2
2:
3
3:
5
4:
7
(Example:
Four numbers in a simple list)
Data table for A
Fourparticle, OneDimensional Universe:
List Index # 
Location 
1 
2 
2 
3 
3 
5 
4 
7 
(The
same four numbers in the same simple list, shown as a data table)
(This is THE key!) …
From our point of view, each of these list entries functions as a location pointer specifying the virtual location of one of our Universe’s fundamental particles, from which emerges everything that we observe…
Visualization of A
Fourparticle, OneDimensional Universe:
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 


1 
2 

3 

4 







(The
same four numbers in the same simple list, shown as a data visualization)
So what do I mean when I shout, “These computations are performed upon a
simple list of numbers”?
An algorithm is a set of instructions; rules to be applied to the list of numbers.
Here’s a simple example:
Rule: Add 1 to the value of the last number in the list.
The rule changes the STATE of our list like this:
Before:
List Index # 
Location Pointer 
1 
2 
2 
3 
3 
5 
4 
7 
Rule: Add 1 to the value of the last number in the list…
After:
List Index # 
Location Pointer 
1 
2 
2 
3 
3 
5 
4 
8 
Now, let’s reapply the same rule again…
Before:
List Index # 
Location Pointer 
1 
2 
2 
3 
3 
5 
4 
8 
Rule: Add 1 to the value of the last number in the list…
After:
List Index # 
Location Pointer 
1 
2 
2 
3 
3 
5 
4 
9 
That wasn’t so hard, was it?
“Nope.”
But now, here’s where the Magic happens…
LOOK AT THE VISUALIZATIONS OF THE DATA LIST:
Visualizations of A Fourparticle, OneDimensional Universe:
(State 1)
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 


1 
2 

3 

4 







(State 2)
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 


1 
2 

3 


4 






(State 3)
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 


1 
2 

3 



4 





Can you visualize particle #4 drifting off to the
right, “programmatically” in relation to the other particles? This
is VIRTUAL REALITY in its simplest form.
I
claim that:
Our physical reality must be implemented
according to algorithms such as these; THIS IS EXACTLY HOW THE UNIVERSE RUNS!
It runs in discrete steps that I call TICKS of Universe Time. Each step (each Tick) consists of performing a set of calculations upon a simple list of numbers that aren’t much more complex than this simple “Right shift the last particle” example.
·
It’s
really simple… the
Universe consists of the changing of numbers in a simple list, and nothing more;
now you know what matter, time and motion are.
·
It’s
really simple… the
execution of algorithm is what moves the virtual matter around from place to
place (from moment to moment); now you know what energy is: energy is the algorithm
itself!
·
It’s
really simple… the
algorithm is so short and primative, it is randomly found in the spacing apart
of the natural “widgets” in the prime spiral; now you know where the
original Universe came from. (Wow… I know.)
But, how big can these “location pointer” numbers get? And how big can the list be?
_C3 CLICK PURPLE LINKS
FOR BYCHAPTER YouTube videos
In the world of virtual reality, there are FINITE LIMITS to everything. For example, the furthest distance two pieces of matter can be apart.
In any REALISTIC COMPUTATIONAL APPROACH, the maximum distance that can ever be “processed” is a finite, integer number.
“Room for one more, honey…”
__c3_3a.wav __c3_4a.wav __c3_5a.wav __c3_6a.wav
In other words, the algorithm only uses as much of the theoretically infinite Universe as
it has the limited capability to calculate.
Data list for A
Fiveparticle, OneDimensional Universe: Tick 1
List Index # 
Location Pointer 
1 
0 
2 
5 
3 
7 
4 
8 
5 
11 
Visualization of A
Fiveparticle, OneDimensional Universe: Tick 1
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 
1 




2 

3 
4 


5 



We’re only using locations 0 through 11 here, so far. Let’s make up another theoryofeverything algorithm consisting of a simple rule that says “all of the particles jump ONE GRIDLOCATION to the right in the next Tick of Universe time”:
Rule: Add 1 to the value of each
location pointer
Data list for A
Fiveparticle, OneDimensional Universe: Tick 2
List Index # 
Location Pointer 
1 
1 
2 
6 
3 
8 
4 
9 
5 
12 
Visualization of A
Fiveparticle, OneDimensional Universe: Tick 2
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 

1 




2 

3 
4 


5 


Now we’re using locations 0 through 12. Let’s reapply the algorithm and continue computing this sequence:
Rule: Add 1 to the value of each
location pointer
Data list for A
Fiveparticle, OneDimensional Universe: Tick 3
List Index # 
Location Pointer 
1 
2 
2 
7 
3 
9 
4 
10 
5 
13 
Visualization of A
Fiveparticle, OneDimensional Universe: Tick 3
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 


1 




2 

3 
4 


5 

Now we’re using locations 0
through 13… our Universe functioned just fine and we didn’t need
infinity to do it!!!
Here’s a set of data visualizations depicting its righthopping motion from Tick 1 through Tick 3:
Tick 1
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 
1 




2 

3 
4 


5 



Tick 2
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 

1 




2 

3 
4 


5 


Tick 3
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 


1 




2 

3 
4 


5 

CLICK
HERE for a JAVA program visually demonstrating this.
Q + A:
This is explained in all of my books and papers. Finite limitations and digitization are fundamental concepts:
I contend:
COMPUTABILITY must
be the first consideration of any attempt to explaing how the Universe
operates.
If you believe in the VR basis, then the Universe MUST COMPUTE.
If the Universe is computable, it must be both FINITE and DIGITAL!!!
I can’t understate the importance of
this; it’s the key to understanding everything!
(http://brianwhitworth.com/BW_VRT1.pdf)
As I write this paper, every day,
the consensus of science is closer and closer to admitting virtual reality as
mainstream science[2].
However, I believe they are overcomplicating matters…instead of taking a fresh
approach based upon a computable Universe, most scientist are trying to
retrofit these new ideas back into our old concepts.
I believe many of these old concepts
are incorrect, and this is evidenced by the fact that modern science can’t make
sense out of a lot of what they observe. This paper FULLY[3]
describes this in plain English.
So,
what’s beyond that wall in outer space that I claim delineates digital reality from analog
delusion? IT DOESN’T MATTER; THE UNIVERSE WON’T GO BEYOND ITS COMPUTABLE
RANGE.
Here’s how I’d do it, if I were God…
CLICK
HERE for a JAVA program visually demonstrating the life cycle of a Universe.
In it, a 64particle,
threedimensional Universe runs through its life cycle about every minute. In
this “SuddenBurst Fountain” model, the outer range of the Universe is
maintained within a cube shape that results implicitly from the 3d
configuration. All 64 particles in the list are initialized at location
0; the prebig bang state.
According to the first rule of my simple
theoryofeverything (#5, coming up next), the particles are not allowed to
share a location, so they are all (but one) blasted out in a “computed spray
pattern”, all at once in the “Tick0 big bang”.
They continue to hop away from location 0 (at various speeds[4])
towards the outerwalls of the cube and stick to them like powdered sugar
inside of a gingerbread house. When the last of the drifting particles
splatters the “Sugarcoat”, they are ALL unstuck, and ALLATONCE, allowed to
drift one more location, FORWARD to the next location past the end of
computable range; the DIGITAL ROLLOVER: back to location 0 (where particle
#1 stayed the whole time)… back into the prebig bang state, and in the
very next Tick of Universe time… KaBOOM!!!
The code (shown in a link at the
bottom of the JAVA window) is all real, and if you look, you’ll note that just
by increasing the WordSize parameter, this Universe gets much
larger and contains appropriately more VPs without any other code changes. This
scalability is built into every aspect of the theoryofeverything so
that it can work for huge Universes upon reasonably realistic hardware.
Computability and scalability are the themes upon which the TheoryOfEverything (T.O.E.) is designed.
Infinity is not computable.
Infinity
and reality are mutually exclusive.
This inflation and life cycle of a Universe is explained in the chapter “Appendix: The Overall Flow of the Universe”, found in my free online ebook: The Theory of Everything: God’s program, written in C.
“A Metronome
Simply ticks out a beat.
Upon this beat,
We shuffle our feet,
We drive down the street,
And buy tacos to eat.
We add green sauce
On our way home.”
_C4 CLICK PURPLE
LINKS FOR BYCHAPTER YouTube videos
What a “1 GL/Clock Tick
speed of light” implies, and answers to the theory of relativity, time
dilation, length contraction and clock speed discrepancies:
Light always moves at ONE grid location per Tick. Matter stands still for a number of Ticks, then moves ONE grid location.
Here is the first half of a recent Yahoo Question …
Your Open Question: I think the MichelsonMorley experiment has explanation that was overlooked, how can I explain it? (PART 1)
(Marty, 29Oct2012)
No Aether, eh?
From a digitized approach, wherein photons of radiation and bits of fundamental
particles both move about a fixed universewide grid of virtual locations, you
can define "velocity" as being a certain number of Grid Locations
(GL) per computer update cycle (a Tick of Universe time). For example, 23
million GL / Tick.
BUT WHAT IF 
Light always traverses through digital space at ONE GRID
LOCATION per TICK, everywhere.
Matter always moves by
waiting a certain count of Ticks and then moving ONE GRID LOCATION.
First off, the speedoflight is no
longer an arbitrarily defined constant; IT IS THE ACTUAL FRAME CHANGE RATE the
universe "Ticks" by. (Wow…. I know.)
Next, whenever a photon is created (due to some kind of reaction occurring to a piece of matter), THAT MATTER IS STATIONARY!!! The same is true for when a photon's traversal path crosses the location of some matter... EVERYTHING SITS STILL WHILST LIGHT CONSTANTLY MOVES ALONG.
Nobody could envision this idea of MATTER SITTING ABSOLUTELY STILL as it generates, reflects, or absorbs radiation. And THAT is exactly why relativity was invented! Oops?? (The Yahoo letter is continued below…)
So, what I’m sayin’ is this:
Light emitted from material objects always
occurs when they’re sitting absolutely still within the Universewide grid of
locations, regardless of their “moving speed”
or direction!
Here,
I will explain the motion of matter through the grid…
Click HERE
for a JAVA demo of the motion of matter…
All 7particles in a onedimensional Universe are
initialized to location 0 (the “prebigbang state”).
In tick 1, they are all (but one) blasted away from
location 0 according to a bigbang ruleofmotion, sending them
all away into different LOCATIONS:
·
Particle
1 stays still at location 0
·
Particle
2 jumps to location 2
·
Particle
3 jumps to location 3
·
Particle
4 jumps to location 5
·
Particle
5 jumps to location 7
·
Particle
6 jumps to location 11
·
Particle
7 jumps to location 13
The particles were all sprayed away from location 0
into different locations. Note: This is called a primenumber spray
pattern; the use of prime numbers assures these locations won’t
cooccupy.
The algorithm then sets the RELATIVE SPEED
of momentum of these particles so they can continue moving appropriately, in
relation to oneanother. This is done implicitly; the RELATIVE SPEED is an integer number
determined simply according to the distance moved from the previous location.
Angles
and trig functions
”BUT WAIT”, you say,” it might be at an angle, so we need to allow for trig functions, floatingpoint numbers, etc. Integer math can’t do the job”.
My answer: I explain a lot of it in 1dimension because I envision the TheoryOfEverything as being able to run in any number of dimensions, including only onedimension.
I
contend that:
We move
only one dimension at a time.
The motion of
matter is implemented one dimension at a time; all of the location
specifications as well as the speedlevels and speedcounters
are all tracked and processed individually, by dimension using all INTEGER
NUMBERS (data strctures are
shown below).
Taxicab
Geometry:
I have been accused of being simpleminded, and my
visualization of the T.O.E. running in 3d as being “TAXICAB GEOMETRY”.
Yes, I am and yes it is exactly taxicab
geometry, and I contend this because of the way it can be done in
any number of dimension; not to provide some kind of a
flexiblydimensionally coded application, but rather because, and I’ll say it
again, it’s very easy to code that way, in fact, WITHOUT DOING IT THIS WAY, THE
T.O.E. WOULD REQUIRE THE CAPABILITY TO DO TRIG FUNCTIONS!!!!
Ya see what I’m sayin?
This is the only way to implement the processing of
motion in 2 or more dimensions without doing anything but basic integer
arithmetic using algorithms that work just fine in 1dimension.
Remember my “PRIMARY RULE”:
COMPUTABILITY must be the first
consideration of any attempt to explaing how the Universe operates.
When the
T.O.E. is run in > 1d, WE MOVE ONE DIMENSION AT A TIME, in rotation… can’t you feel it?
(Moving from point A to point B in TAXICABGEOMETRY
is a process of counting hops between locations… its more like TOPOLOGY than
MATH!!!)
I will break everything down to it’s most basic
components and start from scratch to explain how the Universe works, and I will
prove that it is possible for TheTruth machine to be invented and operate
exactly as I have described above.
You will understand it because I repeat everything a
dozen times, just for starters.
For
handling the speed of matter in one –dimension, let’s continue our
example:
So anyway, the relative speed levels were:
We have to get
things moving SOME way, don’t we, and so we need to establish relative speed
level numbers, right? If we must be confining ourselves to integer
arithmetic, is there any more of a basic way to accomplish this? Once again, this
program designs itself.
Note that the quantumjumping motion of matter[6]
is itself a set of instantaneous leaps. HOWEVER, those are all adjacent leaps and they’re part of the ”global
no more than 1 GL/Tick motion of everything” that occurs subsequent to establishing
the initial speed.
That
includes all subsequent changes in speedlevel that can occur, for
example, due to gravity or a collision; all of those speedlevel
changes are processed within the 1 GL / Tick framework.
So, it all boils down to setting the initial speedlevel...
how’s it done?
???
Quick
and dirty?
It seems so easy at this point to just implement the algorithm straightup this way… to just say that particle # 6 had moved 11 locations in the last Tick, so just call its speed of momentum “11 locations per Tick”, RIGHT???
WRONG!!!
I say that NOTHING moves faster that one location per Tick as a speed of momentum, and light ALWAYS moves at 1 GL / Tick, everywhere.
PERIOD!!!
Matter sits
still for a number of Ticks, and then moves ONE GL.
I mean, what am I gonna do, set some arbitrary maximum number of GL/Tick as the speed of light and then make up a bunch of rules and conditions of motion to stop matter and light from exceeding it?
By setting the speed of light at ONE location per
Tick, it is NOT ambiguous!!! And, although it might not be obvious at this
point, I claim that we’d
also need to introduce RELATIVITY in order to get it to work the “intuitively
obvious” way of “Zero to > 1 GL / Tick”. I will fully explain this, below.
Meanwhile,
here is a bit of my own “Magic”:
Question:
If the speed
of light ( c ) moves along at 1 GL/Tick, then, if a piece of matter moves EVERY
OTHER TICK, how fast is it, compared with c?
Obvious answer: ½ c.
1/3 c is waiting 2 Ticks and
then moving ONE GL.
1/4 c is waiting 3 Ticks then
moving ONE GL.
Now, I KNOW
you just got a creepy feeling running up your spine. This is a normal reaction
to this elementary enlightenment of blinding proportion. Now it’s all
suddenly obvious: 1/1000 c is waiting 999 Ticks and then moving
ONE GL, light moves by all the time at ONE GL, establishing it as the heartbeat
of the entire Universe.
Please see Appendix: Side rant on determinism and the feasibility of creating
TheTruth machine.
Back
to RELATIVE SPEED levels:
Lets take this just a bit further…
The fastest speed is C, which = 1 GL / Tick.
½ c is one GL / 2
Ticks,
1/1000 c is one GL / 1000 Ticks, and so…
RELATIVE SPEED LEVEL (lets just call it SPEED) CAN BE EXPRESSED AS:
(1/ SPEED) * C = 1
GL / SPEED Ticks
This is our
formula for converting a relative speed number from a fraction of the speed of
light.
Oops, did you just get another creepy feeling… could this be the explanation for the quantification of motion as it approaches the speed of light… because every SPEED LEVEL is an INTEGER NUMBER and it represents WHOLE FRACTIONS of c that must fall upon certain whole FACTORS?
Because we’re limiting the range of all
possible speed levels to a finite set of fractions occurring between 0 and 1, these FACTORS don’t
work like you’d expect:
Lets say that something called Speed_Range is a
measurement of the system’s arbitrarily selected LEVEL OF RESOLUTION,
(ALL FULLY DESCRIBED BELOW) as it applies to the range of allowable relative
speed levels. If Speed_Range =
128, and you’re moving at ¼ c, then your actual speed is based upon the ratio
of 3 counts to 1 * 128, but if the Speed_Range = 256, this is now
based upon 3 counts to 1 * 256 and THIS DOES NOT FUNCTION THE SAME as far as
counts and ratios as the algorithm processes the effect of gravity, for
example.
It’s not a linear scaling and so the U. works differently at each scale we run it at.
HOWEVER, once a resolution is set, it runs and it runs consistently and it runs forever.
I
believe that the resolution that runs OUR Universe is set for the lifespan of
it, a good 13.7 billion years so far and counting.
A plan:
All
righty then, WE JUST
NEED TO:
(1)
Figure out the resolution the
Universe operates on (shown below)
(2)
Figure A WAY TO IMPLEMENT THIS
(or any) RESOLUTION IN THE T.O.E. CODE… We need a way to FACTOR the system’s
resolution into all of our calculations (shown below)
(3)
Figure out how we can actually
get this to REALISTICALLY work in a simple computer algorithm such that it can
be run upon realistic hardware (shown
below)
(4)
Discuss the hardware
requirements and ways to accomplish “getting more done with less” to create an
achievable working TheTruth machine, no kidding (shown below)
One, two, three, four this entire
process is simple and straightforward. Lets start with number (1)…
(1) System Resolution:
Figuring
out the system’s resolution will provide us with a solid framework to build
upon[7].
How
do we do this?
We ask
what the slowest speed possible is…
The slowest speed represents 1 / n
Now we just need to figure out what n is. We are trying
to figure out how to use RELATIVE SPEED LEVELS because we need to calculate
them in our T.O.E.
What
are the slowest and fastest sublight speeds possible?
We can say that STANDING STILL is the same as
“moving at 0 GL / Tick”.
OK, YES, but what is the SLOWEST moving
speed that we can quantitize? The
slowest speed that we can define numerically… we need this for our theory of
everything to be able to make speed calculations. If C if N fast, how slow is a speed of 1?
Lets use
our equation…
(1/ SPEED)
* C = 1 GL / SPEED Ticks
so,
·
1
/2 c = 1 GL / 2 Ticks
·
1
/ 3 c = 1 GL / 3 Ticks
·
1
/ 10 c = 1 GL / 10 Ticks
·
1 / n c = I GL / n Ticks
·
… The slowest theoretical speed = 1 /
∞ Ticks.
And RIGHT HERE
marks the difference between reality and fantasy. We DO MOVE our Universe DOES operate Frisbees
spin!
The algorithm running our Universe can NOT be infinite in any manner, especially concepts such as “infinite clock Ticks” … HOGWASH… IT MUST BE DIGITAL AND FINITE and COMPUTABLE, PERIOD!!!
(If it took forever to process, we would
never move)
But, we DO MOVE… how can anyone disagree?
A deal with the Devil:
I recall somewhere hearing it being quoted by a
famous mathematician:
“Randomization CANNOT be accomplished
programmatically. To believe one has done so is equivalent to making a deal
with the devil”.
Is there any difference between “randomization”
and “making an arbitrary decision”?
I’m now gonna go ahead and say these are the same thing (because
there is no such thing as random)[8].
The deal is we
choose a finite resolution or we don’t exist. Our choice lasts for eternity. We MUST
make an ARBITRARY decision… HOW SMALL CAN 1 / n get… n CANNOT be ∞! Come with me if you want to
live. Opps, wrong movie, but right on.
Well, the uncool thing here is, YES A DECISION MUST
BE MADE, but the cool thing is: we don’t have to make that decision; it’s
already made for us. We just need to look at what Planck Distance and
Planck Time already have been scientifically determined to be and simply work
that into a ONE GL / TICK max. speed functional operation, and THAT IS ALL
THERE IS TO IT!!!
By doing it
this way, there is no arbitrary speed of light, and we do NOT need relativity.
Why?
A verbal explanation now follows…
God’s Program, Version
00.00.a
DO FOREVER
// Each time
though this loop is another TICK of our universe time sequence
FOR
(each of the 3 Dimensions (D) our Universe exists in) DO
FOR
(each Virtual Particle (VP) in a fixed sized list of ‘em)
DO
IF (VP’s INTEGER
GRID LOCATION (GL) in D is cooccupied with another
VP) THEN
“Nuclear Force”:
Sprays them all apart into different GLs in all Ds.
// KaBOOM this explains the big bang and other nuclear
events
ELSE
IF (This VP is
unbound) THEN
“Fusion Force”:
Binds it with the nearest unbound VP into a collective arrangement; mass is
assigned to the ATOM thus created.
ELSE
IF (This VP is in a
collision with an “Appearing Photon”) THEN
// (“Appearing
photon”, “temperature”, and “concurrent branches” are described below)
“Radiation
Absorption”: The VP’s “temperature” is increased and/or “Partial
Reflection” or “Transparency” occurs. ALL concurrent branches of the
appeared photon are terminated.
// This
explains conservation laws and part of the doubleslit experiment results!
END IF
IF (This VP is in a
collision with another VP) THEN
“Atomic Force”:
If ((the sum of kinetic + heat energies) exceeds the system’s INTEGER
computational capability) Then
// “Kinetic
energy” is the speed * the mass. “Heat energy” is the temperature * mass.
“Nuclear Collapse”:
Cooccupation of all (up to 7 VPs) results, collective mass is reassigned to
0.
// In the very next Tick, kaboom!
ELSE
“Kinetic/Heat
Transfer”: The above sum is imparted back into all colliding VPs, which
heat or cool and change their SC and/or direction accordingly. If
heated, a VP’s “Effective Area of Collision” is increased (a geometric
expansion of the outer layer of 3d cubes makes it more likely to collide).
// SC is the Speed Counter, fully
described below
END IF
END IF
ELSE
“Radiation” (VP cooling
by 1 degree): IF (VP’s temperature is > 0) THEN
A photon of frequency f (inversely
proportional to) the count of cubes that comprised the shed outer layer is propagated in both
directions of dimension D at a
rate of 1 GL per Tick. It only “Appears” every f Ticks, and only
then, it can effect matter or other photons; if none there, it “Splits”
into 2 “Concurrent Branches” heading in the same direction, but only in the
other 2 dimensions, causing an overall domeshaped expansion in each direction.
END IF
Movement by “Newtonian
Force”: If the VP’s “Speed
Counter” (SC) = 0, the VP is moved 1 GL in the present direction,
otherwise it stays still
and SC is decremented. The SC is then recalculated according to the affect
every other VP has upon it… there are electrostatic and gravitational
components, summed and divided by the delta distances.
END IF
END IF
END IF
END DO
(FOR each VP in the list)
END DO
(FOR Each Dimension)
END DO FOREVER
Since we observe these forces at work in our Universe WE KNOW which ones are stronger, and so this tells us what the priority of execution is:
1. Nuclear (identified by cooccupying plasma)
2. Fusion (identified by noncooccupying plasma)
3. Atomic (identified by colliding the heatexpansion zones of bonded atoms)
4. Radiation (reexplained in #8 and #9)
5. Newtonian_1 (momentum)
6. Newtonian_2 (the affect the MASS of all of the other particles have and the affect the CHARGE of all of the other particles have reset the speed counters)
The theoryofeverything program thus designs itself… this is the only way it CAN work!!
Here’s an actual code JAVA code
excerpt showing WordSize being defined …
/*
** These
are the ONLY two parameters;
** both
are wellknown to modern science as 3, 17317,
** but
we'll use 3, 14 for now, to fit it into a computable
**
resolution, given our hardware constraints.
**
** The
17317 stems from dividing ONE Planck distance Unit into c,
** and
working that into the closest larger prime number exponent
** of 2.
*/
static final int N_DIMENSIONS = 3;
static final int WORD_SIZE = 14;
/*
**
Amazingly, these are the only 2 parameters used!
**
Maximums such as the hottest temperature, the longest
**
distance, and the heaviest mass, etc. are all based upon
**
limitations imposed by the capacity to calculate such numbers,
** and
this all gets back to WordSize.
*/
A nonnarrative explanation of
universewide synchronization now follows…
Because by limiting
all motion to be less than C, it is IMPOSSIBLE for motion to occur whilst light
is generated. Light CANNOT be generated whilst in motion because speeds
never exceed the 1 GL per Tick boundary.
This is not a
circular argument; the light must be delivered within a single
clock Tick, and because the entire
operation is synchronized Universewide, this enforces that no
“oneTicktimeboundary” can EVER be crossed, Universewide.
An
analogy for understanding Universewide synchronization:
A simple analogy is testing if the amplitude of a
sin wave operating at a fixed frequency meets a minimum threshold, yes or no…
how often do you need to monitor the amplitude of the wave in order to not miss
any belowminimum thresholds?
It’s really simple… if you test the wave at least
once every freq. occurrences, you will ALWAYS get a poll within each and every
sine wave… you cannot miss any, regardless of where in the wave pattern you
start.
RESOLUTION, IN THIS EXAMPLE, IS THE FREQUENCY OF EXAMINATION OF AN UNDERLYING ACTIVITY.
In this example, as we increased the systemwide
SAMPLING resolution, suddenly we cross a threshold wherein we sample every
sinewave, and increasing the resolution beyond that is just an
overapplication of compute cycles… the result will always be the same no
matter how many times we test a given sine wave.
Universewide synchronization:
In this exact same way, by accepting it as something
we just need to do (or we don’t exist), by settling upon a fixed resolution,
and THEN by limiting all motion of matter to fractions of a range between zero
and one as divided by this resolution, universewide, it all gets snapped
into a perfect single digital decision point… UNIVERSEWIDE, within one
Tick or not at all, yes or no, true or false, real or unreal, live or die,
it all boils down to where we choose to set the resolution of the system, and
then let the chips fall where they may!
DIGITAL vs. ANALOG means that out of infinity, a
finite set is chosen and CAN be manipulated in realistic ways, just like all of
our simple example algorithms.
Please see “Appendix: Setting the resolution
at which the Universe operates” in this document for repetitive details on the
derivation of WordSize… it is
17317.
ALL RIGHT, NUMBER (1) is
accomplished… we know what the system resolution is and were starting to get a
feeling for how it works to fractionalize the activities of the Universe.
Next up is NUMBER (2)… How do we
implement this system resolution into the T.O.E. code?
How do we implement this in the T.O.E. code?:
How do we account for this in the speed calculations
we make? Repeating myself from above, moving around is always done in singlesteps
into adjacent position, and this is done one dimension at a time, in rotation, and the real question was … how do we set this initial speed?
The initial speed is set after
a nuclear event, remember the relative speed levels?
HERE IS HOW IT’S DONE: WE COUNT!
We track our counting from one moment to the next in the VP list.
We use the following DATA STRUCTURES in the VP list to do so:
VP_Index 
Location 
LastLocation 
Speed 
SpeedCounter 





We set the initial speed level as follows:
VP.Speed = The speed
level... the count of grid locations JUMPED in oneTick during the nuclear
event, by dimension.
How do we know that?
Remember the nuclear force event?
“All 7particles in a onedimensional Universe are
blasted off in a bigbang RULEOFMOTION, sending them all away from location 0
(the “prebigbang” state”) into different LOCATIONS:
·
Particle 1 stays still at location 0: no motion
·
Particle
2 jumps to location 2
·
Particle
3 jumps to location 3
·
Particle
4 jumps to location 5
·
Particle
5 jumps to location 7
·
Particle
6 jumps to location 11
·
Particle
7 jumps to location 13 ”
When that happened the T.O.E. kept track of the previous location of each
particle as follows:
Tick 0:
VP_Index 
Location 
LastLocation 
1 
0 
(Doesn’t
matter) 
2 
0 
(Doesn’t matter) 
3 
0 
(Doesn’t matter) 
4 
0 
(Doesn’t matter) 
5 
0 
(Doesn’t matter) 
6 
0 
(Doesn’t matter) 
7 
0 
(Doesn’t matter) 
Rule of motion: KaBOOM!!! Nuclear force sprays VPs out into a
primenumber distribution pattern:
Tick 1:
VP_Index 
Location 
LastLocation 
1 
0 
(Still
Doesn’t matter) 
2 
2 
0 
3 
3 
0 
4 
5 
0 
5 
7 
0 
6 
11 
0 
7 
13 
0 
__c4_57a.wav
… (PLEASE SEE Appendix: Computer Word Sizes and Addressing
Limitations)
Not to confuse matters, but:
Recall I mentioned this is a
twostep process. I won’t confuse the issue right now explaining the first part
of process that occurs between Tick 1 and Tick 2. ($$$ I will rewrite this chapter to explain this,
meanwhile, just read any of my free ebooks on the subject).
However, we will examine the
next step RIGHT NOW, which is what we’re talking about; SETTING THE INITIAL SPEED OF
MOMENTUM; at last,
Scroll back up to the TheoryOfEverything Pseudocode and
stare at it in order to understand these narrations:
__c4_59a.wav __c4_60a.wav __c4_61a.wav __c4_62a.wav
and then scroll back here.
HERE’S HOW IT’S DONE:
(1) VP.Speed = abs (VP.Location – VP.LastLocation);
We set the
SpeedCounter as follows,
and FINALLY, HERE IS WHERE THE SCALING FACTOR
GETS INTRODUCED:
(2) VP.SpeedCounter = 1/2 (2**WordSize) – VP.Speed;
IT
ALL HAPPENES IN TICK #2… all of the force of momentum in the
entire Universe gets introduced right then and there simply by setting these
initial speed of momentum numbers in the VP list.
If
WordSize =14 (as shown in the above JAVA example and explained in the code as
well), here is how we use the DATA
STRUCTURES in the VP list to set the initial speed level values:
Tick 2:
VP_Index 
Speed 
SpeedCounter 
Location 
LastLocation 
1 
0 
(Not used) 
0 
(Still Doesn’t matter) 
2 
2 
½ (2**14 – 2) 
2 
0 
3 
3 
½ (2**14 – 3) 
3 
0 
4 
5 
½ (2**14 – 5) 
5 
0 
5 
7 
½ (2**14 – 7) 
7 
0 
6 
11 
½ (2**14 – 11) 
11 
0 
7 
13 
½ (2**14 – 13) 
13 
0 
(The above diagram is showing the VP table in our example 7Particle, ONEDIMENSIONAL U.)
__c4_64a.wav
__c4_65a.wav __c4_66a.wav
We PROCESS relative speed levels whilst
accounting for system resolution as follows:
When
the T.O.E. considers if a VP should move to the next adjacent location, it
follows this simple algorithm:
(3) If (VP.SpeedCounter = 0) then
// Time to move 1 adjacent location (in the right
direction) …
// Save the VP’s current location in VP.LastLocation, and
THEN
// increment (or decrement) the VP.Location:
(4)
VP.LastLocation = VP.Location;
VP.Location = VP.Location + 1;
// This is how things move, BTW
(5) VP.SpeedCounter = 1/2
(2**WordSize) – VP.Speed;
(6) Else
// Not yet time to move …
// The VP sits still until the countdown hits zero:
(7)
VP.SpeedCounter = VP.SpeedCounter – 1;
// This is now
things wait between moving, BTW
(8) End If
A total of 8 lines of code do it all. It took me 50 pages to explain it, though, sorry about that!
The narration gets a bit
tangential…
Why the speed counter is set to ½
(2**WordSize) – Speed introducing an example; Speed = 1000, and introducing an
onthespot quiz.
EACH FRACTION IS ONE SPEED LEVEL.
Next in line?
“Inverted “ speed levels,
ascending from the fastest speed to the slower factors::
InvSpeed_1 = 1 / 2 c
InvSpeed_2 = 1 / 3 c
InvSpeed_3 = 1 / 4 c
InvSpeed_4 = 1 / 5 c
Hey… what about 1 / 1 c ? Its not
allowed; that would BE c.
Why not use fractions past 1 / 2
c all the way to c? We would notice a
certain number at which behavior changes, but we don’t observe this. We only
see the linear lower end of the range and then throw our hands up when things
start moving close to c and say “relativity”.
Answering the onthespot
question, what is the smallest U that can accommodate speed numbers of 1000…
answer 11 because 2**11 = 2048, big enough to hold 1024 as ½ c and 1024 is big
enough to process a speed level of 1000. Introducing the “miscellaneous data
structure” called CuurrentTick…
hiCurrent_Tick as HugeInteger
// The current Tick of Universe time
Why do we need the
UniverseTickCounter?
WFE_List_Structure:
(PK) WFE_OriginatingTick as HugeInteger
(PK) WFE_OriginatingLocation[N_DIMENSIONS] as HugeInteger
WFE_Frequency as HugeInteger
WFE_StreamDuration as HugeInteger
End Structure
To calculate how old a photo is,
subtract the photon’s Tick of origin from the current tick. Translate this
finite, integer count of ticks into a distance by counting the number of hops
in every possible direction, These mark out all of the points of contact, well,
they only appear every f ticks, so if the MODULO function of freq % hopcount,
that is a potential point of waveform contact.
A ray of light hits a flower. And
it smiles…
The “Apparent” Time Distance
Radius Traversal of Light
Temp is proportional to Frequency
and thus both are restricted to the same exact range of levels, and this means
that there are relationships between these numbers, and it goes beyond
computability:
Temp is involved in distance
calculations when the T.O.E. calculates the exchange of heat and kinetic energy
when a collision occurs.
Mass is also involved in the
exchange of heat + kinetic energy, but it’s also involved in gravity
calculations.
Elapsed time is involved in all
of these equations. THESE are the kinds of relationships we will explore below
when we discuss Garret Lisi.
In our REALISTIC implementation, the introduction of the SCALING to
WordSize when the SpeedCounter is set, the subsequent use of THAT SCALE OF
NUMBERS in all of the calculations of OTHER numbers (other: not distance
counts, instead, heat_level, mass, age, etc., etc., etc.)
Completing the example of moving
at speed 1000, we subtract the current tick from the time when the light
originated (as recorded in the WFE table record that was created when the WFE
occurred), and plot that along the timedistance radius. The fractionalization
of speeds as the approach c is explained.
Fractionalization of speed
ranges; light hops from location to location, but it zigzags its path, so what
WE think is c is actually ½ c. The speed limits encountered at the LHC are an
example of fractionalization.
Why Newton’s theories work great, why Einstein’s adjustments
seem correct, why Feynman seems correct and string theory and harmonics all
seem to work… this T.O.E. is THE ONLY POSSIBLE mechanism that can account for
ALL of this!!!
What might happen at ½ c? Let’s take a step back and take a
look from 10,000 ft.
Stepping back and looking from 10,000 feet:
It’s all based upon counts of
intervals. There is no clock, and it doesn’t matter how fast this algorithm is
processed. It doesn’t even matter if it gets halted during execution, or if it
gets stopped and restarted, and that old thought that the U. just started one
instant ago starts to get really scary.
Don’t
worry. The algorithm is rock solid (obviously, with 13.7 billion years of
elapsed processing uptime recorded so far) and the data upon it works is also
rock solid (the grid of integer numbers), I feel safe and sound. Well, safe
and secure, anyway.
Please
see “My letter to Ray Kurdsweild” in “The Theory of Everything: God’s Program,
written in C”.
__c4_68a.wav __c4_69a.wav __c4_70a.wav
How do we do this
is 3d? Very simple…
Tick 2:
VP_Index 
Speed 
SpeedCounter 
Location 
LastLocation 
1 
0,
0, 0 
(Not used) 
0,
0, 0 
(Still Doesn’t matter) 
2 
2, 0, 0 
½ (2**14 – 2), 0, 0 
2, 0, 0 
0, 0, 0 
3 
0, 3, 0 
0, ½ (2**14 – 3), 0 
0, 3, 0 
0, 0, 0 
4 
0, 0, 5 
0,0, ½ (2**14 – 5) 
0, 0, 5 
0, 0, 0 
5 
7, 0, 0 
½ (2**14 – 7), 0, 0 
7, 0, 0 
0, 0, 0 
6 
0, 11, 0 
0, ½ (2**14 – 11), 0 
0, 11, 0 
0, 0, 0 
7 
0, 0, 13 
0, 0, ½ (2**14 – 13) 
0, 0, 13 
0, 0, 0 
The above diagram is showing the state the VP table
in a 7Particle, THREEDIMENSIONAL U. just after the nuclear
event.
In 3d, the spray pattern is
filling up all 3dimensions by using a spiral distribution of the prime number
spray pattern across dimensions; so, we get to mix prime numbers with Fibbonacci[10]spirals
and its not just bragging that we know what these things are;
ONCE AGAIN, if we consider what other possible ways are
available to introduce a “WORKING” spray pattern, whilst applying noninfinite
accelerations from zero to finite speeds of momentum over a digitized sequence
of events, this program designs itself.
Garret Lisi has come up with this:
Garet Lisi’s 8dimensional theoryOfEverything is shown
as a diagram (above), however, I believe this is really a flowchart of the
transitions of matter and energy STATES, not a picture of the configurations
that matter ITSELF assumes.
This diagram can be turned inside out, showing a complex
relationship that spans multiple dimensions.
Above, I provided an example of such relationships in
that finite and fixed range of Temperatures is proportional to range of
possible Frequencies.
Here
is a bit of CONJECTURE: When we actually code the T.O.E., we use only 1
definition for WordSize and then we scale everything based upon this…
Let’s say that the CurrentTickCounter needs to go to
5,000 (a lot longer than we, as programming God’s had anticipated), but we
still need to run it (obviously), and so we might kick our WordSize up a
bit just for the CurrentTickCounter, and then just continue to track the other
quantities using WordSize 11:
Here’s a quick summarizing review:
So bottom line: we use WordSize 13 for the CurrentTickCounter
and 11 for tracking SpeedLevels and these numbers are compatible with each
other in every way and there is no problems in the processing BECAUSE (and THIS
gets way beyond spiritual), we won’t ever need to copy the value of the
CurrentTickCounter into any of these smaller data structures, and WHY???
BECAUSE, like I’m been repeating myself all along, THE
T.O.E. DESIGNS ITSELF!!! Of course every one of these numeric uses WILL
EVENTUALLY RELATE TO EACH OTHER, It is UNAVOIDABLE!!! Just look at my
description for the lifecycle of a Universe, or better yet, look at reality…
look at Feynman’s matterstate transition diagrams, this is all obvious.
Feynman did establish these relationships and then string
theory uses them as well in the vibrations are based upon counts of intervals.
To my best understanding, Garrent Lisi has demonstrated that these “harmonic”
relationships extend across several dimensions, and yet, WE LIVE IN ONLY ONE
SET OF DIMENSIONS, as far as we know… I mean we know we live in at least
3dimensions, and then there’s time, and yes, there might very well BE hidden
dimensions that we can’t see, but I don’t think anyone actually believes that
the Universe currently operates by somehow changing up the number of dimensions
used in any of the calculations.
Of course, there are those who believe that the big bang
was an example of this, wherein “EVERYTHING INFLATED”, including time and
space itself, however, me thinks that’s bullshit; I would ask how the
transition between the use of varying numbers of dimensions occurs, like just
before the big bang, zero dimensions and then in the next instant, all 3 pop
up, or do they rampup and add themselves on as the U. progresses[11],
do they keep on adding more or are has the count of dimensions now stabilized?
And another question is, do they alternate the count of dimension used in some
kind of a flux?
I say NO, they are fixed, at least they are fixed right
now[12].
My reasons are obviously for the primitive simplicity of the T.O.E. By making
this statement, I am taking the position that most scientists do NOT consider
the possibility that the U. is in a state of multidimensional flux; this means
that it operates upon a FIX set of dimensions. That is NOT what Garret Lisi’s
diagrams imply.
We will see in chapter 10 that, no matter how many
dimensions the Universe consists of, it still has only WordSize addressable
locations. NOW, if there are > 1 dimensions used, what happens is the
program starts to use different names, for example a line of 100 people (1
dimension) is then reshuffled into 10 rows of lines, each containing 10
people.
That’s actually a good analogy; the overall COUNT of
people is the same, BUT NOW WE ONLY NEED 2 DIGITS TO ADDRESS EVERYONE whereas
we needed 3 before to identify the 100^{th} person.
So once again, this same scaling reduction is seen. Lets
try to figure out where more of these kinds of relationships occur… we have so
far:
ALL RIGHT now, here’s my wild contentions: I think the
T.O.E. runs just as I’m showing it, simple and not multiplychanging in any
dynamic manner.
AND YET, the mad Hawaiian isn’t crazy, he is an acclaimed
researcher as well as another dude, in fact, similar to Garret Lisi, named
Nassim Haramein who has also come up with a harmonics – based explanation and
both of these agree with the harmonics described in string theory. ALL OF THESE
HARMONICS WORK AS MULTIPLES OF EACH OTHER… I HAD TO IMPLEMENT THESE SAME EXACT
RATIOS OF PROPORTION INTO THE T.O.E. for obvious reasons of scalability and
computability.
And so, I contend that, the reason that these
relationships appear to occur in a (fictitious) Universe that consists of a
flux between changing numbers of dimensions is because these relationships are
really locked into a fixed number of dimensions and they EXIBIT this
dimensionfluxing behavior because of the fractional scaling involved: the
fractional scaling provides implicit relations because of the proportional
scaling of the ranges of these disparate numbers!
And so, I say that the diagrams that the mad Hawaiian
came up with ARE CORRECT and I believe that we can map these exact
relationships back to the calculations that will work in the T.O.E.; the order
of exchange of these numbers will not only be dictated by reality (the real
matterstate changes are well known), but also by this scaling of smaller
numbers into larger numbers in the directions that are computable.
Once again, this program designs itself!!! Sorry for the really long
tangent.
BACK TO OUR DEMO:
Now, finally getting back to the JAVA demo program, if you really look, you can see these particles are all WAITING for a count of Ticks and then jumping ONE LOCATION.
This is what makes “my”[13] theoryofeverything “Tick”… the speed of light is based upon ONE location per ONE clock Tick, making it NOT an arbitrary constant, it is the very framework upon which the entire Universe itself operates… it is the algorithm executing, making one set of state changes at a time to the ENTIRE list of particles ALL AT ONCE… this is key.
ANY LIGHT that gets generated occurs while the
particles are waiting, it DOES NOT (it really can not) occur
“inmotion”. This is true, UNIVERSEWIDE (because there is only ONE algorithm
that can possibly run a virtual Universe). As such, ALL MOTION IS SYNCHRONIZED,
UNIVERSEWIDE into a single timeframe, and ALL LOCATIONS ARE PRECISELY ALIGNED
in a single UNIVERSEWIDE GRID OF LOCATIONS… THAT is what I am calling THE
AETHER.
Now, look at this diagram:
This
is the MichelsonMorley experiment.
And I’m saying that velocity (v) is always
zero, everywhere!!!
The entire notion that relativity is required is based upon this one simple failure to visualize matter sitting still. Oops?
WAIT! Before you write me off as loony, please read this work from Brain Whitworth, a famous professor, and the work of J. Gregg Moxness of http://theoryofeverything.org who independently came up with similar explanations for the speed of light; they are among a growing number of accredited theorists who believe it works this way.[14]
This is a complete and (I feel) reasonable rebuttal to the
MichelsonMorley experiment… see it, along with an explanation of why we
observe time dilation in clocks, in the Appendix: a condensed summary of the
TheoryOfEverything in my book: The Theory of
Everything: God’s program, written in C.
So, how and why did I not have to program relativity into my theoryofeverything? It’s simple… BECAUSE RELATIVITY IS ALL BULLSHIT, THERE IS ONLY A RELATIVISTIC EFFECT. That’s an original top12 idea, eh?
OK, we have now accomplished (1) and (2). Well, most of (2); we still need to account for this same scaling capability when it comes to GRAVITY… we will need to scale the mass into fractions of c of available mass the exact same way we just spent 60 pages doing it for motion (accomplished in 8 lines of simple code).
Now we know how to get matter to move, and our next obvious hurdle is figuring out how the motion of matter can be affected by other matter and by the force of radiation. GRAVITY does fall into this obvious next hurdle, however, before we explain GRAVITY, we will first explain light and radiation.
Because I said so, that’s why!
When we’re done with radiation, ALL OF WHICH MOVES AT THE EXACT SAME RATE OF 1 GL / TICK, THEN we can talk about moving matter around, all of which occurs at different speeds by pausing and then jumping to adjacent locations, all done one dimension at a time.
_C5 CLICK PURPLE
LINKS FOR BYCHAPTER YouTube videos
The
fundamental particles are numeric location pointers that get programmatically
changed. (Please see the JAVA
demo and the explanation, above.)
Error! Hyperlink
reference not valid.The tiny size and primitive complexity of the
theoryofeverything program code is required for it to be found somewhere in
the substructures of prime spiral, as a simple matter of probability.
I believe the current consensus would agree with me on (3) by now (2013), taking into account statements (1) and (2).
The numbers in these lists specify the current locations of every particle in the Universe.
This works exactly the same way as what I’m demonstrating with these simple example number lists.
This also exemplifies what I mentioned above about infinity… if locations can be specified as numbers in a list, those numbers cannot be infinite in size, or the list could not be realistically functional.
Note, it could store theoretical numbers like infinity – 23
to represent locations, speed levels, heat levels and mass, but the math
becomes ambiguous and I’m talking about a realistic operation here, that
being the application of The TheoryOfEverything algorithm to these number
lists in order to make our Universe run.
Here are the data structures involved, followed by a
onepage Pseudocode rendition.
Two major size lists are used; one is fixed in length, the other is a dynamic queue:
A fixedsize list of Virtual Particles (VPs); one record exists for each Fundamental Particle in our Universe. A VP can only be in one location at a time.
The implication here is that no transformations between matter and energy occur; “Energy” is actually the algorithm working to change the values in this list:
VP_List_Structure:
(PK)[16] VP_Index as HugeInteger
Temperature as HugeInteger
Mass as HugeInteger
Location[N_DIMENSIONS]
as HugeInteger
PreviousLocation[N_DIMENSIONS] as HugeInteger
SpeedCounter[N_DIMENSIONS] as HugeInteger
Speed[N_DIMENSIONS] as HugeInteger
End
Structure
Grab the number 2 and pull it
like a loop of yarn…
Imagine the string of numbers as
being passed through a ratcheting device…
Please research Turing Machines…
How big is the Universe?
How long is the string?
This is a variablesize list of Waveform Formation Events (WFEs); one record is created every time a photon is created; this is a dynamic queue of all of the “active” photons in the Universe. A WFE is created at single location by the activity of the algorithm at a particular tick in the sequence of Universe time, and can last a finite DURATION of ticks.
The implications are that photons are created and they are also destroyed, but they are never converted into matter and they don’t come from matter. Instead, photons carry “Energy” as informational message packets enacting upon the matter they encounter:
WFE_List_Structure:
(PK) WFE_OriginatingTick as HugeInteger
(PK) WFE_OriginatingLocation[N_DIMENSIONS] as HugeInteger
WFE_Frequency as HugeInteger
WFE_StreamDuration as HugeInteger
End Structure
iCurrent_Dimension as Integer
// The current dimension in space
hiCurrent_Tick as HugeInteger
// The current Tick of Universe time
hiCurrent_VP as HugeInteger
// The current VP being processed
bAllDone as Boolean
// A Universe termination flag
VP_List as VP_LIST_STRUC[VP_COUNT]
// The fixedsize VP list
WFE_List as WFE_LIST_STRUC[WFE_COUNT]
// The queue of WFEs, implemented within a fixed size list
Simple. Primative. One page of
code. Here it is:
DO FOREVER __c5_9a.wav
// Each time
though this loop is another TICK of our universe time sequence
FOR
(each of the 3 Dimensions (D) our Universe exists in) DO __c5_10a.wav
FOR
(each Virtual Particle (VP) in a fixed sized list of ‘em)
DO __c5_11a.wav
IF (VP’s INTEGER
GRID LOCATION (GL) in D is cooccupied with another
VP) THEN
“Nuclear Force”:
Sprays them all apart into different GLs in all Ds.
// KaBOOM this explains the big bang and other nuclear
events
ELSE
IF (This VP is
unbound) THEN
“Fusion Force”:
Binds it with the nearest unbound VP into a collective arrangement; mass is
assigned to the ATOM thus created.
ELSE __c5_14a.wav __c5_15a.wav __c5_16a.wav
IF (This VP is in a
collision with an “Appearing Photon”) THEN
// (“Appearing
photon”, “temperature”, and “concurrent branches” are described below)
“Radiation
Absorption”: The VP’s “temperature” is increased and/or “Partial
Reflection” or “Transparency” occurs. ALL concurrent branches of the
appeared photon are terminated.
__c5_17a.wav __c5_18a.wav __c5_19a.wav
// This
explains conservation laws and part of the doubleslit experiment results!
END IF
__c5_20a.wav __c5_21a.wav __c5_22a.wav __c5_22b.wav __c5_23a.wav
IF (This VP is in a
collision with another VP) THEN
__c5_24a.wav __c5_25a.wav __c5_26a.wav
“Atomic Force”:
If ((the sum of kinetic + heat energies) exceeds the system’s INTEGER
computational capability) Then
// “Kinetic
energy” is the speed * the mass. “Heat energy” is the temperature * mass.
“Nuclear Collapse”:
Cooccupation of all (up to 7 VPs) results, collective mass is reassigned to
0.
// In the very next Tick, kaboom!
ELSE
“Kinetic/Heat
Transfer”: The above sum is imparted back into all colliding VPs, which
heat or cool and change their SC and/or direction accordingly. If
heated, a VP’s “Effective Area of Collision” is increased (a geometric
expansion of the outer layer of 3d cubes makes it more likely to collide).
// SC is the Speed Counter, fully
described below
END IF
END IF
ELSE
“Radiation” (VP cooling
by 1 degree): IF (VP’s temperature is > 0) THEN
A photon of frequency f (inversely
proportional to) the count of cubes that comprised the shed outer layer is propagated in both
directions of dimension D at a
rate of 1 GL per Tick. It only “Appears” every f Ticks, and only
then, it can effect matter or other photons; if none there, it “Splits”
into 2 “Concurrent Branches” heading in the same direction, but only in the
other 2 dimensions, causing an overall domeshaped expansion in each direction.
END IF
__c5_30a.wav __c5_31a.wav __c5_32a.wav
Movement by “Newtonian
Force”: If the VP’s “Speed
Counter” (SC) = 0, the VP is moved 1 GL in the present direction,
otherwise it stays still
and SC is decremented. The SC is then recalculated according to the affect
every other VP has upon it… there are electrostatic and gravitational
components, summed and divided by the delta distances.
END IF
END IF
END IF
END DO
(FOR each VP in the list)
END DO
(FOR Each Dimension)
END DO FOREVER __c5_33a.wav __c5_34a.wav
Here are the diagrams of
onedimensional geometric shapes mentioned in __c5_22a.wav:
Zero degrees:
… 
35 
36 
37 
38 
39 
40 
41 
42 
43 
44 
45 
46 
47 
48 
49 
50 
51 
… 









5,7 









Heat Level 1:
… 
35 
36 
37 
38 
39 
40 
41 
42 
43 
44 
45 
46 
47 
48 
49 
50 
51 
… 









5,7 









Heat Level 2:
… 
35 
36 
37 
38 
39 
40 
41 
42 
43 
44 
45 
46 
47 
48 
49 
50 
51 
… 









5,7 









Heat Level 7:
… 
35 
36 
37 
38 
39 
40 
41 
42 
43 
44 
45 
46 
47 
48 
49 
50 
51 
… 









5,7 









Continuing with __c5_22b.wav,
Click HERE
for the appendix “The geometric shapes” for 3d visualizations (using
amateur 2d drawings)
This
is explained in my book: The Theory of
Everything: God’s program, written in C
Click
here for another JAVA program I wrote demonstrating this using
a WordSize parameter only slightly larger.
Nearly whole thing is shown above, and if you notice, I didn’t program anything in for RELATIVITY… length contraction, time dilation, it AIN’T in there… How and Why?
Ho boy! (This was described above.)
Here is a surreal experience and
an explanation for my seemingly pointless ramblings. The previous narrations
were all done on 0809 Apr, 2013, and the reminder of these were all done on
13Apr2013:
Approach 1: Loop through all photons,
for each, if it’s at an apex, fan out each new concurrent branch. For each
fanned out branch, check if its location is = any of the VP locations.
For (Windex = 1 to the Count_Of_WFEs)
DO:
// For every photon currently active in
the U.
For (each new point along the timedistance radius) DO:
// As each branch fans out like the Hydra, it finds new locations,
// but only if it is time to appear. This occurs when the
// current tick minus the tick of WFE formation falls upon
// an exact multiple of the waveform’s frequency
If (((CurrentTick  wfe(Windex).FormationTick) MODULO
Wfe(Windex).Frequency) == 0)
// Time to make an appearance,
// so NOW we can check if they hit any VPs…
For (each new “HydraBranch”) DO:
// Feel out the new locations
For (each VP), DO:
// For every particle in the U.
If (wfe(Windex).Location =
Vp(Vindex))
// Well, that’s one possible
photoabsorbtion…
Approach 2: Loop through all VPs, for
each, loop through the list of WFEs; for each, if the topological count of hops
between the two = an exact modulo of the WFE frequency, that is a hit.
For (Vindex = 1 to the Count_Of_VPs)
DO:
// For every particle in the U
For (each new point along the timedistance radius) DO:
.// For every photon currently active in the U.
If ((modulo (CountFunction (Vindex, Windex),
WFE(Windex).Frequency))
{
// Well, that’s one possible
photoabsorbtion…
This is way, way more efficient!!!
__c6_1e.wav
(Quantum tunneling is explained)
The zigzag propagation of light in multipleconcurrent
branchingout patterns, and answers
to the observations of the doubleslit experiment.
The zigzag pathway that I claim is taken by light is a
simple pattern of traversal through the Universewide grid. This is visually explained in
my books: Moments in Time and Big Bang Formation of Matter.
Here
is the second half of that recent Yahoo Question …
Your Open Question: I think the MichelsonMorley experiment has explanation that was overlooked, how can I explain it? (PART 2)
…
Note that I believe that
radiation moves along at ONE GL / Tick, however, it is attenuated at a given
frequency f; a photon skips along only ONE DIMENSIONAL AXIS AT A TIME, only
appearing once every f Ticks, exactly f GLs apart. I believe that it then
splits off into two concurrent branches, one for each of the other 2
dimensions. And so a single photon of light appears in multiple locations
concurrently, expanding away from its source in an inflating dome shape.
The “particlewave duality” of radiation is thus clearly understandable… photons
are counted like particles and yet they progress in very strict patterns that
precisely resemble waveforms.
If any one of these concurrent branches appears where some matter is (this is a
substrate of a photoabsorption reaction), the "energy carried by it"
is transferred into the matter struck and the entire photon (ALL concurrent
branches) is terminated.
It is very possible for a “branchedout” photon to hit multiple substrates at
the same moment amongst its concurrent branches. In this situation, I say that
only ONE of these substrates is PROGRAMMATICALLY chosen to accept the photon;
my reason for this is the law of conservation of energy, and I believe
that this was programmed in order to conserve computer resources… if it is
programmatic, it must be realistically implemented upon realistic hardware.
Because it is the exact same photon appearing in zillions of locations
concurrently, if somebody is counting the number of photons splattering a wall
via a detector, if the photon is detected, it can't also hit the wall, and that
is a simple explanation
for "destructive observation" results of the doubleslit experiment.
__c6_1f.wav Interference patterns and selfinterference are discussed
As far as the ability of a photon to pass through solid matter, I say its
because photons only appear once every f Ticks… they don’t really have a
continuous flow, they jump from spot to spot and do NOT interact with anything
along the way. (Quantum
tunneling explained)
As far as the interference patterns that emerge in the doubleslit experiment,
it’s the same deal; other photons can interfere if they both appear in the same
location at the same moment.
Additionally, when a photon hits one of the two slits, I say that
“TRANSPARENCY” occurs… the photon is terminated (along with all concurrent
branches, of course), and A NEW PHOTON IS CREATED AT THE LOCATION OF THE POINT
OF ABSORPTION (the glass used in the slit). I say that THIS explains the
interference patterns we see splattered on the wall, including the appearance
of a photon being able to interfere with itself, explaining these observations
when only one photon is fired at the double slits.
Everything is stationary in a universewide FIXED grid... the aether IS the
really there, it is the grid of virtual locations!
OK, NOW, do we still need relativity to explain the Michelson  Morley
experiment?
OK, NOW, do we still need quantum mechanics to explain the doubleslit
experiment?
??
(BTW, I got one Yahoo answer; I was accused lying and working for Satan.)
I will repeat and clarify this concept in subsequent
sections of this document. PLEASE SEE #8: My explanations of “Spooky action” observed when
testing/observing the behavior of light, below for a demo of
this and a whole lot more.
__c6_1g.wav …. Interference patterns and
selfinterference are discussed
Transparency, reflection, partial
absorbtion discussion:
What can happen?
100% absorbtion: 100% of the energy
of the photon is 100% absorbed by the substrate
Transparency (I do NOT have this
done but I have the mechanism worked out to match reality)
Partial absorbtion (Same mechanism
as transparency)
In the looping structure, the act of
photon absorbtion makes the substrate skip subsequent processing, and thus,
subsequent rules of motion are not implemented…. this explains why radiation
absorbtion by any substrate should exhibit “relativistic effects”, for example,
loss of detected mass of the substrate (I claim that this happens because the
gravity rule is skipped).
What about INTERFERENCE?
I claim that it ONLY occurs when
there is some matter involved, never when just a photon crosses another.
Interference happens when MORE
THAN ONE photon concurrently hits one bit of matter. Please don’t confuse this with a similar situation that we
are gonna beat to death; a single photon’s multiple concurrent branches hitting
multiple substrates at the same instant.
.
I also have an explanation for
the clarity of light we do see… why, with all the eons of light darting every
which way, we can see things clear as a bell in outer space…
SPACE DUST
I believe it filters out the crud
the same way a sandy river bottom filters out the flow of water over it. This should result in the elimination of most of the “crud”[17],
allowing the pure, unabridged light from distant stars to arrive with perfect
clarity… it prevents scattering by keeping the pathways clear.
The mechanism of interference:
I do not have this worked out, but
it would also create new waveforms and they would originate at the point of the
interference and they would cancel all of the waveforms that feed the reaction,
and thus the overall affect is reduction of WFEs and conservation of
computational resources.
What about REFRACTION?
I claim this occurs because if the
creation of new WFEs at the location of the interference. The new waveforms can
be expanding outwards in a dome shape that apparently extends beyond the range
of the feeding waveforms. This all deals with DIRECTION and I have only vaguely
described it, and alluded to it in the JAVA demo.
So, this is unfinished territory,
however, I feel the basic mechanism is described.
__c7_1a.wav …. Six minutes of bragging (Note: the following chapter was explained in the .wav files
previous heard in chapter 5)
It’s VERY SIMPLE… IF STATEMENTS in the theoryofeverything algorithm make
it enact various rules of motion (what we interpret as “forces”) according to
various situations that occur… there are NO CONVERSION FACTORS programmed in.
The IF STATEMENTS make it such that only the rule that is eligible to run DOES run, and that statistically appears to apply relative strengths to these various forces.
Since we observe these forces at work in our Universe WE KNOW which ones are stronger, and so this tells us what the priority of execution is:
The theoryofeverything program thus designs itself… this is the only way it CAN work!!
PROOF BY PHYSICAL TESTING:
I CLAIM that these relativistic effects are present and I
suggest the following tests should be performed in order to prove it:
1.
Bombarding a substrate with radiation and seeing if it slows
down its internal rate of radioactive decay…
… by interrupting the Atomicforce rules because radiation absorption is a
higher priority.
2.
Bombarding a substrate with radiation and seeing if it ALSO
becomes lighter…
… by ALSO interrupting the gravity rules because radiation absorption is a
higher priority.
3.
Shaking the shit out of a substrate and checking if it has
any affect upon radiation absorbtion…
… it should NOT affect radiation absorbtion because Atomic force (resulting
from collisions occurring from the physically contact) is a lower priority.
4.
Shaking the shit out of a substrate and checking if it slows
down its internal rate of radioactive decay…
… by interrupting the Newtonianforce rules, because Atomic force is a higher
priority (this explains timedilation observed in satellites).
I claim that Einstein’s theory of general relativity is not correct.
Timedilation has never been tested using linear motion, wherein no external
force is being applied... the satellites are continuously subjected to both
radiation and physical rotational forces, as are the voyager and other
spaceexploration vehicles; I would EXPECT these relativistic effects to occur
under these conditions.
5.
However, I do not expect these effects to occur in the
absence of these conditions, and so, I claim that if a test could be setup
wherein two masses get separated from each other via a short duration of force
being applied, and if their separation path is linear and they are allowed to
drift apart from each other, we should NOT observe any timedilation as
predicted by general relativity…
… we now have “superclocks” that can show the relativistic effects of gravity;
it slows down when masses even as light as people move close to them: Let’s
just take these clocks on a voyage through outer space and see what happens!
Looping, Counting, Scaling to fractions, and Feynman’s
diagrams:
In #10: Calculating Gravity by SCALING mass into FRACTIONS of Universe mass, below, we will explore how the T.O.E. works by COUNTING everything. These counts provide a set of fractional ratios, but they’re always ratios of whole integers. This all gets back to the concepts of scaling and WordSize, which is the underlying foundation upon which the T.O.E. is designed.
My point is, this also converges upon Feynman’s implementation… his state transition diagrams ALL work upon the concept of LOOPS. I’m certain that Feynman didn’t consider these as DOLOOPs, which is a computer programming construct, HOWEVER, (as I will eventually show), that is exactly what they really are!!!
If you follow the simple Pseudocode above, you can see it working… just follow it through a few loops and consider the changes that occur to one individual VP… how many times one force runs vs. the others MUST BE described in terms of ratios of whole numbers… why??? BECAUSE IT ALL OCCURS IN TIME BASED UPON RATIOS OF THESE PROGRAM LOOP COUNTS!
One easy proof of my T.O.E. will be to exactly match these back to Feynman’s diagrams... I understand that this has now been done by the likes of Leonard Suskind, however, I wonder if this was done the way I do it, using 1 GL /Tick as the speed of light and then having things traveling slower WAIT for COUNTS of Ticks.
I
figure that must be how it works, and I also figure that changes everything
in the way we perceive, obtain, and interpret any and all measurements of our
reality. I, Marty Wollner, amateur, wannabe theoretical physicist hereby state
that:
We need to start from scratch and
reconsider everything. We need to consider all of our measurements as
FRACTIONS of the speed of light.
__c8_2a.wav … Spookiness starts with a full review and a reminder of how mother nature throws us curve balls
all the time; for example, the dark side of the moon.
As explained in #6 Digital Radiation (above), this
occurs as a result of the algorithms that handle the traversal of light through
the fixed digital grid that I claim IS the aether. Let us start with a full review, and
then I will explain spooky:
1.
I contend that photons of light have an initiation event
that is tracked by the T.O.E. and this tracking requires computer resources to
perform.
2.
Each photon operates by acting as though it has multiple
concurrent branches extending outward and away from the initiation event.
The branching pattern begins its TRAVERSAL in ONE DIMENSION by
extending out freq. number of grid locations every freq. Ticks of Universe
time, making it appear to jump.
At each of these apexes, the photon stops traversing in that dimension, and
functionally creates two new branches, each of which is heading in the same
general direction, but occurring in the other 2 dimensions.
This creates a dome shaped expansion away from the light’s initiation event.
THE SPEED OF TRAVERSAL OF
THIS OVERALL PATTERN IS ½ C!!! AND THAT IS WHY I USED ½ c AS THE MAXIMUM
ALLOWABLE SUBLIGHT TRAVERSAL SPEED!![18]
__c8_3a.wav … The JAVA demo is described
Click here for a JAVA program I
wrote demonstrating this. ($$$
Inprogress but functional for this demo). This demo shows how
digital radiation works:
__c8_4a.wav … Our full review is completed.
·
The end result (once
again): CONCURRENT, MULTIPLE BRANCHES of the POTENTIAL path of a SINGLE photon
explains all of this and more!!!
This explains
why the currently accepted scientific explanation of this is to say “the light
does not exist at all until it hits something”[24], well, THAT IS the current
consensus, I have explained it, but it goes beyond that…
Full
review over, now for the spooky…
__c8_4b.wav … Our full review is completed. Lets get
spooky starting with an explanation of the reality of living within a sequence
of steps…
IT GOES WAY BEYOND THAT!! If we wanted to
program the algorithm to seek out only blue objects to selectively illuminate, it
would be a very simple matter to accomplish, and still obey the laws of
conservation. That ain’t spooky.
HOWEVER, if we wanted to, we could program it such that, by selectively
illuminating one object, another SUBSEQUENT set of events will occur that THEN
illuminates a blue object! Now THAT’S SPOOKY!
THIS capability (and a whole lot
more) can be programmatically accomplished by using a technique known as RECURSION.
By using recursion, our algorithm can look forward over any number of future sequential transitions, over which every possibility can be precisely predicted[25]. For each and every one of these possibilities, we could programmatically ask questions ... if this photon is allowed to activate this substrate, will that activity then EVENTUALLY cause a blue object to be illuminated?
The recursive function will keep traversing up and down the binary logic tree as far as we desire the program to look ahead.
__c8_6a.wav … Our full review is completed. Lets get
spooky starting with an explanation of the reality of living within a sequence
of steps…
If it is determined that a photon will eventually
illuminate a blue object by selectively illuminating something in the present,
this can be accomplished, and it will appear as though the decision went
backwards in time, the exact same way we observe the change between wave and
particle states upon SUBSEQUENT observational activity.
This
is explained in “Another example: M7P1DPOU”
and “Appendix: Explanations of Behaviors” in my book: The Theory of Everything: God’s program,
written in C.
__c8_7a.wav … Our full review is repeated. Again.
Backwards in time.
THIS
IS SIMPLE! It will occur every time any kind of preference is
given to the selection of a photon target, even at the simplest levels!!
ANOTHER
Quick Review to get everyone exactly on track:
1.
I contend that photons of light have an initiation event
that is tracked by the T.O.E. and this tracking requires computer resources to
perform; a record is created in the WFE list recording the location (where) and
the Universe Tick (when) of the photon creation event[26].
2.
The photon operates by acting as though it has multiple
concurrent branches extending outward and away from the initiation event. The
pattern extends out freq. number of grid locations every freq. Ticks of
Universe time, making it appear to jump. At each of these apexes, the photon
stops traversing in that direction, and functionally creates two new branches,
each of which is heading in the same general direction. This creates a dome
shaped expansion away from the light’s initiation event.
3.
It takes way too much computer resources to actually do
that, so instead, the T.O.E. simply looks at each piece of matter and asks if
it is being hit by any of the photons POTENTIAL branching paths along the
distancetime radius.
4.
In most cases, the photon strikes nothing and all of its
concurrent branches each continue to branch and grow.
5.
In some cases, a single branch of the
photon will strike a single substrate and this causes the photonabsorbtion
reaction to occur just as everyone envisions it: as a ray traversing directly
toward a flower, oscillating at a given frequency. So, yes, this is a
correct impression of what does happen, well, some of the time…
In this case, the full payload of the photon’s energy is conveyed to the
flower, the algorithm no longer needs to track the photon’s initiation event
(the waveform collapses, the computational resources used to track the photon’s
activity is reclaimed).
6.
In other cases, however,
multiple concurrent branches of a single photon will strike more than one bit
of substrate at the same (digitally exact) moment in time… in these cases, a
single choice of which bit of matter “sees the light” must be made, and these
decisions affect the future outcome of the state if the Universe[27].
7.
In
order to make these decisions, the algorithm needs some kind of a basis,
for example, the order in which these multiple potential targets appear in the
list of all targets. There is no such
thing as an algorithm to program random, the entire process is deterministic in
any case.
8.
I have suggested that in these situations, the algorithm has an
opportunity to do some very powerful activities by using very simple
programming constructs known as RECURSION.
With recursion, the T.O.E. has the opportunity to look AHEAD and elaborate upon
what will result in any one of several possible choices of outcome.
__c9_1a.wav … Green or Red? Recursion example.
Quick review is over. Let’s
elaborate upon the power of recursion.
(Green and Red
chili sauce)
Green
or Red?:
Choose Green sauce or Red sauce (even been to New Mexico?)
Let’s say the Universe wants photons to make Green sauce… this has nothing to do with the light actually hitting any Green or Red sauce, but :
The only question is how deeply do we want to nest our recursive lookaheads. Let’s say 10 levels deep (that just means that we look forward 10 Universe Ticks of time for every possible outcome).
__c9_1b.wav … The recursive algorithm is described
Algorithm for examining a single level:
For (each bit of matter the photons concurrent branching pattern is currently striking) Do:
1. We step one level forward in time and ask what would happen if it were the substrate select to see the light?
2. We then take statistics at that “node in that next possible branch of reality”.
After we complete this for every one we can then choose one from the list of potential targets that yields best results. That is, if there are any to look for (any Greens) and if there are any more Greens out there that results from our choice.
If not (no changes in the global levels of Green), should we then try
the next level?
Sure, why not… we can repeat the above logic, and WITHIN
EACH OF THESE repetitions we can perform the same algorithm and ask the same
questions… “Do you have any Green
sauce?”
And on and on, each level takes an exponential number of
additional iterations, and hopefully, some Green sauce will eventually appear.
__c9_3a.wav … Some conjecture about how to proceed…
Conjecture:
If none by level 10, SHOULD WE ALLOW THE PHOTON TO JUST SKIP OVER THESE TARGETS and proceed traversing along the distancetime radius?
PAST the 10 (max)?
HOW FAR SHOULD THAT GO?
THIS IS A NEW KEY QUESTION; IT MAKES THE U. “CREATE” whatever its looking for!
THINK ABOUT IT…. if we keep looking for Green sauce until it appears,
IT WILL APPEAR by virtue of the fact that we’ve been manipulating the
Universe in order to make it make some.
The Universe will mold itself to create whatever we are searching for!!! If we order up a mix of spheres and spirals that’s what we’ll get, as if by some kind of magic…
This is the most amazing thing, EVER!!!
Being stupid and working from the insideout, making these discoveries totally on my own, I think I’m just discovering what Madlebrot and those guys have always used as their fundamentals. Those guys, however, are starting with a pattern and extending it out.
My approach to running the U. works backwards in time… it works to create the DESIRED function and form of the future from the present, on forward. This again, exactly explains spooky.
Here’s selfdesign aspect of the deal once again:
THE PROGRAM BEHAVES THIS WAY EVERY TIME ANY PREFERENTIAL CHOICES ARE MADE even at the most basic level…. Green or Red… this makes the U. behave as thought it’s going backwards in time to create Universes that manufacture Green or Red from obscurity!!!
COOL, EH?
__c9_4a.wav … How can the program search for anything?
Patterns of recognition:
WARNING: The following pages will cause chills to run up yer spine:
How do we know if selective illumination is making any Green or Red sauce? We need to recognize what we are speculating about in this possible choice of reality. Actually, I’m not certain the term speculation applies; in fact, it does not apply because this is a 100% deterministic algorithm… I’ll call it A METHOD OF DETERMINATION:
We need to determine if there is more Green sauce than Red sauce, as a result of our
choice; HOW IS THIS DONE, REALISTICALLY?
If it’s a Universewide increase in Green vs. Red we could just do a Universewide count through the entire VP list. I think that would work well to make a Universe with a lot of Green taco sauce[28].
But what if we, instead are looking for a GEOMETRIC SHAPE to appear? In this case, a universewide count of individual VPs won’t accomplish the job because we need multiple, localized VPs to make up any interesting shapes to seek out…
(Spheres, spiral, snowflake, hydrogen421, the MonaLisa, smileyface)
The next thing we need is to figure out is:
Where are we going to look for these attributes and/or geometric shapes? Should we conduct a Universewide lookahead search every time any photon strikes multiple substrates?
We could, but if we consider realistic COMPUTABILITY, it seems obvious there’s too much space to search through[29], especially if we’re doing it an exponential number of times in our recursive tree expansion.
(Sore fingers after a few trillion iterations of searching the entire U.)
__c9_5a.wav … Localized searches… confining them to a
small region:
However, IF THE SEARCH PATTERN IS CONFINED TO A SET OF REGIONS, each originating AROUND the candidate contacting substrate’s locations at that Tick in time, we can consider some “localized affects”. THIS ONLY MAKES COMMON SENSE; IN FACT (YET AGAIN) IT’S THE ONLY WAY THAT IT CAN BE DONE AT ALL. For example:
(A taco stand, either here on Earth or on AlphaCentaury)
__c9_6a.wav … Localized searches… HOW ARE THEY DONE?
Determining the localized affects:
You are examining a small region around a fixed point for a count of Greens and a count of Reds. HOW IS IT DONE REALISTICALLY? (Sorry for repeating myself.)
Of course, by making a set of searches through the list of VPs, but these searches are specifying these LOCALIZED AREAS IN SPACE…
In 1dimension:
The light contacts location 6 (here on Earth) and location 6zillon on AlphaCentari concurrently at Tick 10…
Visualization of A
(2**17317)particle, OneDimensional Universe, Tick 10:
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 
(Row deleted to nix controversy… something happened at location 6 at Tick 10).
This isn’t shown because IT DOESN’T MATTER what was there or what happened to the matter that it struck at location 6. I’m not showing it because I’m not describing or speculating on how the photoabsorbtion reaction would have occurred at location 6 at Tick 10, I’m only concerned with the count of greens and reds that would result from this potential photoabsorbtion, in and around location 6 in the subsequent 10 LOOKAHEAD Ticks.
I will use the notation 10LA(Tick) to denote this LOOKAHEAD time designation, for example, 10LA3.
During such a moment in lookahead time, the VP list might specify VPs with locations in the localized region, and these are the ones we want to test for Green and Red sauce attributes…
Data table for A
(2**17317)particle, OneDimensional Universe, Tick 10LA3:
List Index # 
Location Pointer 
Red Sauce ? 
Green Sauce? 
1 
2 
Yes 
YES 
2 
3 
No 
YES 
3 
5 
No 
YES 
4 
7 
No 
YES 
… 



It doesn’t matter if there is or isn’t any matter at location 6 or any location in the search range, for that, (sorry,) matter in any of the lookahead Ticks.
__c9_7a.wav … Localized searches in one, and then two
dimension for green sauce:
Searching though a contiguous set of locations from a starting point (minPoint, like 3) to an ending point (maxPoint, like 9), all finite, integer math, of course…
Visualization of A
(2**17317)particle, OneDimensional Universe, Tick 10LA3:
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
… 


1 G R 
2 G 

3 G 

4 G 







You
can get tacos with both Green
AND Red. I love green sauce, BTW.
This is a simple pattern to search for Greens, just start at the minPoint, test, jump one, test, etc till maxPoint…
For index = minPoint to MaxPoint
If (VP(index)
is GREEN) then
GREEN_COUNT++
End if
Next index
Lets think about what we’re trying to accomplish: Were examining a range of + or – 3 locations.
Questions:
First off, why did we arbitrarily pick any range at all?
WHY SEARCH
FOR JUST ANY AREA AT ALL????
THIS IS SOOOOOOOOOOO AT THE HEART OF EVERYTHING… as we will soon see, it is more efficient is to ask, “can there be a count of greens to look for, all close to an individual location?” We will then apply this same reasoning into looking for geometric patterns.
Next is 2d:
11 
12 
13 
14 
15 
21 
22 
23 
24 
25 
31 
32 
33 
34 
35 
41 
42 
43 
44 
45 
51 
52 
53 
54 
55 
Lets first try all locations that start with 1:
11, 12, 13, 14, 15
Next, lets try all locations that start with 2:
21, 22, 23, 24, 25
Lets just show these for one more row:
31, 32, 33, 34, 35
OK. Now, lets look at the pattern of examination itself…
11, 12, 13, 14, 15
21, 22, 23, 24, 25
31, 32, 33, 34, 35
We DON’T want to retest any repeater, that’s a stupid waste off efficiency and yields wrong results if recounted in the accumulators. We don’t want to reexamine 22, 33, etc.
Note
that this 2d search pattern can be accomplished by a very well known algorithm
called the “Spiral Matrix”,
wherein each location is only counted once.
HOWEVER, for counting VP having certain attributes, we really don’t want to start at 11 (the corner of the box surrounding the point of photon contact in this possible branch the U might peruse), because like I said, we are examining the localized area around the contact, so why arbitrarily start 3 locations away from where we’re looking?
Lets try a different one that is more optimized for performance:
11 
12 
13 
14 
15 
21 
22 
23 
24 
25 
31 