More concise T.O.E. explanation:

 

 

Explaining the Reverse-Time-Ordering of Light

 

Part 1 of 3: Introduction and Prerequisites of Digital Physics as demonstrated in introductory VB programming language

 

 

http://spikersystems.com/FlashNet_Pointer/www/projects/Martys_World/Quick_Explanation/Quick_Explanation_Digital_Light_Part1.htm

 

Part 2 of 3: The digitized operation of light: The fish in the Ocean

 

http://spikersystems.com/FlashNet_Pointer/www/projects/Martys_World/Quick_Explanation/Quick_Explanation_Digital_Light_Part2.htm

 

(Marty, 28-Apr-2016)

 



.

 

 



 

This e-book is entirely free of charge from TheTruth-machine.com. Enjoy and share!

 

 

 

 

TheTruth machine: Functional Specification

 

By Marty Wollner

 

TheTruth-machine.com

discflicker.com

 

14-May-2014 a

 

 

 

 

 

RIGHT-CLICK PURPLE LINKS (open in new window), for YouTube PLAY LISTS

 

__c0_1a.wav    CLICK RED LINKS FOR BY-CHAPTER AUDIO NARRATION


 

 

 

Digital physics describes the Universe as consisting of changing sets of INFORMATION.

 

This book describes my rendition of the Theory-Of-Everything (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 ultra-fast computing technology makes it possible.

 

PLEASE be open-minded and give these ideas some serious consideration.

 

 

There is no magic or intentional bull-jive in any of this… everything presented is strictly scientific-based 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.

 


 

__c1_1a.wav

 

1: TheTruth machine:

 

 

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 far-fetched very recently…

 


Based upon the concept of virtual reality and upon my simple theory-of-everything 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 theory-of-everything 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…

 

 

 

and pass judgment upon …

 

 

 

 

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 NON-RELIGIOUS 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 after-the-fact 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 virtual-reality 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/BW-VRT1.pdf)

 

by

 

Brian Whitworth

Massey University, Albany, Auckland, New Zealand

http://brianwhitworth.com/

 

 

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 far-fetched very recently…

 

 


 

__c1_2a.wav    __c1_3a.wav

 

As of 20-Oct-2013, 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 TheTruth-machine. 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 time-stamped and location specified. The machine would create a huge database of these recorded data-streams and also be able to combine the data into a “big-picture”, from which computer-generated viewing aspects could be generated upon demand. TheTruth-machine 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 “big-picture”, 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 brand-new nano-technologies in which very small swarms of self-replicating flying observation devices could be created such that every square-inch of inhabitable terrain is under constant observation and all of the data collected is archived forever in the “big-picture”.


 

 

 

__c1_4a.wav

 

 

The problem, again and as always, is CORRUPTION of the truth.

 

The only way to really make a real TheTruth-machine 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    RIGHT-CLICK PURPLE LINKS (open in new window), for YouTube PLAY LISTS

__c2_1a.wav

2: The 100% scientific postulation of where the ORIGINAL universe came from.

 

 

Start with 1 in the center, and continue to write integer numbers in a counter-clockwise rotational pattern…

 

  

 

Then remove all the non-prime numbers…

 


 

 

 


This “physical structure” that results from the spacing apart of the prime numbers amongst the integers can be shown as:

 


 

 

__c2_2a.wav


   (Ulam’s prime spiral)

 

 

(Kluaber’s triangle)

 

 


   (Sacks’s sphere)

 

 

__c2_3a.wav

 

 

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 train-track

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 Euler-lines 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 pre-adolecent conclusion)

 

 

__c2_5a.wav

 

 

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 sub-structures 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 theory-of-everything – either my version (described below) or one similar to it.

 

 

 

 


 

 

__c2_6a.wav

 

(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 Four-particle, One-Dimensional 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)

 

 

__c2_7a.wav

 

(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 Four-particle, One-Dimensional 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)

 


 

__c2_8a.wav

 

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.

 

__c2_9a.wav

 

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

 

 


__c2_10a.wav

 

Now, let’s re-apply 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.”

 


 

__c2_11a.wav

 

But now, here’s where the Magic happens…

 

 

