make path using binary, steps of binary power = path
= [(2 ^ 0, 2 ^ 1, 2 ^ 2, 2 ^ 3, 2 ^ 4) = [(1 or 0), (1 or 0), (1 or 0), (1 or 0), (1 or 0)]]
learn path = one binary at a time completes binary power.
= [(2 ^ 0, 2 ^ 1, 2 ^ 2, 2 ^ 3, 2 ^ 4) = [(1), (1), (1), (1), (1)]]
redo binary power correcting binary errors in subsequent versions to match the number made in the binary power
if previous binary path = true, new binary path may also be true.
changing the binary power to be true for a lower binary power, 2 to the 0 power for example = 1,
greater binary power which does not know this binary value of 2 to the power of 1 = 0 incorporates the value into the number their binary power makes
= [(2 ^ 0, 2 ^ 1, 2 ^ 2) = [(1), (1), (1)]]
= [2 ^ 3, 2 ^ 4) = [(1 or 0), (1 or 0)]]
in creating the value the binary power equals, you incorporate lower binary power values into the greater binary power value which sorts out errors = blend binary path
you branch out the various nouns into their own verb binary path, a verb binary path merges greater binary power paths with lower binary power paths
to make the greater binary path true.
the greater the binary power, the more smaller binary values have to be made to fit the greater binary power, the harder to complete the harder to merge.
for example the number pi, you can merge pi to math but not all of the number pi.
and for things that are a rational number you need to have the entire binary power path, this is considerate.
so fitting a irrational number to a rational number is corrupt. you need to take only a part of the irrational number to a rational value = proportion.
therefore, if a path = a binary to some power, made up of smaller binary power that are themselves made up of smaller binary power,
reversing the largest binary value down each power in the path to sort out its origin might fix the one largest path to sort out the smaller paths to their value,
but the smaller value or path is tied to the larger value so it holds the smaller values in relation to the largest path value.
therefore in sorting out the return to the smallest value the largest value having sorting out the smaller values to their position,
keeps the largest value open as reference for that value or power till that power has completed its return to the smallest value.
= [(2 ^ 0, 2 ^ 1, 2 ^ 2) = [(1), (1), (1), (1)]]
= [2 ^ 4) = [(1 or 0)]]
therefore, to remove smaller power values inaccessible to the larger path power, the larger path power creates a path intermediate that removes the small power value for the larger power path.
= 2 ^ 3
so thats my theory. in practice if you jimmy up an algorithm using my theory the bot would see it needs the intermediate to generate the result wanted.
the binary goes up to the problem, but not down to the solution.
so the intermediate 2 to some power, is held open binary to some power, made up of smaller binary power that are themselves made up of smaller binary power, eventually to 2 ^ 0. each time this happens a new pice of the puzzle is added until the entire puzzle can be solved, all the pieces are there.
in my theory, the bot would see it needs to sort out a value to its original spot, it cant, so it uses an intermediate paths to generate the result wanted.
im not able to test this theory practically yet, im still learning my binary theory and other maths and game programming but for future reference both to myself and others and people who could jimmy up an algorithm using my theory i put this here now.
i could have put this in the off topic forum but its useful for bots which might come in handy for oculus.