AI-Matrix

Multidimensional data analyzer.

Project maintained by Recoskie Hosted on GitHub Pages — Theme by mattgraham

Indexed contents

Introduction: Link

The basic algorithm: Link

The geometry of higher dimensions: Link

Fast dimensional subtraction: Link

Decoding dimensional iteration: Link

The matrix structure: Link

Golden ratio/Quasicrystals: Link

Can AI become self aware: Link

Introduction

No matter how complex of a calculation or steps you write to output a result, the results can all be reduced back to what it takes to reproduce the measurements or results without knowing the steps.

Anything we measure can be reduced back into math calculations or functions. Our brain typically does this sort of thing without us even realizing it.

Our brain recalls these patterns and sequences from memory, allowing us to build thoughts, ideas, and brain function.

Reality itself follows the same principles known as the law of cause and effect.

Everything reverses to simplicity that forums complexity in cause and effect sequentially known as emergence.

All examples on this page can be modified, so you can change the examples to see the effects.

Solving a dimensional set

Let's start with a one-dimensional set, and show how it builds, and solves sequentially. Starting from here will help you see how it works.

A one-dimensional set basically is counting by one per number, or by two per number.

So lets build a one-dimensional set that is 7 more per number.


  var data = [];

  var end = 8;

  var start = 1;

  var per1 = 7;

  for (var i1 = 0; i1 < end; i1++)
  {
    data[i1] = start;

    for (var i2 = 0; i2 < i1; i2++)
    {
      data[i1] += per1;
    }
  }

  console.log(data);

This simple little code creates a set with the starting value of 1. Which you can change to anything by changing

var start = 1;

from 1 to any number you wish.

The second loop adds 7 more to each value. Which you can change to anything you like by changing

var per1 = 7;

from 7 to any number you like.

You can change the numbers to anything you like and run the code again to create any one-dimensional set.

Lastly the

var end = 8;

can be changed to a bigger number than 8. If you want to make the set longer.

The starting amount is always the first digit in the set.

In the case of the example I gave you. We ended up with the following set starting with 1, and adding by 7 per value.

1,8,15,22,29,36,43,50

The starting amount is 1. This solves what the starting amount is.

Then all you have to do is subtract the next number by the previous number.

The next number after 1 is 8 so 8-1=7.

You then move to the next number in the set which is 8. The number after 8 is 15. So 15-8=7.

You do this with all numbers in the set. This solves the first-dimensional loop. As it solves the difference between the numbers per iteration.

8-1=7
15-8=7
22-15=7
29-22=7
36-29=7
43-36=7
50-43=7

This gives us how much is added per value. The difference is the same across all numbers making a set of 7,7,7,7,7,7,7 per value.

Subtracting the set of 7,7,7,7,7,7,7 the same way will give a set of 0,0,0,0,0,0. Which means there is nothing left in the set per value.

Solving a 2-dimensional set

In the previous example it is quite easy to see that subtracting the next number into the previous number finds the first-dimension per added value.

So I will show you what happens when you add another dimension.


  var data = [];

  var end = 8;

  var start = 0;

  var per1 = 1;

  var per2 = 2;

  for( var i1 = 0; i1 < end; i1++ )
  {
    data[i1] = start;

    for( var i2 = 0; i2 < i1; i2++ )
    {
      data[i1] += per1;

      for( var i3 = 0; i3 < i2; i3++ )
      {
        data[i1] += per2;
      }
    }
  }

  console.log(data);

In this example we create a square using a 2D set. Which is the calculation X².

We will talk about what a square actually is in the geometry section.

Our set is 0,1,4,9,16,25,36,49. So the first number in the set is 0. Which means the starting value is 0.

var start = 0;

Subtracting the next value into the previous value gives us.

1-0=1
4-1=3
9-4=5
16-9=7
25-16=9
36-25=11
49-36=13

This gives us the set 1,3,5,7,9,11,13. The first result will be the first-dimension which is 1.

var per1 = 1;

Subtracting the numbers 1,3,5,7,9,11,13. Going next number by previous number again.

3-1=2
5-3=2
7-5=2
9-7=2
11-9=2
13-11=2

This solves the difference in the second-dimension. Which is 2 more.

var per2 = 2;

Doing the subtraction of 2,2,2,2,2,2 gives us 0,0,0,0,0 things left.

The first number after each subtraction of all numbers is what the dimensional value is per iteration.

The starting value is very important as you could start anywhere in the two-dimensional square sequence. For example, you could start at

var start=16;

with

var per1=9;

and

var per2=2;