LOOK AT THE VISUALIZATIONS OF THE DATA LIST:

 

Visualizations of A Four-particle, One-Dimensional 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.

 

 

               

 

 

 

 


 

__c2_12a.wav

 

 

I claim that:

 

Our physical reality must be implemented according to algorithms such as these; THIS IS EXACTLY HOW THE UNIVERSE RUNS!

 

 

 

 

__c2_13a.wav     __c3_1a.wav

 


 

 

 


 

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 BY-CHAPTER YouTube videos

__c3_2a.wav

 

3: How big is infinity?

 

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 Five-particle, One-Dimensional Universe: Tick 1

List Index #

Location Pointer

1

0

2

5

3

7

4

8

5

11

 

Visualization of A Five-particle, One-Dimensional 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 theory-of-everything algorithm consisting of a simple rule that says “all of the particles jump ONE GRID-LOCATION to the right in the next Tick of Universe time:

 


 

 

Rule: Add 1 to the value of each location pointer

 

Data list for A Five-particle, One-Dimensional Universe: Tick 2

List Index #

Location Pointer

1

1

2

6

3

8

4

9

5

12

 

Visualization of A Five-particle, One-Dimensional 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 re-apply the algorithm and continue computing this sequence:

 


__c3_7a.wav

 

 

Rule: Add 1 to the value of each location pointer

 

 

Data list for A Five-particle, One-Dimensional Universe: Tick 3

List Index #

Location Pointer

1

2

2

7

3

9

4

10

5

13

 

Visualization of A Five-particle, One-Dimensional Universe: Tick 3

0

1

2

3

4

5

6

7

8

9

10

11

12

13

 

 

1

 

 

 

 

2

 

3

4

 

 

5

 

 

 

 

__c3_8a.wav      __c3_9a.wav

 

 

Now we’re using locations 0 through 13our Universe functioned just fine and we didn’t need infinity to do it!!!

 

 

Here’s a set of data visualizations depicting its right-hopping 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:

 

  1. Q: If each Tick of universe time represented one elapsed second, how big would this Universe be after one minute?

    A: Virtual particle #5 was in location 11 at Tick 1 and moves one location every Tick, so after 60 Ticks… it will be at location 72, and that’s how big this Universe will be.

 

  1. Q: After 13.7 billion years? (Hint: it’s less than infinity.)[1]

 

 

This is explained in all of my books and papers. Finite limitations and digitization are fundamental concepts:

 

__c3_10a.wav

 

 

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!


 

__c3_11a.wav     __c3_12a.wav     __c3_13a.wav

 

 

