This is what makes waves (Unified theory Pt. 2)

This is a continuation of Unified theory here

This will have to be considered in the context of binary numbers (down to the quantum fundamental)

What is needed?

An understanding of basic switch logic, and the operations for the 555 timer.

 

Here is what this looks like as a translation of elements from the Periodic Table:

 

Where do we begin? With the number 16:

 

16 = 12/3 = 4

  • 4 = 16

 

What? This is somewhat confusing at first I know. This tells us we have a 16 mid-point to simulate a universe; as a value of bit depth operators (registers). We need to be able to fit both 3 and 4 into the whole simply. 16 (12) is the only way we can do that.

 

But that isn’t 16? You’re right, but neither is any number when you value them as ratios against a larger piece. 16 is seen as a value or portion of the whole.

 

Where am I going? So we know there can be 16 bits here, and that 16 can be half of 32 (the final atomic shell value).

But don’t atoms go 2, 8, 18, 32? Yes – they do. You’ll see why soon.

 

As previously discussed, the universe has registers, which compound upon one another and divide into eachother based on voltage, or pressure values (wave peaks). There are point values which must meet or exceed thresholds in order to create new atoms, combinations of atoms, or cell divides, and we need to go a little bit off base in order to come to the accurate conclusion.

 

Since there are bit values that must be defined to complete one specific function; which is to transfer a bit to the next register, there are some missing links. For example, 11 at the end of the register will enact a transfer, so those numbers are never truly used and are transitional numbers, like 9. This means we have 14/16 possible bits we can use, because at the end of each register we have a reserve value.

 

When we are using for example 6/8 bits, we know that the number 12 will cause a divide, but the total depth of the registers was actually 16. Just like you see above. Now this should be slightly less confusing, and as we work with these types of operations more and more the numbers become intuitive, as the relationships are seen over and over again. Especially in real world calculations.

 

So what about the 555 timers? This is where it gets interesting.

 

Knowing there are computational values to each provisional point across the universe, and that these values are inflating to create peaks and divots, we can conclude that there are sub-divides. When you introduce a voltage into a circuit, you enter 1 whole value. Introduce a transistor, and you can gate the value to inflate other values when thresholds are reached.

 

So we have 1 bit + 1 bit

1100000000

 

Now we connect these bits using an AND gate; which reads specific values (11, 01, 10). When the 11 is triggered, it opens a new gate, and pushes the 1 outwards. This then closes the gate until another 11 is received:

1010000000

1110000000

1011000000

1010100000

end

 

That’s pretty cool right? It definitely is, but let’s add a 555 timer to that.

 

These timers open and close gates based on voltage values, of 1/3, and 2/3. If for example 1/3 voltage is received out of the total circuits input, a gate will remain closed. If a threshold value of 2/3 is reached, a certain gate will open. — So preferably at the very start, we gate each bit individually. When the first bit reaches 2/3, a movement occurs. This is basically saying are you 0 or 1?

 

If 1 (2/3 or more) then current is allowed into the AND gate through the 555 timer, and the first 2 bit allocations are interlinked. This can happen in succession numerous times to end in a fully linked register of 8 total bits, and you can then use the 555 in conjunction with a second, third, or fourth register to continue the pattern. This introduces scalar results and universal values.

 

It happens in such a way that later on 1/2 is used too, and the excess values get pushed outwards and balanced. The use of AND gates can allow redirection of current back into open bit locations which have moved into 0 states. (we see this in atoms when d orbitals begin to fill)

 

We can route all of the registers into another 555 timer to create a whole new register as well.

 

So now we have 1 universal bit, and that is two 1’s (11); or an output. Which is the trigger for an AND gate. This is what a wave looks like:

 

 

Each 2 bits connect through AND gates to other fractions of the next register

They are themselves also connected through AND gates, and controlled by a 555 timer.

 

https://www.electronics-tutorials.ws/waveforms/555_timer.html
https://www.electronics-tutorials.ws/logic/logic_10.html

 

But that isn’t how binary works right now? No it isn’t and neither is the universe.

 