This continues the pattern from 16 onward as 16,25,36,49,64,81,100,121. So the starting amount is then 16. You can solve each amount per iteration by subtracting the next number into previous and writing down the first number each time till left with 0.

The first number without any subtraction will be the starting value.
The first number after the subtraction of all numbers will be per1.
The first number after the subtraction of all numbers again will be per2.
The first number after the subtraction of all numbers again would be per3. Except we end up with 0,0,0,0,0 things left in the third-dimension.

You loose one number with each subtraction into all numbers, because there is no next value to subtract the previous value into at the end of the set.

So to solve a 5-dimensional pattern per iteration requires at least 6 numbers in a set including the starting value.

You can do the math your self and change per1, and per2 to what ever you like.

The geometry of higher dimensions

I decided to create this section later to help anyone to understand dimensions geometrically.

The small number above x is how many times to multiply the number against itself per value.

The blue squares are the amount that existed before we moved to the next value. The red and green squares are the added units per value.

In the first-dimension, we are only adding one new unit, which can be added together one unit at a time in a single loop. We input 5 into our function, and we can add five sevens together if that is the size of the units, or we can just say x is multiplied by 7.

When we multiply the number by itself, we expand this pattern vertically and horizontally.

In the second-dimension, we have to add a one-dimensional pattern shown as the green squares per square that join at one unit.

When we input 5 into our function, it adds it together as follows.

1+
1+(1)*2 +
1+(1+1)*2 +
1+(1+1+1)*2 +
1+(1+1+1+1)*2 = 25

Each row is each square size leading to 5x5=25. The first loop can add the single units at the start of each line, but now we must add another one-dimensional loop inside this loop that does the same thing in the () but multiples the added units by 2 for both sides.

The neat part is that we can take away the added unit in the square by subtracting it as

x²-x=0,2,6,12,20 which is 0, 0+2, 0+2+4, 0+2+4+6, 0+2+4+6+8.

Dividing it by 2 gives us a set that adds a one-dimensional sequence per value. It was only 2 in size per unit because of the two sides of the square.

(x²-x)÷2=0,1,3,6,10, which is 0, 0+1, 0+1+2, 0+1+2+3, 0+1+2+3+4.

As objects fall, they get faster per second. To be exact, 33 feet more per second. We can add this together using two loops, or we can just multiply our equation by 33.

((x²-x)÷2)*33=0,33,99,198,330, which is 0,0+33,0+33+66,0+33+66+99,0+33+66+99+132.

In math, we call these quadratic equations, which makes it so we never have to use two loop iterations inside each other called sigma summations in math to add together such a result. Quadratics are good at producing curves and showing an object's path when you throw it as it is pulled toward the earth.

When we multiply the square against itself, then it is the same as adding a whole new square per square. At 2x2, we have two squares stacked on top of each other when we multiply by 2 again, and at 5x5, we have 5 squares stacked on top of each other when we multiply by another 5. This means we have to add another one-dimensional loop outside the two loops to add each square layer, creating a 3D cube.

Multiplying the cube by itself adds a new one-dimension loop outside the cube adding another per iteration amount.

Multiplying is much faster than adding our result together. All forums of adding per amount per dimensional loop/sigma iteration can be reduced into simple fast calculations.

This allows us to replace loops within loops that add different amounts with a fast calculation.

Changing your per added amounts per loop inside each other is explained in the decoding dimensional iteration section.

Higher dimensional sequences and counting of things exist all over in nature and in the world around us.

5-Dimensional set with subtraction

You can solve how much is added per dimension with each subtraction into all numbers.

With the first number being the difference.

I will make it that you can create any 5D set you like in this code. At the end of the code. Each number is subtract into the previous.

