Some random food for thought:

c=ab

2 inputs

infinite solutions

infinite wrong solutions

1 right solution - two primes

encode solution not as a number

but as a pattern, algorithm, approach towards the number

Imagine playing chess.

Every piece has a specific pattern/permutations in which it can move/exist.

Solution to the game is check mate - a specific pattern amongst some pieces.

Superimpose piece patterns to get all possible patterns for all pieces.

On every move discard those patterns that dont lead to check mate.

Play the game.

At the begining there is a starting pattern amongst all pieces.

And a superposition of all possible patterns.

As the game progresses and moves are made, solution space shrinks.

Everytime some cell gets occupied by some piece, solution space shrinks.

On every move evaluate if this specific pattern (can) leads towards check mate.

Does it make sense?

Can we apply it to our problem?

Pieces are equations,

Check mate is c=ab,

Patterns are grid patterns?

Row 0 is a superposition of all possible patterns at every step?

Everytime a cell gets occupied/calculated….???

Just some thoughts, maybe it helps someone.

Will probably work on the analogy further as I can see some resemblance.

Without any information or sense of what the best move is, of what the best pattern to follow is an algorithm would still reach the solution-check mate, but by randomness.

So, how do we evaluate which pattern in any moment is the best, optimal?

Dont mind me, just thinking out loud :-)

So… what are your thoughts on how The Grid relates to RSA?

:

RSA revolves around Eulers PHI function, phi(N), pic related

phi has all primes on its diagonal and a fractal pattern inside a triangle

Our c is somewhere in the fractal, related to a,b who are predictably on the diagonal

Every point in a fractal is self-similiar

We are trying to find a pattern that ties our c to all its self-similiar points in the fractal

a and b are hidden in the pattern

Something about triangles, squares and fractals?

The Grid reverses the operation

It starts with some input 'c' and applies a square pattern on phi untill perfect squares(primes) are found???

Diagonals of prime squares?

The Grid is built for a specific version of RSA, specific constants

It might be easier to concentrate all our efforts on one specific path if we discuss how we SEE the problem.

for a moment consider every digit in a base a unique component

multiplication a composition and division decomposition of a number

sum, as all possible linear combinations of unique components to construct a number

base10,mod9:

-791=7+9+1=17=1+7=16+1=91+7=8

-791=16mod9+1mod9=91mod9+7mod9=8mod9=8

-135727=1+3+5+7+2+7=13+57+27=135+727=75+13+27=123+577=7

-478=1

if a in base10 then sum_digits(a)=amod9

whole part of division by 9 is number of overflows in the algorithm

base16,mod15:

-791=0x317=0x3+0x1+0x7=0xB=0x31+0x7=0x17+0x3=0x38 →convert to base10,mod9→0xB=11->0x11->17=8

-791=0x317=0x31mod15+0x7mod15=0xB

the result in base16 is actually a direct result in base10: 791/15=52+11

-135727=0x02122F=0x0+0x2+0x1+0x2+0x2+0xF=0x16=0x000007=0x02+0x2F+0x12→convert to base10,mod9→0x7=7->0x7->7=7

-478=0x01DE=0x0+0x1+0xD+0xE=0x01+0xDE=0x1D+0x0E=0x001C=0x000D →convert to base10,mod9→0xD=13->0x13->19=1

the result: 478/15=31+13

how to do division using only addition?

c=a/b

a in base10

convert a to base(b+1)

sum the digits arbitrarily

when sum>b, ovf++;

sum=remainder

ovf=whole part

once you have the remainder of a for one base, you can easily convert between bases and get remainder for other divisions

now imagine you have a number c that is 100 digits long in base10

in base100 the digit itself is the remainder, ovf=0

idk,maybe… will try to write up a script later for arbitrary bases to see what we get.

>>8170

I've written a script that computes remainder of any number when divided by (2^n)-1 only by summation and bit hacking.

It works by converting a number into series of digits in a chosen base and modulo summing the digits. As is, it works only for bases2^n, so for divisions of the form 2^n-1.

I think this can be further developed for any base, by treating each bit (when converting) not only as 0 or 1, but as a float between 0…1.

(pic related)

And with some clever bit hacking, we should be able to factorize any number stupidly quickly.

The code is written in C: https://pastebin.com/bj8U1Qb1

And can be tested online: https://www.onlinegdb.com/

>>8292

A crude algorithm for now.

But am thinking if we figure out how VQC came to his algorithm, we could figure out how the Grid works. As it was said a lot of times, the Grid is the solution.

Code that resembles a bit more what VQC posted: https://pastebin.com/5t67KA0f

This algorithm also generates a grid with base in column (array of n) and where each row contains digits (n[].d[]) that make up the original number (x) in observed base.

n[].r holds a value of x mod (base-1).

This algorithm still works only for (2^n)-1 divisions. Will try to extend to to any base. Any help,guidance or criticism is appreciated.

>>8295

Yep sorry, will explain it more later. The uploaded code is wrong however, will work on it.

In the meantime, if we represent a value in some number base, base16: 0x3ab7, it means 7+b16+a16^2+3*16^3.

But the part b16+a16^2+3*16^3 is just sum of 16 (base) and 7 (remainder), the last digit is the remainder if 0x3ab7 divided by 16.

The problem I think we are solving is find a base b where last digit of a number is 0. Or rather construct a number in some base such that last digit is 0.

The base is then the solution. As number/base=0.

https://en.wikipedia.org/wiki/Redundant_binary_representation

Intuition :-) Also seems like a fun problem to work through.

No, not all. But the problem we are all solving is factorization. No?

>>8303

>VQC sez: "(You) are at The final lock and key construction steps. Happy to give it but it is the Eureka moment and anons are close. In hindsight, it shows exactly why this problem has existed for so long.You are solving two problems at once in this method of constructing the answer. Also in hindsight the steps give the pattern back in the grid (The End).

Maybe the answer is not in a decimal form but rather in some other base. Learning why and how the algorithm was constructed will reveal the answer.

>>8306

The question still remains, why does it work the way it works.

You guys are too far in and too close, you work on yours and I will try something along a different path.

Who knows, maybe we can be of a help to one another.

an interesting property, admitedly tested only on short integers

not directly connected to the problem presented, but nevertheless

sum of digits in base(b+1) is same as last digit in base(b)

e.g (base8):

0c1420=1+4+2+0=7(in base8) means its divisible by 8 and 7

0c3774=3+7+7+4=7(in base8) means its divisible by 7 and remainder when dividing by 8 is 4

0c7120=7+1+2+0=3(in base8) means its divisible by 8 and remainder when dividing by 7 is 3

0c6305=6+4+0+4=7(in base8) means its divisible by 7 and remainder when dividing by 8 is 5

0c6620=6+6+2+0=7(in base8) means its divisible by 8 and 7