/vqc/ - Virtual Quantum Computer

>>8446

Right, but if it isn't necessarily what he meant, and we need to study the thing and figure out if it is what he meant and if so what specific patterns are in play, shouldn't we do that in RSA general? This thread is for things we understand. and can explain. So far I don't even completely understand where you're going with this (since before you were looking at the triangle bases being a factor of (x+n)(x+n), and now it's n-1).

sqrt(d) is between the mirrors of the elements that d is between in (e, 1)?

>>9071

What is a mirror element?

>>9081

getElement(-f, 1, getT(x[t]+1))

Where c is the product of two primes:

c % (N-1) = 2d+1

>>9121

That should be 2d-1. It also appears to be the case for all numbers regardless of the number of factors.

If n is too small, the large square appears as an exact value of i[t] in e or -f

That is what the algorithm from earlier is showing, it can be extended.

>>9124

What does "too small" mean? The point of this thread is to get all the patterns we completely understand in one place, so you'll need to figure specifically what types of n values this works for and specifically what elements they appear in in (e,1) and (f,1).

>>9125

public VQCElement getElementBelowRoot(BigInteger e, BigInteger n, BigInteger d) {
        BigInteger c = d.multiply(d).add(e);
        BigInteger f = (d.add(n)).pow(2).subtract(c);
        BigInteger xpn = sqrt(f);
        BigInteger x = xpn.subtract(n);
        
        boolean eIsEven = isEven(e);
        boolean xIsEven = isEven(x);

        if (!(eIsEven == xIsEven)) {
            x = x.subtract(one);
        }

        return getElement(e, n, getT(e, x));
    }

>>9126

If we input -f, 1, d into this method, calculates

c = d^2 + f

(d+1)^2 - c = e

xpn = sqrt(e)

x = xpn - 1

So in this way, taking sqrt(e) and sqrt(f) give us the elements that d is between.

>>9127

That's interesting, do you know what happens if you multiply d by two?

>>9128

No, what happens?

>>9127

I was wrong about half of my observation. sqrt(f) gives you where d is between in (e,1), but sqrt(2f + e) is what gives you where d is in (-f, 1)

I misinterpreted an addition operation for a subtraction operation in my program. What it for -f is this:

c' = d^2 - f

(d+1)^2 - c' = f'

xpn = sqrt('f)

x = xpn - 1

I noticed my mistake because sqrt(e) was giving the wrong x value, but sqrt(2f+e) wasn't.

>>7960

The n0 base is a way to calculate through iterations the correct value of n or n-1. The iterations required are no bigger in complexity than Big Oh for the root of c.

A staircase number is a number that can be expressed as the addition of two or more consecutive numbers (e.g. 3+4+5, 8+9+10+11+12+13, 22+23). To find one configuration of a staircase number for any odd number, we add one to the value then divide it by two. Then the number is equal to the result added to the result minus one (e.g. 67 = (67+1)/2 + ((67+1)/2)-1 = 33+34).

One place in the grid in which we find two consecutive numbers like this which can be added together to find a staircase number is the x values in (e,1) and (f,1). Two elements from two (e,1) and (f,1) cells with the same t value will have consecutive x values. For example, (-17,1,6) has an x value of 11, but (30,1,6) has an x value of 10. These are consecutive numbers, so they produce the staircase number of 10+11=21.

Something Chris has suggested that we look into is where the x values of two paired (e,1) and (f,1) elements at the same t add together to produce na or n-1 (depending on which one is odd).

>>7420

>a from (e,1,1) = c at (2c,1,1) and (2c-1,1,1)

We can find c at t=1 in both of these cells. We can also find c at t=2, t=3 etc. Since all a values in (e,1) are twice a square or the sum of consecutive squares (based around t) plus either e/2 or (e-1)/2, but we're choosing t, we can just take 2(t-1)(t-1) and (t-1)(t-1)+tt away from c to find e/2 or (e-1)/2 and therefore calculate the columns in which c will appear as an a value in (e,1). So we can find where c appears in (e,1) at t=1, t=2, t=3 etc through calculation. There is a pattern to the columns where c will appear at each t value. Where c145 appears as a[t] in (e,1) with t increasing from 1 upwards, to begin with for even e is 290, 286, 274, 254, 226, 190, etc. -4, -12, -20, -28 etc. The gap between cells increases by 8 each time for even e. For odd e, 289, 281, 265, 241, 209, 169, etc. -8, -16, -24, -32, etc. The gap between cells also increases by 8 each time, but the first started at 4 and this one starts at 8.

In all of these columns, there will be a cell where n equals our a and one of the a values equals our b, as well as where n is our b and one of the a values is our a. This is because each a[t] represents na for some c. All of these columns will have this in common. When Chris posted about this, he said "how many columns do you need to create a lookup?" This implies that having a certain number of these columns calculated will give us enough information to create a lookup. Nobody seems to have figured out what information is specifically important in this context so far.

"Values of t that are derived from imaginary numbers can be thought of as orthogonal to the grid." This could relate to when Chris told us to consider the idea of elements in the grid coming out towards you. He never elaborated about what imaginary numbers these t values need to be derived from. Obviously if we're taking a square root in order to produce imaginary numbers this would imply he's talking about negative c values. Taking sqrt(-c), we would end up with di, which, squared, would be a negative square. For example, if we take c=-559, d=23i, and dd=-529. e = c-dd, so e here would be -30. This is e for c=559 but negative. f=e-(2d+1), so here f = -31-46i. I never did imaginary numbers in school so I'm not sure where you'd go from there, but it would appear that using negative c produces a new set of cells and numbers that may be worth analyzing. This is obviously not a completely-understood pattern, but this paragraph at the very least potentially explains the opening statement from a post by Chris, which can be expanded upon when understood further.

If c has two prime factors (and is therefore semiprime), it'll have two na values (including BigN). If c has three prime factors, it'll have four na values. If c has four prime factors, it'll have eight na values. The number of na values a given c has increases exponentially with its total number of prime factors. So within (e,1) and (f,1), there will be more values of na and (n-1)a if c has a higher number of factors. This also means the number of overall factors (prime and/or composite) and the number of valid n values for a given c increases exponentially with the number of factors it has.

Chris said that we're meant to make use of this concept by multiplying c by another number q. q is meant to be the product of several small known prime numbers (e.g. 5*13*17), and is meant to be slightly bigger than d. There was a vague post in RSA #15 that led us to believe that these small primes are meant to be odd sums of two squares, but Chris never confirmed. We're meant to multiply c by q to give us a new number for which there are more na values, giving us more information. With a semiprime c, since we will know these small prime numbers, we will know all of the corresponding na values for each known factor. So, for example, if we were to multiply 817 (19*43) by q=5*13=65 to get qc=53105, we still wouldn't know 19 and 43 are factors of 817, but we would know that 5, 13, 65 and 817 are factors of 53105. This would give us eight known na values, thereby increasing the amount of information we know within the (e',1) and (f',1) cells. It also obviously means qc will turn up in more cells within the e' and f' columns than c appears in the e and f columns. According to Chris, "there is a point where the number of factors gives up the answer." Also according to Chris, our original a must appear twice in the first a+1 [e',1,t] elements of [e',1], and "the two values we are forcing with the grid" are the "factors [that] will also make up the two values of t where a is a factor". This statement is a bit vague. He refers to these two numbers we're forcing with the grid as factors, which would imply that we're looking for a[t]/a for the two elements in (e',1) where a appears as a factor between 1 and a+1, but he specifically says "values of t", which specifically refers to t, and not to a[t]. Either way, we are apparently looking for two values that both directly relate to two elements in (e',1) where a[t] is divisible by our unknown a and where t is between 1 and a+1 (inclusive).

This process is also allegedly meant to increase the smoothness of BigN-n (i.e. the highest prime factor of BigN'-n' should be lower than the highest prime factor of BigN-n). Chris said "if you multiply c by small primes, the smoothness of BigN-n increase". This does not appear to be the case, however, as I showed >>9049 here. It's worth mentioning in Grid Patterns given Chris said it. Maybe he'll come back and elaborate on this point eventually and I can update this post.

There are three types of prime or rather there is a way to separate primes.

Those in column [1,n], those in column [2,n] and those that are not.

Those in column 1 are the sum of two squares.

Those in column 2 are the sum of three squares.

c%d is congruent to e%d

Column (-1,n) contains an entry in every cell, like column (0,n). In (-1,1), the series of d values (1, 7, 31, 49, etc) are each two times a square minus one (so they're also the n values in (0,n) where a and b are both squares minus 1). Also in (-1,1), the series of a values (4, 12, 24, 40, etc) contain within them as factors every single prime number. They appear in a pattern, shown >>8883 here. Where a prime number appears as a factor of a[t] in (-1,1), it will also appear at this t+1. The first two appearances of primes in a cell at [e,1] have the property where their values of their position t, summed is the value of the prime plus one. Five will appear twice within the first six elements, seven twice within eight, etc. This series is meant to help our lookup somehow.

>>9156

The product of a and some values of q will appear before N'c' in [e',1] with one of the n' values.

There's meant to be a trivial lookup based on everything we already know and a non-trivial lookup that relies on the results of the trivial lookup. The trivial lookup returns t, e and f (we don't know if that t value is the correct one but given there's a separate non-trivial lookup it doesn't seem likely), and the non-trivial lookup returns n (-1 for prime, 0 for square c). Chris didn't give us enough information to infer anything about how the non-trivial lookup works yet (aside from explaining various patterns that are apparently relevant), but he did say that we would use columns -f,0,1 and e; rows 1, (n-1), n, X, Y and C. It depends at least on odd e/even e (i.e. it'll work differently for either one) at a minimum (meaning it could potentially be optimized by going further with things like odd x+n, even n, etc). Column 0 contains the square of c. X and Y are the positions of n between 1 and the square of c (this is extremely vague but it's a direct quote). X and Y will not exist for primes (that depends on the value of f and d - again, a pattern we haven't necessarily understood yet). The work we did with triangles will show which integers are primes. It also pays to mention that a certain notorious weirdo on /qresearch/ once said out of the blue "use X on Y at C", which could potentially be relevant (but possibly not).

In the (e,1) and (f,1) cells corresponding to our given c, from t=1 upwards, we see an increasing infinite series of d values. There are two elements in (e,1) and two elements in (f,1) where the d from our given c fits between the d[t] values. Something about this is meant to be important.

Here are a few more things to add to >>7982 that (as far as I could tell) nobody has looked into yet or are not fully understood.

—————————————————————————

The non-trivial method uses a pattern you might not have seen yet but has been discussed.

You know how to look up a number c from column 0 or 1. One way is to take a[t] from c in [0,1] or [1,1], divide the remainder by two and add that to the column to get c in another column.

The value c can be looked up in many columns this way.

This gives enough information to find a, x and n.

In other words.

The columns that c appears in, determines it's composition.

That is the power behind the grid.

Try it with both primes and composite numbers. Anything strike you? Once you c it…

—————————————————————————

Here is a tip, if i(t) has not been done before.

Take products, c, that have odd x+n. And even n.

Take one from x+n.

8 triangles.

Create a table.

What does f and 2(n-1) contribute?

Because the tips of all 8 triangles are from (n-1)(n-1) - 1.

Find the pattern from large to small.

There are h families!

Avoid the 13th step of AA.

—————————————————————————

All values in the cells at n=1 are products where you add a small square to e to make a square with c.

—————————————————————————

There always exist another multiple of a that has a modular congruence with c. (it was from the c%d stuff)

—————————————————————————

sqrt(a) is our long side length of the triangle, with t and t + 1 being the other two sides.

—————————————————————————

(In relation to qc)

By controlling the low prime numbers as a product with, an increasing (non-linear) amount of information is forced upon [e',1]. Each of those factors have to appear early and forever after once they appear in the grid. The sequential probability of consecutive primes being in a random value of [e',1] are low and place huge restrictions on the other primes, including a and including the values of x.

The low primes act to filter out the numbers that a cannot be based on what we know in [e,1] and, importantly in [-f,1]. Because one is odd, and one is even, the overlap and distribution of odd numbers in one of these columns and e' is such that a lookup becomes possible. BigN' comes into play.

—————————————————————————

The importance of column zero is all in the fact that it encodes c value whose remainder is 0, squares

It's filled with alternate factorisations of squares

Shouldn't such an alternate factorisation exist for i or squared?

>>9364

Just stop already.

The well has dried up.

There isn't anyone else to lure.

Nobody listens to you any more.

>>9379

Who ya talkin' to?

>>9378

>>9379

That wasn't Chris, spooky anonymous pessimist. That was one of us who doesn't post with a name.

>>9444

SeeIt v4.

C, C2 = the elements c is between in i[t] in row one

Add parity matching to half the element calculations required to check for an i[t] = i match.

Add calculations to find j[t] match in C and C2

Remove experimental na factoring.

Add new experimental calculation.

Enumeration so far

(e,1) and (f,1) elements of note

>In (e,1) we have elements where a[t]=an and a[t]=bn. In (f,1) we have elements where a[t]=a(n-1) and a[t]=b(n-1). These elements are n and n-1 apart in terms of t respectively.

>Since an and bn appear in (e,1) and a(n-1) and b(n-1) appear in (f,1), the equivalent elements appear for c=1*c. In (e,1) we can find elements where a[t]=BigN and c*BigN. In (f,1) we can find elements where a[t]=BigN-1 and c(BigN-1).

>In (e,1) where x=c-d and where x=c+d+1, a[t]=c*BigN and a[t]=c(c-BigN+1) respectively, and in (f,1) we have equivalent elements where a[t]=c*(BigN-1) and a[t]=c(c-BigN+2). In both positive and negative space, these cells are 2d+1 apart in terms of t (the d in this gap being the d of the c we're trying to factor)

>i[t]=i occasionally pops up in the elements in (e,1) and (f,1) where d is between the d[t] values. This is also true for j[t] where c falls between the i[t] values (which also means c falls between the d[t] values).

(e,1) (f,1) concepts

>If an integer p is a factor of a[t], then p will be a factor of a[p+1-t] for ALL cells in row n=1 (na and nb are n apart (at a[t] and a[t+n])

>If p is a factor in a[t] then there exists (e,p)

>If a number at position t has a factor s, then s is a factor at (t+s), (t+2s) and so on for a at (e,1).

>Also, if a number at position t has a factor s at (e+1), then s is a factor at (s+1-t), (2s+1-t), etc for a at (e,1).

>In row 1 (where n=1) in positive space (so not the (f,n) cells), f=(x+n)(x+n)

>(1,1) contains as values for a and b the values of two consecutive squares added together.

>The n values in (0,n) where a and b are squares appear as the d values in (1,1). They also appear as the a values in (0,1).

>In (e,1) and (f,1), there's meant to be an asymmetrical pattern of n-1 as a factor of (f,1)'s d[t]-d compared with n as a factor of (e,1)'s a[t].

>Since d[t]-d values have the opposite parity (odd or even) of the a[t] values, then that means that for any e, we already know the parity of the d[t]-d values.

>Where a[t] = bn, d[t-1]-d = b(n-1)

>Between the starting prime solution cell and the a[t]=na cell in (e,1), the difference between the a value from the first to the second is a(n-1). This is obvious since na-a = (n-1)a. To add to this, though, the difference between the d values in these cells is also a(n-1).

>Take a cell in (e,1). This holds for any cell in (e,1). If it's even, its b values will appear as the d values in (e+1,1), and the a values from (e-1,1) will appear as its d values. If it's odd, its a values will appear as the d values in (e+1,1), and the b values from (e-1,1) will appear as its d values.

>We can find elements in (e,1) and (f,1) where a[t]=c. Since all a values in (e,1) are twice a square or the sum of consecutive squares (based around t) plus either e/2 or (e-1)/2, but we're choosing t, we can just take 2(t-1)(t-1) and (t-1)(t-1)+tt away from c to find e/2 or (e-1)/2 and therefore calculate the columns in which c will appear as an a value in (e,1).

(0,1) and (1,1) concepts

>(1,1) contains as values for a and b the values of two consecutive squares added together.

>The n values in (0,n) where a and b are squares appear as the d values in (1,1). They also appear as the a values in (0,1). These are two times the square numbers.

>The values of a[t] at (0,1) are twice the square numbers. The values of d[t] at (0,1) are 4 multiples by the triangular numbers.

>In (0,1) we know a[t] = t*t*2. We also know how to "move" up and down (0,1) whereby t=p+t. This means that if we try to find all the a[t] that are divisible by 3, we can simply list: t = 3, 6, 9, 12, etc.

>By multiplying c with 4 we're creating a new record and distributing the 4 (2x2) to both a and b, giving us 2a, 2b. This also gives us an even square to work with 2(x+n)^2. Odd (x+n)^2 = 8(Tu) + 1. Even (x+n)^2 = 4(Tu + T(u-1)). We now have two triangle problems to solve. For an even square, half of the triangles is one unit longer than the other half. The even square can be expressed as two d values from (0,1) added together, d[u+1] + d[u].

>The a[t] values in (1,1) are all odd sums of two squares (although not every odd sum of two squares appears as an a[t] value). The a[t] values in (1,1) are also only divisible by numbers which are also odd sums of two squares.

>>9575

(0,n) cells of note

>In (0,0) every a and b are equal and every c is a perfect square.

>If c is a semiprime, it'll show up where [a,b] = [1,c^2], [a,ab^2], [b,a^2b], [a^2,b^2] and [c,c]

>Root of d = {0, 2xd, 3xd, 2xd, d, 9xd}. We don't know what this is used for but it's meant to be important.

>There is a cell in (0,n) where a=(x+n)(x+n) and b=(d+n)(d+n).

>In (0,n), if you set x=2c (and therefore with semiprimes t=c+1), each valid n value is divisible by either a or b (or both).

(0,n) concepts

>Squares only ever appear in a and b in (0,n) where n is two times a square, so 2, 8, 18, 32, 50, 72, etc

>The n values in (0,n) where a and b are squares appear as the d values in (1,1). They also appear as the a values in (0,1).

>In column zero, x is a multiple of n

Relationships between variables

>Based on the parity of d and e, we can also find the parity of x, a, b, f and c.

>The parity of BigN is the same as the parity of n.

>2(BigN-n) = (a-1)(b-1), and we can find the cell where a=a-1 and b=b-1 (or where a=a+1 and b=b+1, for which our current unknown a and b represent 2(BigN-n)) by finding the cell (e-2n,n) (or (e+2n,n) for +1s).

>When you decrease e by 1 but increase n by 1, the increase in f is equal to 2d-1. When you increase e and n by 1, at the same t, the increase in f is equal to 2*(the increase in d)+1.

>a*b can be represented as the sum of consecutive odd numbers where a is the number of terms and b is the midpoint: 5*29=145=25+27+29+31+33=145

>If a cell contains an element c, another element in the cell can be constructed from it. e'=e, n'=n, x'=x+2n, a'=b, d'=a'+x', b'=a'+2x'+2n

>By multiplying c with 4 we're creating a new record and distributing the 4 (2x2) to both a and b, giving us 2a, 2b. This also gives us an even square to work with 2(x+n)^2. Odd (x+n)^2 = 8(Tu) + 1. Even (x+n)^2 = 4(Tu + T(u-1)). We now have two triangle problems to solve. For an even square, half of the triangles is one unit longer than the other half. The even square can be expressed as two d values from (0,1) added together, d[u+1] + d[u].

>For each odd (x+n)(x+n), there is a finite set of cells where n!=1, and an infinite set where n==1.

>c%(BigN-1) = 2d-1

>c%d is congruent to e%d

>(x+n) = (b-a)/2

Relationships between cells

>If a cell has values at (e,n) then there will be values in a cell at (e+2n,n). This is how you get the horizontal pattern of grid cells.

>The values of a,b and d each increase by ONE 2n cells to the right. They decrease by one 2n cells to the left. This also means that one cell's c is equal to the next one to the right's 2(BigN-n).

>From (-f,n-1) = c, the value of a,b and d increase by ONE every 2(n-1) cells, as you move from left to right in the grid.

>From (e,n) = c, the value of a,b and d decrease by ONE every 2n cells, as you move from right to left in the grid.

>Choose *any* cell (e,n). Take a look at the corresponding cell (e, a). The a value of the 2nd cell = the n value of the 1st cell.

>Take a cell in (e,1). This holds for any cell in (e,1). If it's even, its b values will appear as the d values in (e+1,1), and the a values from (e-1,1) will appear as its d values. If it's odd, its a values will appear as the d values in (e+1,1), and the b values from (e-1,1) will appear as its d values.

>At any (e,n,t), there will be another record at (e,n,t+n) where that record's b is equal to the original record's a, and the new x is equal to the old one plus 2n.

>You can create any negative x record by substituting a and b. (1,5,4) = {1:5:12:7:5:29} = 145 becomes (1,5,-8) = {1:5:12:-17:29:5} = 145

>The a values in (-1,2) are equal to 1*2, 2*3, 3*4, 4*5, 5*6, 6*7, 7*8 etc. So our n(n-1) will always appear as an a (and technically also a b) in (-1,2).

>>9576

Bigger overarching concepts that we were told were meant to be used to directly solve the thing

>There's some kind of tree thing we're meant to use. It starts of as a decision tree which terminates if we can immediately solve (e.g. if gcd(d,e)>1). There's then a proper tree diagram in which we find d and e of c, then we find d and e of d and d and e of e, and so on until reaching 1, and also dividing by 2 if we get an even number until it's odd. This is meant to precede whatever concepts we use in either (e,1) or (0,n) to solve, although once we learned to make the tree it was never brought up again and no links were made to any other concepts. Summing up all of the leaves of the number tree diagram gets us a number that is relatively close to one of the factors. "The factor tree is used to factor d and e", apparently, even though that hasn't been shown. "Factoring these (and down the tree) allow for the factoring of c" too apparently. Another claim is that "the tree solution finds x+n or x."

>We're meant to be able to use (x+n)(x+n)=nn+2d(n-1)+f-1 to find the solution. This involves patterns that were looked for but never found, and a variable n0 which is meant as a guess base for each triangle that makes up (x+n)(x+n) and then eventually finds the right triangle base in some way we were never shown.

>Polite/staircase numbers are numbers that can be expressed as the sum of consecutive integers. There are many different variables which pop up as expressions of polite numbers, such as 2d+1. We also find staircase numbers when we add the x values from an (e,1) element and an (f,1) element (this was specifically pointed out), although nothing useful has come from analysis of this either. "The solution to this problem introduces a new form of algebra where two concurrent forms of equations run side by side and then merge. The two sets of equations take the problem and simplify it. Together they handle the "lock and key" nature of the problem/solution, particularly when c is divisible by 1, c, and two other prime numbers, such as in RSA. The two forms of equations that merge together handle staircase numbers where the base of one staircase, is one unit longer than the other." According to this statement, staircase numbers directly relate to the solution, but they have only ever come up in the explanation of the triangle method, which, as stated, we don't know how to use.

>Multiplying c by known small primes is meant to help us to find the unknown factors by increasing the frequency of their appearance. We multiply c by another variable q, which is the product of those small known primes (which for some reason are meant to all end in 01 in binary). We are then meant to multiply qc by another variable v, which will transform it into (0,n). We haven't found anything useful through analysis of qc alone, and it would appear to not currently be possible to directly calculate v. Chris also said that multiplying c by q would increase the smoothness of BigN-n (in other words, decrease its highest prime factor). We discovered that this is actually incorrect, and that the highest prime factor of BigN-n actually increases in every test case of qc.

>There's meant to be a trivial lookup based on everything we already know and a non-trivial lookup that relies on the results of the trivial lookup. The trivial lookup returns t, e and f (we don't know if that t value is the correct one but given there's a separate non-trivial lookup it doesn't seem likely), and the non-trivial lookup returns n (-1 for prime, 0 for square c). Chris didn't give us enough information to infer anything about how the non-trivial lookup works yet (aside from explaining various patterns that are apparently relevant), but he did say that we would use columns -f,0,1 and e; rows 1, (n-1), n, X, Y and C. It depends at least on odd e/even e (i.e. it'll work differently for either one) at a minimum (meaning it could potentially be optimized by going further with things like odd x+n, even n, etc). Column 0 contains the square of c. X and Y are the positions of n between 1 and the square of c (this is extremely vague but it's a direct quote). X and Y will not exist for primes (that depends on the value of f and d - again, a pattern we haven't necessarily understood yet). The work we did with triangles will show which integers are primes. It also pays to mention that ebot on /qresearch/ once said out of the blue "use X on Y at C", which could potentially be relevant (but possibly not).

>There are meant to be separate ways to solving using either (0,n) with X, Y and C (possibly including (0,e) and (0,f), or they might be their own separate solution path), (e,1) and (f,1), row 2, and (1,1).

>>9577

Things we don't know what to do with

>Root of d = {0, 2xd, 3xd, 2xd, d, 9xd}. We don't know what this is used for but it's meant to be important.

>In (e,1) and (f,1), there's meant to be an asymmetrical pattern of n-1 as a factor of (f,1)'s d[t]-d compared with n as a factor of (e,1)'s a[t].

>Apparently there's a useful values in the cell in (e,1) where x=f or f-1.

>There's meant to be a "lookup x" for our given c that "gives you na or (n-1)". There's some x value somewhere in the grid that can applied to c in some way to give us na or n-1. Since there are two possibilities, it's probably based on e and f parities, given all of the patterns based around e and f parities. Also, since the x value in (e,1) where a[t] = na will always be equal to the x value in the prime solution record, finding that x value would bypass (e,1) and na completely, since we wouldn't need to factor na to know what a and b are (since we'd have the prime solution record). So this x value is most likely not the x value from the (e,1) record where a[t] = na.

>Apparently aan(n-1) is meant to be helpful. We don't know how to find it or what to do with it.

<There are more things in this thread that I left out because either they were extremely vague, we looked into them and didn't find anything, or they're interesting concepts but they've never been brought up by anyone other than the person who discovered them and don't seem to have much use. I may include these in this section later on if anyone wants.

For a[t]=an and a(n-1), (e,1,t)'s d minus (f,1,t)'s d is (e,n)'s a minus one. For a[t]=bn and b(n-1), (e,1,t)'s d minus (f,1,t)'s d is (e,n)'s b plus one. This means you don't have to use gcd(a[t], a[t]) to find a or b (O(1) vs O(log n)).

e.g. 13x43=559

(e,1) a=na = (30,1,6) = {30:1:75:10:65:87}

(f,1) a=a(n-1) = (-17,1,6) = {-17:1:63:11:52:76}

75-63=12, one less than a

(e,1) a=bn = (30,1,11) = {30:1:235:20:215:257}

(f,1) a=b(n-1) = (-17,1,10) = {-17:1:191:19:172:212}

235-191=44, one more than b

e.g. 7*29=203

(e,1) a=na = (7,1,4) = {7:1:35:7:28:44}

(f,1) a=a(n-1) = (-22,1,5) = {-22:1:29:8:21:39}

35-29=6, one less than a

(e,1) a=bn = (7,1,8) = {7:1:131:15:116:148}

(f,1) a=b(n-1) = (-22,1,8) = {-22:1:101:14:87:117}

131-101=30, one more than b

B

This is the Offset that Chris has described.

It allows us to solve for (a) or (n) for the (an) and a(n-1) pairing.

It allows us to solve for (b) or (n) for the (bn) and b(n-1) pairing.

Since we can isolate a

And we can isolate b

we can approximate cTest = c

Which means we can approximate n.

Which means we can solve for x in a way that snaps the answer into place.

Using the first formulas.

It means we can potentially solve for n using an approximate distance between a * b = cTest

The real KEY is persistence.

>>12482

???????

>>7610

>>7648

>>7668

>>9575

>>12493

Reposting for clarity.

Last post was >>11836 on 01/08/21.

Figured it was good to repost the most important pattern related to the Offset.

Also, this is new information.

Being able to extract (a) and (n) from a given a[t] value is new in Grid Patterns.

Being able to extract (b) and (n) from a given a[t] value is new in Grid Patterns.

The approximation of cTest = a * b is also new in Grid Patterns.

>>12498

Ideas you're working on aren't established, fully-understood grid patterns. Why do you keep posting in here instead of the main thread?