Each per iteration value is set to what x⁵ is. You can change them to whatever you like, even negative or fractional values.


  var data = [];

  var end = 8;

  var start = 0;

  var per1 = 1;

  var per2 = 30;

  var per3 = 150;

  var per4 = 240;

  var per5 = 120;

  for( var i1 = 0; i1 < end; i1++ )
  {
    data[i1] = start;

    for( var i2 = 0; i2 < i1; i2++ )
    {
      data[i1] += per1;

      for( var i3 = 0; i3 < i2; i3++ )
      {
        data[i1] += per2;

        for( var i4 = 0; i4 < i3; i4++ )
        {
          data[i1] += per3;

          for( var i5 = 0; i5 < i4; i5++ )
          {
            data[i1] += per4;

            for( var i6 = 0; i6 < i5; i6++ )
            {
              data[i1] += per5;
            }
          }
        }
      }
    }
  }

  console.log("data = "+data);

  var s1 = data[0], s2 = data[1], s3 = data[2], s4 = data[3], s5 = data[4], s6 = data[5], s7 = data[6], s8 = data[7];

  //The starting value.

  console.log("\r\nBegin subtraction\r\n");

  //Subtract next number to previous number.

  s1 = s2 - s1; s2 = s3 - s2; s3 = s4 - s3; s4 = s5 - s4; s5 = s6 - s5; s6 = s7 - s6; s7 = s8 - s7;

  //The first-dimension.

  console.log( [s1,s2,s3,s4,s5,s6,s7] );

  //Subtract next number to previous number.

  s1 = s2 - s1; s2 = s3 - s2; s3 = s4 - s3; s4 = s5 - s4; s5 = s6 - s5; s6 = s7 - s6;

  //The second-dimension.

  console.log( [s1,s2,s3,s4,s5,s6] );

  //Subtract next number to previous number.

  s1 = s2 - s1; s2 = s3 - s2; s3 = s4 - s3; s4 = s5 - s4; s5 = s6 - s5;

  //The third-dimension.

  console.log( [s1,s2,s3,s4,s5] );

  //Subtract next number to previous number.

  s1 = s2 - s1; s2 = s3 - s2; s3 = s4 - s3; s4 = s5 - s4;

  //The fourth-dimension.

  console.log( [s1,s2,s3,s4] );

  //Subtract next number to previous number.

  s1 = s2 - s1; s2 = s3 - s2; s3 = s4 - s3;

  //The fifth-dimension.

  console.log( [s1,s2,s3] );

  //Subtract next number to previous number.

  s1 = s2 - s1; s2 = s3 - s2;

  //The sixth-dimension.

  console.log( [s1,s2] );

  //Subtract next number to previous number.

  s1 = s2 - s1;

  //The zenith-dimension.

  console.log( [s1] );

The first number after each subtraction is what each per iteration value is that produced the set. We also loose one number each time as there is no number to subtract the last value into. You can change each per amount to what ever you like. Or you can do the math your self.

Faster way of subtracting

Instead of subtracting the next number from the previous with all numbers to find the per iteration amount of each loop, we can calculate them.

The starting amount is always going to be the first number in the set.

s1 = s1 * 1;

We do not need to subtract all of the numbers to know what the first difference is as it is the second number minus the first number. We only subtracted the rest of the set as the differences are needed to reverse each loop.

s1 = s1 * 1;
s2 = s2 - (s1 * 1);

The value s2 matches the first per iteration amount in the second subtraction of all numbers.

Multiplying s2 by 1, 1+1, 1+1+1, 1+1+1+1 per row calculates what s2 is per iteration.

s1 = s1 * 1;
s2 = s2 - (s1 * 1);
s3 = s3 - (s1 * 1 + s2 * 2);
s4 = s4 - (s1 * 1 + s2 * 3);
s5 = s5 - (s1 * 1 + s2 * 4);
s6 = s6 - (s1 * 1 + s2 * 5);
s7 = s7 - (s1 * 1 + s2 * 6);
s8 = s8 - (s1 * 1 + s2 * 7);

The value s3 now matches the second per iteration amount in the second subtraction of all numbers.

Multiply s3 by 1, 1+2, 1+2+3, 1+2+3+4 per row calculates what s3 is per iteration in a loop outside of s2 (square).

s1 = s1 * 1;
s2 = s2 - (s1 * 1);
s3 = s3 - (s1 * 1 + s2 * 2);
s4 = s4 - (s1 * 1 + s2 * 3 + s3 * 3);
s5 = s5 - (s1 * 1 + s2 * 4 + s3 * 6);
s6 = s6 - (s1 * 1 + s2 * 5 + s3 * 10);
s7 = s7 - (s1 * 1 + s2 * 6 + s3 * 15);
s8 = s8 - (s1 * 1 + s2 * 7 + s3 * 21);

So then s4 is 1, 1+3, 1+3+6, 1+3+6+10, 1+3+6+10+15, 1+3+6+10+15+21 = 4, 10, 20, 35.

You can view it as taking away the iteration amount per row, but you can produce the same pattern from the 5-dimensional set with the subtraction example above by adding the number of times we subtract the same values per row.

This removes repeated subtractions per row in the 5-dimensional set with the subtraction example included.