Some notable values in this are 16 / 3 = 5.33, and 32 / 6 = 5.33. You will find that dividing element values by 118 also tend to end off in .333 and .666 values. Just like the operation of these gate and timer types.

 

Now how can we apply that knowledge to build a computer which has the same aspects of the space which we frequent?

 

We have to either realize that 8 can’t be a value; due to the final bit restriction (11), or we need to use 9 bit registers. I am going to use 2’s now. Consider these to be already formed atoms. Each two is made up of two 1’s (11). It is essentially an AND gate connected to more AND gates.

 

We have

2 _ 2 _ 2 _ 2

With a 555 connecting each, we get these necessary values to push the bit into the next gate;

2_ 3 _ 4 _ 6

 

That means for each atomic first shell, we need 6 minimum AND thresholds to be reached through the use of 1/3 sub-divides in order to begin the next shell.

 

There are 3 good ways to visualize this. The fundamental, the group, and the orbital. I will start with the fundamental, move to the group, and then show orbitals. The fundamental is the base 101 format. The group visualizes the total amounts of 1’s as separations; factors of 2 (1/2). This works because of the rule of ratios and their separations within the register. Finally I will show orbitals which visualizes how these spacings look in real life application.

 

Fundamental:

 

So for shell 1 (2);

We get 1_1_0_0_0_0_0_0 (takes 2 bits to flip (think in terms of voltage for the timer)

You must understand now that 0 is a value. Electrical gates can close or open if 0 is applied; so in binary, this is actually a number. It is more like 1 and 2. I’ll show you that in the group explanation. It’s actually easier to understand than this one, but this is how it really works.

 

This gives:

(1_0_)(1_0_)(0_0_)(0_0_)

That is 2 bits total to pass into the next sub-register (through the gate).

This creates Hydrogen. With a nucleus, and an electron. See how there are 4 total sub-registers though? That’s where Helium comes from. It’s also where groups (shells) come from. It’s also where orbital patterns are derived.

 

For shell 2 (8);

Now we have 1_0_1_0_0_0_0_0

It takes 1 bit to flip again (3 total bits) then it balances – We’re making isotopes here.

1_1_1_0_0_0_0_0

1_0_1_1_0_0_0_0

1_0_1_0_1_0_0_0

(1_0_)(1_0_)(1_0_)(0_0_)

Now we have 1_0_1_0_1_0_0_0_

It takes 1 bit to flip again (4)

Isotopes occur until you reach that point (7 total) – then Helium exists

1_1_1_0_1_0_0_0

1_0_1_1_1_0_0_0

1_0_1_0_1_1_0_0

1_0_1_0_1_0_1_0

(1_0_)(1_0_)(1_0_)(1_0_)

Now we have 1_0_1_0_1_0_1_0 (Helium)

You can see right away why there are only 4 total Isotopes of Helium

We have to visualize two registers now.

It takes 2 more bits to pass through the next gate (6)

(1_0_)(1_0_)(1_1_)(1_1_)

moves to

(1_0_)(1_0_)(1_0_)(1_0_) AND (1_0_)(1_0_)(0_0_)(0_0_)

These are always moving by the way. + and –

Now we have Hydrogen + Helium. See why Isomers occur?

We have an AND gate connecting another register, but the voltage is sometimes too low to surpase 2/3. You have to remember now that each separated bit is linked by a 555 timer which requires 2/3 threshold to be breached in order to pass the next gate. Some numbers move around depending on what’s outside of them. We’re only two elements in.

So this really looks like this; with the values passing back and forth in the first register like a wave:

(1_0_)(1_0_)(1_1_)(1_1_) AND (0_0_)(0_0_)(0_0_)(0_0_)

but the good news is we hit 6 bits, so that AND gate opened up when 11 hit, because the 555 timer opened its gate. We just needed the right moment. The gate was open due to voltage but we were waiting on the numbers to shift into place.

(1_0_)(1_0_)(1_0_)(1_0_) AND (1_0_)(1_0_)(0_0_)(0_0_)

 

Finally:

Add 2 bits, and you get a working wave which has held itself in place.

(1_1_)(1_1_)(1_0_)(1_0_) AND (1_0_)(1_0_)(0_0_)(0_0_)

 

These numbers now pass themselves around without exceeding the second registers 6 volt threshold. Unless something comes along and inflates it by introduction. You need either 11 volts (bits) for a full shift to two new registers, or 2 more bits to move along. The thresholds grow and it takes more to change things as they are passed. It’s actually probably easier to do all of this with 9 bits rather than 8;

 

(1_0_1)(0_1_0)(1_0_1) AND (1_0_1)(0_1_0)(0_0_0)

That is because each register timer requires 12 bits or volts exactly instead of just over 10. Otherwise it’s all generally the same, the ratios are just slightly different. The computational world is based on 8 bits, but that isn’t a universal rule. We just never tried it this way. You can look for ways to use the 9th bit as a non voltage required (single digit) pass, or rework the ratio sets to operate in the same way.

 

It gets really dizzying after all that, and I am still working my head around how to do each atom individually, but you can see that we broke through the second ratio eventually and they work for both atoms, and the shells. All of the atoms in our universe are basically circles stacked on top of circles. This is why everything is always moving, and flying through space. I’ll come back to that as I build a physical computer model that can use this system. For now it’s much easier to use the group setting. As you can see, there were 2 total registers with 8 total sets. We’ll start along those lines.

 

 

Group:

 

Use this to view things in a simpler format. The other way isn’t needed to calculate things right now, but as soon as you get the hang of it, start to take things further and use the foundational values.

So for shell 1 (2);

we get 11_0_0_0 (takes 2 bits to flip)

1_0_0_0

 

For shell 2 (8);

Now we have 1_0_0_0

It takes 2 bits to flip again for a higher tier 11 (4 total)

2_0_0_0

It takes 2 bits to flip again, and 3 bits to exceed 2 by 2/3 (3/4)

2_1_0_0

It takes 2 bits to flip again and open the next gate (8 bits total)

2_2_0_0

2_0_2_0

 

For shell 3 (18);

Now we have 2_2_0_0

It takes 2 bits to flip again

2_2_1_0

It takes 2 bits to flip again

2_2_2_0

We start to fill into the next register now though because we broke the 6 threshold, so things equalize. (this is why you see orbitals skip around)

That was because of the 555 gates. Remember? 2, 3, 4, 6? Those are all the threshold values to surpass or meet 2/3. Add them all together and we get 18. Individually there are 16 total bits needed to reach 2_2_2_1, plus 2 to fill the register.

2_0_2_0 – 2_0_0_0

2_2_2_0 – 2_0_0_0

2_0_2_2 – 2_0_0_0

2_0_2_0 – 2_2_0_0

2_0_2_0 – 2_0_2_0

 

But something is off? That isn’t 18? It’s not, and this is the halfway point for the table.

 

In reality this actually happens twice as a matter of balance (syncopation), so you see two sets of 2, 8, 18, 32; and the higher you go in elemental values, the more thresholds you have sitting inside one another, which brings up compression, and magnetism. This is the hardest one to comprehend. You have to keep in mind that it takes 16 volts (bits) to flip the 3rd register, and it also takes 18 bits to get the 3rd register to read 2 at its end.

 

This means we have a lot of intermediates.

 

2_2_2_1 isn’t balanced. We need to keep going.

2_2_2_2 – 2_2_2_2 – 2_0_0_0

2_0_2_0 – 2_0_2_2 – 2_2_2_2

2_0_2_0 – 2_0_2_0 – 2_0_2_0 – 2_0_2_2

 

I can’t stress enough how important it is that you write all these things out on your own. You can’t really grasp this without doing so. It is up to you to complete that chain by filling in what I left out from the middle. I am also going to add a more definitive list of these to this spreadsheet as they just repeat themselves over and over and need to be written down.

 

Now we have one full register. It seems like there are more there, because I didn’t double the 2, or 8 shells (syncopation). This makes it significantly easier to read at first, and I went into more detail on that later.

 

For shell 4 (32);

It’s the same thing. We add another register, but we reached half of 360 with 18. At this point we are capped out, and filling the final half with the remaining thresholds. We are doing the same thing we did from Atom to Group. We are re-evaluating the ratio:

2_0_2_0 – 2_0_2_0 – 2_0_2_0 – 2_0_2_0

Which is equivalent to 16 – 16; for 32 total bits instead of 36.

 

This is the simplest way to put it right now. Each of those 2 values in the final shell are constituted as 8 total bits.

 

This explains why we cap out at 32, and have H and He as balancers. It quantifies atoms, groups, and their orbitals into measurable, and calculable bits.

 

But what does this look like with the group syncopations?

 

So for shell 1 (2);

we get 11_0_0_0 (takes 2 bits to flip)

1_0_0_0

 

 

For shell 2 (8);

Now we have 1_0_0_0

It takes 2 bits to flip again for a higher tier 11 (4 total)

2_0_0_0

It takes 2 bits to flip again, and 3 bits to exceed 2 by 2/3 (3/4)

2_1_0_0

It takes 2 bits to flip again and open the next gate (8 bits total)

2_0_2_0

Plus the syncopation (another 8)

2_0_2_0 AND 2_0_2_0

 

 

For shell 3 (18);

We start to fill into the next register now because we broke the 6 threshold, so things equalize. (this is why you see orbitals skip around)

That was because of the 555 gates. Remember? 2, 3, 4, 6? Those are all the threshold values to surpass or meet 2/3. Add them all together and we get 18. Individually there are 16 total bits needed to reach 2_2_2_1, plus 2 to fill the register.

2_2_2_2 – 2_2_2_2 – 2_0_0_0

2_0_2_0 – 2_0_2_2 – 2_2_2_2

2_0_2_0 – 2_0_2_0 – 2_0_2_0 – 2_0_2_2

 

For shell 32:

 

2_0_2_0 – 2_0_2_0 – 2_0_2_0 – 2_0_2_0 – 2_0_2_0 – 2_0_2_0 – 2_0_2_0

or

2_2_2_2 – 2_2_2_2 – 2_2_2_2 – 2_2_2_2

or 2_2_2_2 (scaled)

 

Orbital:

 

These are pretty straightforwards. The same rule, though it seems they are determined inside of the group/atom ratios, as they are lower voltage values held in place, less gating allowance. This shows their spin changes.

 

2_0_0_0 (2)

fills like

2_1_1_1

2_2_1_1

2_2_2_1

2_2_2_2 (8)

 

Remember the 1’s in this case are equivalent to 0’s. The thresholds are reached, but the atoms are still rules, and we know there are other atoms around them as excess thresholds are required in order to hold them together. Electrons are a visualization of the movements which fall in between. We can look at these a little more openly than when we were setting up the rules of the atoms and their behaviors.

 

2_2_2_2 – 2_2_2_2 – 2_2_2_2 (18)

It fills like this

2_2_2_2 – 1_1_1_1 – 1_1_1_1

We know there are things outside of it, because it is needed in order for this to exist, so we aren’t making any assumptions by inferring that the end point is actually a bounceback from other atoms. At its syncopation point (1), there is at least 1 bit. That means the values are coming inwards.

2_2_2_2 – 1_1_1_1 – 1_1_1_2

2_2_2_2 – 1_1_1_1 – 1_1_2_2

2_2_2_2 – 1_1_1_1 – 1_2_1_2

until

2_2_2_2 – 1_1_1_1 – 2_2_2_2

until

2_2_2_2 – 2_2_2_2 – 2_2_2_2

 

That’s also been shown already by the threshold example where the value began to rise and hold pieces in place:

(1_1_)(1_1_)(1_0_)(1_0_) AND (1_0_)(1_0_)(0_0_)(0_0_)

 

So that’s how it works. In 3d space this happens back and forth all around us. We are a part of it ourselves, and it all happens so quickly. Computers already do this in a rudimentary way at magnitudes of Mhz.

 

.

Leave a Reply

Your email address will not be published. Required fields are marked *