(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 over-complicating matters…instead of taking a fresh approach based upon a computable Universe, most scientist are trying to retro-fit 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.

 


 

 

__c3_14a.wav

 

 

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.

 

 

 

 


 

__c3_15a.wav     __c3_16a.wav     __c3_17a.wav     __c3_18a.wav

 

 

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 64-particle, three-dimensional Universe runs through its life cycle about every minute. In this “Sudden-Burst Fountain” model, the outer range of the Universe is maintained within a cube shape that results implicitly from the 3-d configuration. All 64 particles in the list are initialized at location 0; the pre-big bang state.

 

According to the first rule of my simple theory-of-everything (#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 “Tick-0 big bang”.

 

They continue to hop away from location 0 (at various speeds[4]) towards the outer-walls of the cube and stick to them like powdered sugar inside of a gingerbread house. When the last of the drifting particles splatters the “Sugar-coat”, they are ALL un-stuck, and ALL-AT-ONCE, allowed to drift one more location, FORWARD to the next location past the end of computable range; the DIGITAL ROLL-OVER: back to location 0 (where particle #1 stayed the whole time)… back into the pre-big bang state, and in the very next Tick of Universe time… Ka-BOOM!!!

 


 

 

__c3_19a.wav     __c3_20a.wav

 

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 theory-of-everything so that it can work for huge Universes upon reasonably realistic hardware.

 

 

Computability and scalability are the themes upon which the Theory-Of-Everything (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 on-line e-book: 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 BY-CHAPTER YouTube videos

 

__c4_1a.wav     __c4_2a.wav     __c4_3a.wav    

 

 

4: The programmatic handling of the speed of light and answers to the Michaelson-Morley experiment.


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 Michelson-Morley experiment has explanation that was over-looked, how can I explain it? (PART 1)

  

(Marty, 29-Oct-2012)

No Aether, eh?

From a digitized approach, wherein photons of radiation and bits of fundamental particles both move about a fixed universe-wide 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.


 



__c4_4a.wav

 


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 speed-of-light 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…)

 


 

 

__c4_5a.wav     __c4_6a.wav     __c4_7a.wav

 

 

 

So, what I’m sayin’ is this:

 

Light emitted from material objects always occurs when they’re sitting absolutely still within the Universe-wide grid of locations, regardless of their “moving speed” or direction!

 

 


 

__c4_8a.wav     __c4_9a.wav     __c4_10a.wav

 

 

Here, I will explain the motion of matter through the grid…

 

Click HERE for a JAVA demo of the motion of matter

 

All 7-particles in a one-dimensional Universe are initialized to location 0 (the “pre-big-bang state”).

 

In tick 1, they are all (but one) blasted away from location 0 according to a big-bang rule-of-motion, 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 prime-number spray pattern; the use of prime numbers assures these locations won’t co-occupy.

 

 

The algorithm then sets the RELATIVE SPEED of momentum of these particles so they can continue moving appropriately, in relation to one-another. This is done implicitly; the RELATIVE SPEED is an integer number determined simply according to the distance moved from the previous location.

 

 


 

__c4_11a.wav     __c4_12a.wav

 

 

Angles and trig functions

 

 

 [5]

 

 

 

”BUT WAIT”, you say,” it might be at an angle, so we need to allow for trig functions, floating-point numbers, etc. Integer math can’t do the job”.

 

My answer: I explain a lot of it in 1-dimension because I envision the Theory-Of-Everything as being able to run in any number of dimensions, including only one-dimension.

 

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 speed-levels and speed-counters are all tracked and processed individually, by dimension using all INTEGER NUMBERS (data strctures are shown below).

 

 


 

 

__c4_13a.wav

 

Taxicab Geometry:

 

I have been accused of being simple-minded, and my visualization of the T.O.E. running in 3-d 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 flexibly-dimensionally 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!!!!

 

 

__c4_14a.wav


 

 

 

 

 

 

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 1-dimension.

 

 

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 > 1-d, WE MOVE ONE DIMENSION AT A TIME, in rotationcan’t you feel it?

 

 


 

__c4_15a.wav     __c4_16a.wav

 

 

 

 

 

 

(Moving from point A to point B in TAXICAB-GEOMETRY 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.

 


__c4_17a.wav      __c4_18a.wav     __c4_19a.wav

 

 

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 quantum-jumping 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 speed-level that can occur, for example, due to gravity or a collision; all of those speed-level changes are processed within the 1 GL / Tick framework.

 

 

So, it all boils down to setting the initial speed-level... how’s it done?

???


 

 

__c4_20a.wav     __c4_21a.wav

 

 

 

 

Quick and dirty?

 

It seems so easy at this point to just implement the algorithm straight-up 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.

 

 

 

 


__c4_22a.wav     __c4_23a.wav

 

 

 

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.

 


 

__c4_24a.wav     __c4_25a.wav     __c4_26a.wav     __c4_27a.wav     __c4_28a.wav

 

 

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.

 


 

 

__c4_29a.wav

 

 

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)…

 


 

__c4_30a.wav

 

 

(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.

 


 

__c4_31a.wav

 

 

What are the slowest and fastest sub-light 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?

 


 

__c4_32a.wav

 

 

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 un-cool 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…

__c4_33a.wav     __c4_34a.wav     __c4_35a.wav     __c4_36a.wav     __c4_37a.wav     __c4_38a.wav     __c4_39a.wav     __c4_40a.wav     __c4_41a.wav     __c4_42a.wav

__c4_43a.wav

 

__c4_44a.wav … Here’s the Theory-Of-Everything Pseudocode…


 

 

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 co-occupied with another VP) THEN

 

Nuclear Force”: Sprays them all apart into different GLs in all Ds.

// Ka-BOOM this explains the big bang and other nuclear events

ELSE

IF (This VP is un-bound) THEN

 

Fusion Force”: Binds it with the nearest un-bound 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 double-slit 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”: Co-occupation of all (up to 7 VPs) results, collective mass is re-assigned to 0.

// In the very next Tick, ka-boom!

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 3-d 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 dome-shaped 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 re-calculated according to the affect every other VP has upon it… there are electro-static 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

 

 

 

__c4_45a.wav … Here’s the list of force I’ve identified…

 

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 co-occupying plasma)

 

2.      Fusion (identified by non-co-occupying plasma)

 

3.      Atomic (identified by colliding the heat-expansion zones of bonded atoms)

 

4.      Radiation (re-explained 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 theory-of-everything program thus designs itself… this is the only way it CAN work!!

 

 

__c4_46a.wav     __c4_47a.wav     __c4_48a.wav

 

Here’s an actual code JAVA code excerpt showing WordSize being defined …

 

/*

** These are the ONLY two parameters;

** both are well-known 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.

*/

 

 

 

 

 __c4_49a.wav

 

A non-narrative explanation of universe-wide 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 Universe-wide, this enforces that no “one-Tick-time-boundary” can EVER be crossed, Universe-wide.

 

 

 


 

 

 

An analogy for understanding Universe-wide 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 below-minimum 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 system-wide SAMPLING resolution, suddenly we cross a threshold wherein we sample every sine-wave, and increasing the resolution beyond that is just an over-application of compute cycles… the result will always be the same no matter how many times we test a given sine wave.

 


 

 

Universe-wide 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, universe-wide, it all gets snapped into a perfect single digital decision pointUNIVERSE-WIDE, within one Tick or not at all, yes or no, true or false, real or un-real, 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.

 

 

 

 

__c4_50a.wav

 

 

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 single-steps 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?

 

 

  1. 0 to 0 is no speed… stationary relative to the grid
  2. 0 to 2 is speed level 2
  3. 0 to 3 is speed level 3
  4. Etc…

 

 

HERE IS HOW IT’S DONE: WE COUNT!

 

 

 [9]

 

 

__c4_51a.wav     __c4_52a.wav    

 

 

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

 

 

 

 

 

 

 

 

 

 


__c4_53a.wav

 

 

We set the initial speed level as follows:

 

 

VP.Speed = The speed level... the count of grid locations JUMPED in one-Tick during the nuclear event, by dimension.

 

How do we know that?

 

Remember the nuclear force event?

 

All 7-particles in a one-dimensional Universe are blasted off in a big-bang RULE-OF-MOTION, sending them all away from location 0 (the “pre-big-bang” 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

 


 

 

__c4_54a.wav

 

 

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: Ka-BOOM!!! Nuclear force sprays VPs out into a prime-number 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_55a.wav     __c4_56a.wav

 

__c4_57a.wav  … (PLEASE SEE Appendix: Computer Word Sizes and Addressing Limitations)

 

 

 

Not to confuse matters, but:

 

Recall I mentioned this is a two-step 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 re-write this chapter to explain this, meanwhile, just read any of my free e-books 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,

 

 


 

__c4_58a.wav  

 

 

Scroll back up to the Theory-Of-Everything 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.

 

 

 __c4_63a.wav

 

 

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 7-Particle, ONE-DIMENSIONAL 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…

 

 

 

__c4_66b.wav

 

 

Why the speed counter is set to ½ (2**WordSize) – Speed introducing an example; Speed = 1000, and introducing an on-the-spot 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”.

 


 

 

__c4_66c.wav    

 

Answering the on-the-spot 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

 

 

 

__c4_66d.wav

 

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 % hop-count, 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.)

 

 

 

__c4_66e.wav

 

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 time-distance radius. The fractionalization of speeds as the approach c is explained.

 

 

 

__c4_66f.wav

 

 

Fractionalization of speed ranges; light hops from location to location, but it zig-zags its path, so what WE think is c is actually ½ c. The speed limits encountered at the LHC are an example of fractionalization.

 

 


 

 

 

 

 

__c4_66g.wav

 

 

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.

 

 

 

 

__c4_67a.wav

 

 

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 re-started, 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 up-time 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 3-d? 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 7-Particle, THREE-DIMENSIONAL U. just after the nuclear event.

 

In 3-d, the spray pattern is filling up all 3-dimensions 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 non-infinite accelerations from zero to finite speeds of momentum over a digitized sequence of events, this program designs itself.

 

 

 


 

 

 

 

__c4_70b.wav

 

Garret Lisi has come up with this:

 

 

 

 

 

 

 

 

Garet Lisi’s 8-dimensional theory-Of-Everything 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:

 

  1. The maximum allowable number was 2048 (we used it as the fractional scale for sub-light speed levels)

 

  1. But we realize that we need to run the U. for 5,000 ticks.

 

  1. OK, if we allow JUST THE CurrentTickCounter to have a WordSize of 12, the maximum number we could process would be 4096, so we’d still be a bit short, and thus the WordSize must equal at least 13 to process a U. that runs for 5,000 ticks.

 

 

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 UN-AVOIDABLE!!! Just look at my description for the life-cycle of a Universe, or better yet, look at reality… look at Feynman’s matter-state transition diagrams, this is all obvious.

 


 

 

__c4_70c.wav

 

 

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 3-dimensions, 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 ramp-up 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 multi-dimensional 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 re-shuffled 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 100th 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:

 

  1. The CurrentTickCounter possibly being tracked with a larger WordSize, implicitly snapping the ranges of the smaller data structure members used into proportional ratios of the tick counter’s range.

 

  1. Frequency being proportional to temp.

 

  1. Single-dimensional distances proportionally related to the counts of other maximums, like temperate and mass; why? Because when these numbers are used in calculations that involve distance, the results cannot exceed a certain WordSize, as I painfully described above.

 

  1. The possibilities of these reactions moving backwards and forwards in time introduce a level of symmetry. The fact that they do work in 2 directions also introduces a level of symmetry to the diagrammatic interpretation.

 


 

__c4_70d.wav

 

ALL RIGHT now, here’s my wild contentions: I think the T.O.E. runs just as I’m showing it, simple and not multiply-changing 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 dimension-fluxing 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 matter-state 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] theory-of-everything “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 “in-motion”. This is true, UNIVERSE-WIDE (because there is only ONE algorithm that can possibly run a virtual Universe). As such, ALL MOTION IS SYNCHRONIZED, UNIVERSE-WIDE into a single time-frame, and ALL LOCATIONS ARE PRECISELY ALIGNED in a single UNIVERSE-WIDE GRID OF LOCATIONS… THAT is what I am calling THE AETHER.

 


 

 

 

 

Now, look at this diagram:

 

 

 

 

 

This is the Michelson-Morley 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 Michelson-Morley experiment… see it, along with an explanation of why we observe time dilation in clocks, in the Appendix: a condensed summary of the Theory-Of-Everything 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 theory-of-everything?  It’s simple… BECAUSE RELATIVITY IS ALL BULLSHIT, THERE IS ONLY A RELATIVISTIC EFFECT. That’s an original top-12 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 BY-CHAPTER YouTube videos

 

5: The theory-of-everything

 

 

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 theory-of-everything program code is required for it to be found somewhere in the sub-structures of prime spiral, as a simple matter of probability.


  1. This pre-assumes the count of particles in the Universe is finite, at least, at a given moment in time, and this is the current scientific consensus.

 

  1. During this frozen moment in time, everything in the Universe CAN BE digitized, according to computational theories[15].

 

  1. We could therefore express the state of the Universe in the form of information… if we could take a snapshot the entire state of the Universe, we could store it as numbers inside of a set of data structures.

 

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 Theory-Of-Everything algorithm to these number lists in order to make our Universe run.

 

Here are the data structures involved, followed by a one-page Pseudocode rendition.

 


 

 

__c5_3a.wav     __c5_4a.wav      __c5_5a.wav

 

Data Structures

 

 

Two major size lists are used; one is fixed in length, the other is a dynamic queue:

 

The VP list:

 

 

A fixed-size 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

 

 

 


 

 

__c5_6a.wav   … The Prime Spiral

 

 


 

 

 


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?

 

 

 

 

 


 

 

__c5_7a.wav     __c5_8a.wav

 

 

The WFE list

 

 

This is a variable-size 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

 

 

Variables and Arrays:

 

 

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 fixed-size 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:


 

God’s Program, Version 00.00.a

 

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

      __c5_12a.wav 

IF (VP’s INTEGER GRID LOCATION (GL) in D is co-occupied with another VP) THEN

       __c5_13a.wav

Nuclear Force”: Sprays them all apart into different GLs in all Ds.

// Ka-BOOM this explains the big bang and other nuclear events

ELSE

IF (This VP is un-bound) THEN

 

Fusion Force”: Binds it with the nearest un-bound 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 double-slit 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”: Co-occupation of all (up to 7 VPs) results, collective mass is re-assigned to 0.

// In the very next Tick, ka-boom!

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 3-d cubes makes it more likely to collide).

// SC is the Speed Counter, fully described below

END IF

END IF

__c5_27a.wav     __c5_29a.wav

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 dome-shaped 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 re-calculated according to the affect every other VP has upon it… there are electro-static 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 one-dimensional 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 3-d visualizations (using amateur 2-d 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 08-09 Apr, 2013, and the reminder of these were all done on 13-Apr-2013:

 

 

__c6_1a.wav

 

 

 

 

__c6_1b.wav

 

 

 

 

 

 


 

 

 

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 time-distance 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 “Hydra-Branch”) 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 photo-absorbtion…

 

 

 

 

   

 

 

 

 


 

 

 

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 time-distance radius) DO:

 

    .// For every photon currently active in the U.

 

 

 

        If ((modulo (CountFunction (Vindex, Windex),

             WFE(Windex).Frequency))

        {

 

 

// Well, that’s one possible photo-absorbtion…

 

 

 

 

 

 

This is way, way more efficient!!!

 

 

 

 

 

 

 

 

__c6_1c.wav    __c6_1d.wav

 

 


 

 

__c6_1e.wav  (Quantum tunneling is explained)

 

 

Digital Radiation

 

The zig-zag propagation of light in multiple-concurrent branching-out patterns, and answers to the observations of the double-slit experiment.

The zig-zag pathway that I claim is taken by light is a simple pattern of traversal through the Universe-wide 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 Michelson-Morley experiment has explanation that was over-looked, 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 “particle-wave 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 photo-absorption 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 “branched-out” 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 double-slit experiment.

 

__c6_1f.wav   Interference patterns  and self-interference 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 double-slit 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 universe-wide 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 double-slit 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 self-interference are discussed

 

 

Transparency, reflection, partial absorbtion discussion:

 

 

  1. No contact

 

  1. Single photo-absorbtion

 

  1. Multiple branches of the photon are also hitting other substrates

 

  1. Multiple photons are also hitting this exact substrate at his exact time

 

 

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)

 

 

7: The explanation for the relative strengths of various forms of energy, answers to why conversion-constants exist, and how the simple theory-of-everything converges upon Feynman’s transformations.


 

It’s VERY SIMPLE… IF STATEMENTS in the theory-of-everything 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:

 

  1. Nuclear (identified by co-occupying plasma)

 

  1. Fusion (identified by non-co-occupying plasma)

 

  1. Atomic (identified by colliding the heat-expansion zones of bonded atoms)

 

  1. Radiation (re-explained in #8 and #9, coming up shortly…)

 

  1. Newtonian_1 (momentum)

 

  1. 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 theory-of-everything 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 Atomic-force 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 Newtonian-force rules, because Atomic force is a higher priority (this explains time-dilation observed in satellites).

I claim that Einstein’s theory of general relativity is not correct. Time-dilation 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 space-exploration 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 time-dilation as predicted by general relativity…

… we now have “super-clocks” 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 DO-LOOPs, 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, wanna-be theoretical physicist hereby state that:

 

We need to start from scratch and re-consider 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.

 

8: My explanations of “Spooky action” observed when testing/observing the behavior of light…

 

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 SUB-LIGHT TRAVERSAL SPEED!![18]

 

  1. When matter crosses the path of a light photon, a reaction can occur that destroys it[19], after which tracking its path is no longer needed, and resources required implementing tracking can be re-claimed[20]. Note again, this is why I feel the laws of conservation of energy exist in our Universe at all: it’s really a conservation of computer resources running the show!

 


 

 

 

  1. (IT GETS INTERESTING HERE…) There can easily be situations wherein multiple, concurrent bits of matter are struck by concurrent branches of the same photon, and in these situations, a decision must be made as to which bit of matter “sees the light”. A programmatic decision must be made, and it affects future outcomes.

 

  1. These decisions might be done simply by the order of processing; for example, the first bit of matter listed “sees the light”.

 

 

  1. The above explanation answers our observances of the double-slit experiment and also answers why observing a photon has the effect of making it disappear… it can’t splatter the wall if it’s being detected; CONCURRENT, MULTIPLE BRANCHES of the POTENTIAL path of a SINGLE photon explains all of this and more.

 

 

 

__c8_3a.wav   … The JAVA demo is described

 

THIS IS AN IMPORTANT DEMO!!

 

Click here for a JAVA program I wrote demonstrating this. ($$$ In-progress 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 DIRECTLY explains the “spooky behavior” we’re seeing; spooky action ain’t spooky at all! And, it gets even better (see #9 coming up directly).

 

Please see how this impacts #12: Intelligent design (below).

 

 

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.

 

 

9: Spooky actions going backwards in time, EXPLAINED!!

 

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 distance-time 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 photon-absorbtion 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 look-aheads. 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 distance-time radius?

 

 

  1. I think Hiesenberg would say skip it, and just proceed traversing along the distance-time radius (the tree never made any noise when it fell).

 

  1. I claim:

    If no choice is made based upon a recursive lookup decision, then the photo-absorbtion reaction occurs for the first bit of matter in the list (least processing overhead), if the program ain’t happy, TOO BAD, at least light would move consistently throughout the history of time (as we observe).
    I say this because this follows natural law… light does not skip over things “because its not interested in hitting them”.

 

 

  1. But, what of we just let the box continue to run until it finds some Green???

    (There’s that creepy feeling again…)

 

 

 


 

 

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 inside-out, 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 self-design 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 Universe-wide increase in Green vs. Red we could just do a Universe-wide 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 universe-wide 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, hydrogen-421, the Mona-Lisa, smiley-face)


 

 

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 Universe-wide look-ahead 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 Alpha-Centaury)

 

 

 


 

 

__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 1-dimension:

 

The light contacts location 6  (here on Earth) and location 6-zillon on Alpha-Centari concurrently at Tick 10

 

 

Visualization of A (2**17317)-particle, One-Dimensional 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 photo-absorbtion 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 photo-absorbtion, in and around location 6 in the subsequent 10 LOOK-AHEAD Ticks.

 

I will use the notation 10LA(Tick) to denote this LOOK-AHEAD time designation, for example, 10LA3.

 

During such a moment in look-ahead 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, One-Dimensional 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 look-ahead 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, One-Dimensional 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 2-d:

 

 

1-1

1-2

1-3

1-4

1-5

2-1

2-2

2-3

2-4

2-5

3-1

3-2

3-3

3-4

3-5

4-1

4-2

4-3

4-4

4-5

5-1

5-2

5-3

5-4

5-5

 

 

Lets first try all locations that start with 1:

 

1-1, 1-2, 1-3, 1-4, 1-5

 

Next, lets try all locations that start with 2:

 

2-1, 2-2, 2-3, 2-4, 2-5

 

Lets just show these for one more row:

 

3-1, 3-2, 3-3, 3-4, 3-5

 

OK.  Now, lets look at the pattern of examination itself…

 

1-1, 1-2, 1-3, 1-4, 1-5

2-1, 2-2, 2-3, 2-4, 2-5

3-1, 3-2, 3-3, 3-4, 3-5

 

We DON’T want to re-test any repeater, that’s a stupid waste off efficiency and yields wrong results if re-counted in the accumulators. We don’t want to re-examine 2-2, 3-3, etc.

 

Note that this 2-d 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 1-1 (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:

 

 

1-1

1-2

1-3

1-4

1-5

2-1

2-2

2-3

2-4

2-5

3-1