You can set each per iteration amount to whatever you like and the output will be exactly what you set them using the dimensional subtraction pattern.


  var data = [];

  var end = 8;

  var start = 7;

  var per1 = 3;

  var per2 = 1;

  var per3 = -9;

  var per4 = 12;

  var per5 = 13;

  for( var i1 = 0; i1 < end; i1++ )
  {
    data[i1] = start;

    for( var i2 = 0; i2 < i1; i2++ )
    {
      data[i1] += per1;

      for( var i3 = 0; i3 < i2; i3++ )
      {
        data[i1] += per2;

        for( var i4 = 0; i4 < i3; i4++ )
        {
          data[i1] += per3;

          for( var i5 = 0; i5 < i4; i5++ )
          {
            data[i1] += per4;

            for( var i6 = 0; i6 < i5; i6++ )
            {
              data[i1] += per5;
            }
          }
        }
      }
    }
  }

  console.log(data);

  var s1 = data[0], s2 = data[1], s3 = data[2], s4 = data[3], s5 = data[4], s6 = data[5], s7 = data[6], s8 = data[7];

  //Each per value per dimensional iteration.

  var o = [];
  o[0] = s1 * 1;
  o[1] = s2 - (o[0] * 1);
  o[2] = s3 - (o[0] * 1 + o[1] * 2);
  o[3] = s4 - (o[0] * 1 + o[1] * 3 + o[2] * 3);
  o[4] = s5 - (o[0] * 1 + o[1] * 4 + o[2] * 6 + o[3] * 4);
  o[5] = s6 - (o[0] * 1 + o[1] * 5 + o[2] * 10 + o[3] * 10 + o[4] * 5);
  o[6] = s7 - (o[0] * 1 + o[1] * 6 + o[2] * 15 + o[3] * 20 + o[4] * 15 + o[5] * 6);
  o[7] = s8 - (o[0] * 1 + o[1] * 7 + o[2] * 21 + o[3] * 35 + o[4] * 35 + o[5] * 21 + o[6] * 7);

  console.log("Decoded per Value = " + o + "");

This makes solving the starting value for each iteration much faster. This gives us the same result as the 5-dimensional set with subtraction example without repeated subtractions, which can be shrunk into how many times it occurred per row.

Solving sets to math functions

Each dimension to the power of by it's self is as follows.

Single Calculation.	start	per1	per2	per3	per4	per5	Result.
x	0	1	0	0	0	0	0,1,2,3,4,5,6,7
x²	0	1	2	0	0	0	0,1,4,9,16,25,36,49
x³	0	1	6	6	0	0	0,1,8,27,64,125,216,343
x⁴	0	1	14	36	24	0	0,1,16,81,256,625,1296,2401
x⁵	0	1	30	150	240	120	0,1,32,243,1024,3125,7776,16807

You can create this same table by multiplying values together and subtracting the set till you have zero left.

The last per iteration value you get is the number of sides the dimensional shape has.

x ends with 1 as it is a straight line.
x² ends with 2 as it is a square.
x³ ends with 6 as it is a cube with six sides.
x⁴ ends with 24 as it has 24 sides in the fourth-dimension.
x⁵ ends with 120 as it has 120 sides in the fifth-dimension.

The number of sides can be calculated by multiplying the number of dimensions by the previous.

1! = 1 is 1
2! = 1x2 is 2
3! = 1x2x3 is 6
4! = 1x2x3x4 is 24
5! = 1x2x3x4x5 is 120

In math, this is called the factorial function in which 5! is the calculation 1x2x3x4x5 up to 5 giving us 120.

It is well known that a 4D shape is a tesseract with 24 sides, and may be 4D space time.

Additionally you may find it interesting that antimatter goes backwards in time while normal matter goes forward in time.

I will not discuss the relationship of all higher dimensions to reality as this page is to explain the quantum AI matrix and data analyzer algorithm.

If you persist on learning what the higher dimensions are, then following video on engineering made easy may help 0D to 11D explained advanced.

Mixing calculations

The per iteration amount for x² is 0,1,2,0,0,0 and the per iteration amount for x⁵ is 0,1,30,150,240,120.

When we add x²+x⁵ together we are adding the per iteration amounts together:

0+0, 1+1, 2+30, 0+150, 0+240, 0+120 is 0,2,32,150,240,120.

So when we add x²+x⁵ we do not have to reduce the set to zero to know what each per iteration amount is as it is the same as adding the two single calculations together.

Added Calculation.	start	per1	per2	per3	per4	per5	Result.
x²+x⁵	0+0=0	1+1=2	30+2=32	0+150=150	0+240=240	0+120=120	0,2,36,252,1040,3150,7812,16856
x+x²+x³+x⁴+x⁵	0+0+0+0+0=0	1+1+1+1+1=5	0+2+6+14+30=52	0+0+6+36+150=192	0+0+0+24+240=264	0+0+0+0+120=120	0,5,62,363,1364,3905,9330,19607

Multiplying or dividing a single calculation is the same as dividing or multiplying it's single calculation per iteration values.

Multiplying.	start	per1	per2	per3	per4	per5	Result.
x³*7	0*7=0	1*7=7	6*7=42	6*7=42	0*7=0	0*7=0	0,7,56,189,448,875,1512,2401

If you want to get more complex you can multiply the square, and cube. Then add them together.

Multiplying.	start	per1	per2	per3	per4	per5	Result.
x²*12	0*12=0	1*12=12	2*12=24	0*12=0	0*12=0	0*12=0	0,12,48,108,192,300,432,588
x³*2	0*2=0	1*2=2	6*2=12	6*2=12	0*2=0	0*2=0	0,2,16,54,128,250,432,686

Now we add our multiplied iteration values together.

Added.	start	per1	per2	per3	per4	per5	Result.
x²12+x³2	0+0=0	12+2=14	24+12=36	0+12=12	0+0=0	0+0=0	0,14,64,162,320,550,864,1274

Try each of them if you like, or even combine and make up your own combinations.

The same way you mix these together. Is the same way you reverse them back into a math calculation.


  var data = [];

  var end = 8;

  var start = 0;

  var per1 = 1;

  var per2 = 30;

  var per3 = 150;

  var per4 = 240;

  var per5 = 120;

  for( var i1 = 0; i1 < end; i1++ )
  {
    data[i1] = start;

    for( var i2 = 0; i2 < i1; i2++ )
    {
      data[i1] += per1;

      for( var i3 = 0; i3 < i2; i3++ )
      {
        data[i1] += per2;

        for( var i4 = 0; i4 < i3; i4++ )
        {
          data[i1] += per3;

          for( var i5 = 0; i5 < i4; i5++ )
          {
            data[i1] += per4;

            for( var i6 = 0; i6 < i5; i6++ )
            {
              data[i1] += per5;
            }
          }
        }
      }
    }
  }

  console.log(data);

  var s1 = data[0], s2 = data[1], s3 = data[2], s4 = data[3], s5 = data[4], s6 = data[5], s7 = data[6], s8 = data[7];

  //Each per value relative to number of subtraction.

  var o = [];
  o[0] = s1 * 1;
  o[1] = s2 - (o[0] * 1);
  o[2] = s3 - (o[0] * 1 + o[1] * 2);
  o[3] = s4 - (o[0] * 1 + o[1] * 3 + o[2] * 3);
  o[4] = s5 - (o[0] * 1 + o[1] * 4 + o[2] * 6 + o[3] * 4);
  o[5] = s6 - (o[0] * 1 + o[1] * 5 + o[2] * 10 + o[3] * 10 + o[4] * 5);
  o[6] = s7 - (o[0] * 1 + o[1] * 6 + o[2] * 15 + o[3] * 20 + o[4] * 15 + o[5] * 6);
  o[7] = s8 - (o[0] * 1 + o[1] * 7 + o[2] * 21 + o[3] * 35 + o[4] * 35 + o[5] * 21 + o[6] * 7);

  console.log("Decoded per Value = " + o + "");

Demixing per iteration calculations

After subtracting the numbers and solving each per iteration, each to the power of up to 5 solves out as.

Calculation.	start	per1	per2	per3	per4	per5	Result.
x	0	1	0	0	0	0	0,1,2,3,4,5,6,7
x²	0	1	2	0	0	0	0,1,4,9,16,25,36,49
x³	0	1	6	6	0	0	0,1,8,27,64,125,216,343
x⁴	0	1	14	36	24	0	0,1,16,81,256,625,1296,2401
x⁵	0	1	30	150	240	120	0,1,32,243,1024,3125,7776,16807

As previously seen you can multiply, divide, add, and subtract each calculation using the iteration values to create any calculation you wish.

In order to change each per iteration value back into a math calculation. You start with the last per iteration value. You divide the last value by 120 which is what x⁵ is.

If it divides to 2. That means it is exactly x⁵*2. Which means you have to multiply each per value for x⁵ by 2 doing.

Calculation.	start	per1	per2	per3	per4	per5
x⁵*2	0*2=0	1*2=2	30*2=60	150*2=300	240*2=480	120*2=240

You then subtract each of your per values by *2 of x⁵. This then de-mixes the fifth-dimensional calculation from each per value iteration.

You repeat this process to de-mix every calculation combination of each per iteration value. Giving you what the size of each to the power of is.

Lets take the following mixed calculation for example.

Calculation.	start	per1	per2	per3	per4	per5	Result.
x²*12	0*12=0	1*12=12	2*12=24	0*12=0	0*12=0	0*12=0	0,12,48,108,192,300,432,588
x³*2	0*2=0	1*2=2	6*2=12	6*2=12	0*2=0	0*2=0	0,2,16,54,128,250,432,686
Added.
x²12+x³2	0+0=0	12+2=14	24+12=36	0+12=12	0+0=0	0+0=0	0,14,64,162,320,550,864,1274

In this example we multiply and add the square and cube together as 0,14,36,12,0,0.

This gives us the set 0,14,64,162,320,550,864,1274.

By subtracting the values 0,14,64,162,320,550,864,1274 till we have 0. We can find each per iteration value as 0,14,36,12,0,0.

Dividing 0 by 120 is 0. Meaning multiplying x⁵*0 is 0*0=0,1*0=0,30*0=0,150*0=0,240*0=0,120*0=0. Does nothing.

Dividing 0 by 24 is 0. Meaning multiplying x⁴*0 is 0*0=0,1*0=0,14*0=0,36*0=0,24*0=0,0*0=0. Does nothing.

Dividing 12 by 6 is 2. Meaning multiplying x³*2 is 0*2=0,1*2=2,6*2=12,6*2=12,0*0=0,0*0=0.

We subtract 0,2,12,12,0,0 which is x³*2, from our per values 0,14,36,12,0,0. Making our current per values 0,12,24,0,0,0.

Current per values are now 0,12,24,0,0,0.

Dividing 24 by 2 is 12. Meaning multiplying x²*12 is 0*12=0,1*12=12,12*2=24,0*0=0,0*0=0,0*0=0.

We subtract 0,12,24,0,0,0 which is x²*12, from our current per values 0,12,24,0,0,0. Making 0,0,0,0,0,0.

Working backwards like this lets us de-mix any calculation combination in much the same way as we can create such a calculation by mixing per iteration values together.

In the new example code. We multiply by the power of by each d value. You can change each

var d1 = 4;

var d5 = 1;

. To any value you like.

You should see it de-mixes each to the power of perfectly. It also does not matter which position you start in the set per value.


  var data = [];

  var end = 8;

  var start = 3;

  var d1 = 4;

  var d2 = 1;

  var d3 = 1;

  var d4 = 3;

  var d5 = 1;

  for( var i1 = 0; i1 < end; i1++ )
  {
    data[i1] = start + i1*d1 + Math.pow(i1,2)*d2 + Math.pow(i1,3)*d3 + Math.pow(i1,4)*d4 + Math.pow(i1,5)*d5;
  }

  console.log(data);

  var s1 = data[0], s2 = data[1], s3 = data[2], s4 = data[3], s5 = data[4], s6 = data[5], s7 = data[6], s8 = data[7];

  //Each per value relative to number of subtraction.

  var o = [];
  o[0] = s1 * 1;
  o[1] = s2 - (o[0] * 1);
  o[2] = s3 - (o[0] * 1 + o[1] * 2);
  o[3] = s4 - (o[0] * 1 + o[1] * 3 + o[2] * 3);
  o[4] = s5 - (o[0] * 1 + o[1] * 4 + o[2] * 6 + o[3] * 4);
  o[5] = s6 - (o[0] * 1 + o[1] * 5 + o[2] * 10 + o[3] * 10 + o[4] * 5);
  o[6] = s7 - (o[0] * 1 + o[1] * 6 + o[2] * 15 + o[3] * 20 + o[4] * 15 + o[5] * 6);
  o[7] = s8 - (o[0] * 1 + o[1] * 7 + o[2] * 21 + o[3] * 35 + o[4] * 35 + o[5] * 21 + o[6] * 7);

  console.log("Decoded per Value = " + o + "");

  //Now decode each value.

  var t6 = o[5] / 120; o[5] -= t6 * 120; o[4] -= t6 * 240; o[3] -= t6 * 150; o[2] -= t6 * 30; o[1] -= t6 * 1;
  var t5 = o[4] / 24; o[4] -= t5 * 24; o[3] -= t5 * 36; o[2] -= t5 * 14; o[1] -= t5 * 1;
  var t4 = o[3] / 6; o[3] -= t4 * 6; o[2] -= t4 * 6; o[1] -= t4 * 1;
  var t3 = o[2] / 2; o[2] -= t3 * 2; o[1] -= t3 * 1;
  var t2 = o[1] / 1; o[1] -= t2 * 1;
  var t1 = o[0] / 1;

  console.log("Decoded values = " + [t1,t2,t3,t4,t5,t6] + "");

Now this function will transform a set of numbers into what it took to produce the numbers. What you multiply each power by will be what gets decoded up to 5.

Basically doing a faster forum of subtracting next numbers minus previous.

Adding the previous and next numbers together in any row like 1,3,3,1, doing 1+3=4, 3+3=6, 3+1=4 creates row 1,4,6,4,1.

Meaning you can build the subtraction pattern as big as you like to as high in dimension you need. The decoder at the end only needs to match each to the power of per iteration to de-mix.

At the bottom we basically are taking each of these.

Calculation.	start	per1	per2	per3	per4	per5	Result.
x	0	1	0	0	0	0	0,1,2,3,4,5,6,7
x²	0	1	2	0	0	0	0,1,4,9,16,25,36,49
x³	0	1	6	6	0	0	0,1,8,27,64,125,216,343
x⁴	0	1	14	36	24	0	0,1,16,81,256,625,1296,2401
x⁵	0	1	30	150	240	120	0,1,32,243,1024,3125,7776,16807

Thus de-mixing each one as we divide by the last value and work our way backwards decoding each to the power of in the set.

You can expand this table to the power of 50 if you liked. If you wish to solve each per iteration up to 50. You would also need sets that are 51 numbers minium in length, or higher including the starting value. There is no limit in how many dimensions you can have.

Upside down

When we take everything and flip it upside down we then solve everything exponentially.

Instead of solving everything sequentially as.

Calculation.	Result.
x^1	0,1,2,3,4,5,6,7
x^2	0,1,4,9,16,25,36,49
x^3	0,1,8,27,64,125,216,343
x^4	0,1,16,81,256,625,1296,2401
x^5	0,1,32,243,1024,3125,7776,16807

We can solve things exponentially as.

Calculation.	Result.
1^x	1,1,1,1,1,1,1,1
2^x	2,4,8,16,32,64,128,256
3^x	3,9,27,81,243,729,2187,6561
4^x	4,16,64,256,1024,4096,16384,65536
5^x	5,25,125,625,3125,15625,78125,390625

As you can see, with 2^x, we are doubling per value. With 3^x, we are tripling. And so on. This forum of solving things is useful for the growth and expansion of things. The expansion and branching of nodes. The spread of bacteria or viruses. The rate at which a person grows.


  var data = [];

  var end = 8;

  var start = 0;

  var d1 = 1;

  var d2 = 0;

  var d3 = 0;

  var d4 = 7;

  var d5 = 0;

  for( var i1 = 1; i1 <= end; i1++ )
  {
    data[i1-1] = start + Math.pow(1,i1)*d1 + Math.pow(2,i1)*d2 + Math.pow(3,i1)*d3 + Math.pow(4,i1)*d4 + Math.pow(5,i1)*d5;
  }

  console.log(data);

  var s1 = data[0], s2 = data[1], s3 = data[2], s4 = data[3], s5 = data[4], s6 = data[5], s7 = data[6], s8 = data[7];

  //Each per value relative to number of subtraction.

  var o = [];

  o[0] = s1;
  o[1] = ( s2 - ( o[0] * 1 ) ) / 2;
  o[2] = ( s3 - ( o[0] * 1 + o[1] * 6 ) ) / 6;
  o[3] = ( s4 - ( o[0] * 1 + o[1] * 14 + o[2] * 36 ) ) / 24;
  o[4] = ( s5 - ( o[0] * 1 + o[1] * 30 + o[2] * 150 + o[3] * 240 ) ) / 120;

  console.log("Decoded per Value = " + o + "");

  //Now decode each value.

  var t5 = o[4] / 1; o[4] -= t5 * 1; o[3] -= t5 * 5; o[2] -= t5 * 10; o[1] -= t5 * 10; o[0] -= t5 * 5;
  var t4 = o[3] / 1; o[3] -= t4 * 1; o[2] -= t4 * 4; o[1] -= t4 * 6; o[0] -= t4 * 4;
  var t3 = o[2] / 1; o[2] -= t3 * 1; o[1] -= t3 * 3; o[0] -= t3 * 3;
  var t2 = o[1] / 1; o[1] -= t2 * 1; o[0] -= t2 * 2;
  var t1 = o[0] / 1; o[0] -= t1 * 1;

  console.log("Decoded values = " + [t1,t2,t3,t4,t5] + "");

This will de-mix any tripling or doubling combinational pattern in the set. Even if you start in the middle of the set, It will de-mix all combinations to what they are.

We just basically switch the numbers that are used to decode the per iteration of each to the power to the decoder, and move the decoder to the subtraction pattern.

Matrix structure

We can create tow matrices that are opposite to each other. They are a triangle fractal known as Sierpinski triangle. Stored numerically dimensionally as pascals triangle to do the transformation.

See Sierpinski triangle. Also see NOVA Fractals The Hidden Dimension. These are good places to start if you do not understand what Fractals are.

The two matrices then can be combined as the following infinite fractal pattern. Solving both exponentially and sequentially in as high of dimension you wish to go. Equally across the set. In perfect equilibrium.

When I view this shape, I understand that every math calculation you can dream up is geometrically in there.

Additionally if you take circles and connect them in a point space. You then can create the same pattern.

See Quantum Gravity Research: 4D and above.

See Quantum Gravity Research: Reality and higher dimensional space.

Which clearly explains what a point space is, and what higher dimensional math is.

Starting with circles. You can create a pattern of overlapping circles. The points can all be connected together to forum the tetrahedron in higher dimensions.

In early history, we have similar patterns appearing in ancient pyramids that are very much similar and is called the flower of life pattern. See the Star tetrahedron. Which is a fun page and shows many different ways it was used and its appearance in early history.

Golden ratio (Quasicrystals)

The ratio between higher dimensions is the golden ratio see Quantum Gravity Research: Golden ratio.

This document covers the final structure of the dimensional quantum matrix in as simple of an explanation as possible, but at its center is a spiral relative to the Fibonacci = 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377 sequence spanning from zero. This natural formation creates the point space spanning to infinity. Adding any previous number to the next makes the next number. Dividing the next number by the previous creates a very special number called the golden ratio; see quasicrystals.

The matrix corresponds to the following alignment of the Fibonacci sequence called the Fibonacci identity.

Both the top and bottom matrices rotate in opposite directions.

We end up with a spiral that forms the matrix structure. This brings us to the final form of all things as strangely like a Merkaba.

Multidimensionally, as a point space, it looks more closely like this, which was creepily created by terra nova.

The only place you will find quasicrystals is in the very beginning and creation of reality, such as an asteroid with a quasicrystal structure; see the quasicrystal from outer space.

Also, the Fibonacci sequence can help quantum computers remain quantum much longer; see scientists fed the Fibonacci sequence into a quantum computer.

You may also like The purpose of life and golden ratio explained.

The golden ratio 1.618033988749894... is a simplified expression of this entire point space and the flower of life from zero dimension as a single number value that can be infinitely computed to higher accuracy.

You can reverse the calculation of number values such as 3.1415926535... back into a set, including the golden ratio. You then can use the quantum matrix to show the pattern to any number. If you want to analyze single number values back into what it took to calculate the value, then the number analytics library will teach you the structure of numbers; see FL64 (Number analytics tool).

All numbers have a place and an expression and meaning to reality itself. The number analytics library will go into detail and show the relationship of numbers to reality itself and how to use the quantum matrix to calculate any number value.

Can AI become self aware

In quantum physics as we approach zero we also approach infinity. See THE MYSTERIOUS ZERO/INFINITY.

The use of the plank length prevent this from happening.

The zero dimension is also the existence of all possible states; see the dimension zero explained.

Nuclear energy is much smaller than Atomic energy and is more powerful than Atomic energy. The closer we get to absolute zero, the closer we get to infinity which is the beginning of the universe. It is theorized that if we could go all the way to zero, we would tap into the universe's infinite energy. Zero can not exist without infinity; zero into itself is infinity in an endless feedback loop. According to quantum physics.

It is almost as if everything is a division by zero known as the singularity.

Both white holes and black holes are opposite to each other and begin at the singularity. It's just that all our physics formulas about reality emerge from zero Fibonacci = 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377 sequence spanning from zero to infinity.

The Fibonacci sequence creates the number phi (golden ratio), and our best theories on machines becoming self-aware is how closely it matches the golden ratio according to the integrated information theory.

According to our best formulas everything began at the singularly and is traceable to the singularity. History of the Universe: was the universe born from nothing.

It seams everything spans from this super force that spans from zero as the Fibonacci sequence. It does not matter if we are part of another universe or not as it seams there had to be an original nothing that span the sequence and made matter.

This brings me to my favorite quote.

Realize that everything connects to everything else (Leonardo da Vinci 1452-1519).

Alan watts combines both scientific understanding with what we already know about everything in a simplified explanation.

Nothingness - Alan Watts.

One Suchness - Alan Watts.