Furthermore, it "closes the gap" between the f and small square formulas.
Reposting again from VQC:
( f is what you add to c to make a square )
f = 2d + 1 - e
( x + n )( x + n ) = nn + 2d( n - 1 ) + f - 1
>Have you been looking at these relationships in the a x b row too?
Yes. I've got output for all the test cases we previously discussed with their na transforms, plus various increments of e.
Even went up to c^4 to see if there were any patterns at higher numbers.
>f is more important than you think. Take a look at (f, 1).
I have a feeling… Looking into right now!
So the (f,1,t) entries are interesting.
Example below.
145=5x29
a x b *=(1,5,4) = {1:5:12:7:5:29} = 145; f = (2 * 12) + 1 - 1 = 24; (5*5) + 2 * 12 * (5 - 1) + 24 - 1 = 144; (x+n)^2=12x12=144;
a x b na =(1,1,4) = {1:1:32:7:25:41} = 1025; f = (2 * 32) + 1 - 1 = 64; (1*1) + 2 * 32 * (1 - 1) + 64 - 1 = 64; (x+n)^2=8x8=64;
a x b e=f =(24,1,4) = {24:1:36:6:30:44} = 1320; f = (2 * 36) + 1 - 24 = 49; (1*1) + 2 * 36 * (1 - 1) + 49 - 1 = 49; (x+n)^2=7x7=49
1 x c =(1,61,6) = {1:61:12:11:1:145} = 145; f = (2 * 12) + 1 - 1 = 24; (61*61) + 2 * 12 * (61 - 1) + 24 - 1 = 5184; (x+n)^2=72x72=5184;
1 x c na =(1,1,6) = {1:1:72:11:61:85} = 5185; f = (2 * 72) + 1 - 1 = 144; (1*1) + 2 * 72 * (1 - 1) + 144 - 1 = 144; (x+n)^2=12x12=144;
1 x c e=f =(24,1,6) = {24:1:72:10:62:84} = 5208; f = (2 * 72) + 1 - 24 = 121; (1*1) + 2 * 72 * (1 - 1) + 121 - 1 = 121; (x+n)^2=11x11=121
Similar to the na records, the e=f records satisfy the condition f = (x+n)^2.
Any more crumbs to share while I look for additional relationships?
I don't know that we are talking about the same f. Someone else please clarify
The original F formula was used to create a record in the negative part of the grid. You are correct with "f = e - (2d+1)".
But VQC most certainly posted the other formulas:
from your pastebin
https:/ /pastebin.com/eHJTEwWY
>In the original vqc, I used f = 2d+1-e as the negative -e coord.
>f = 2d+1-e (f is what you add to c to make a square)
>(x+n)(x+n) = nn + 2d(n-1) + f - 1
Fair enough. Thanks.
sorry, I'm not explaining myself very well.
there's an alternate formula that VQC gave us for (x+n)^2.
nn + 2d( n - 1 ) + f - 1
I'm checking to see if that formula equals f = 2d + 1 - e.
Small square equations are good. If we can identify the (x+n) of the desired record, we have t and a direct link.
Not sure about the transformations for other examples.
I've currently got a workflow set up to create na, f and "-" negative records.
Don't know if these are even the records that can potentially link to an answer.
perhaps share a step?
teach - pending CA’s breakthrough, if you review the notes above, it seems like we only need to find the delta in small squares to solve this thing.
we know x+n from c, we know x+n from ab.
Should we search for records that give the difference?
don't need x. can create with e,n,d only.
if it's running for an hour, not the right solution.
Can you give a rundown of your method? Perhaps we can assist further.
we know e, d, and c.
I agree that we need to solve for n. I believe that the movement revolves around the small square (x+n). And if we can find a pattern for how it increases from the c record to the ab solution, solving for N is easy.
Also looking into the -E space.
This was your hammer approach, right?
Getting some weird values when trying to construct a record by ENT where n = 0.
Anyone have some working code to share?
Thanks for the thoughtful responses.
I checked the original grid and the n=0 records do have some special properties:
e is negative and one of = 1^2, 2^2, 3^2, 4^2, etc.
x = sqrt(-e)
b-a = 2x
d-b = x
Also noticed that for c=65 a record exists:
(-16:0:3) = {-16:0:9:4:5:13} = 65
which we can almost get to from our starting position.
(1,25,4) = {1:25:8:7:1:65} = 65
Coincidence?
>which we can almost get to from our starting position.
correction, we can get there easily:
BigInteger newE = -(ter.d * ter.d);
BigInteger newX = ter.d;
BigInteger newA = ter.n;
TheEndRecord testNegative = TerFactory.CreateForEXA( newE, newX, newA );
This is the same result of doing an (n-1) shift and the f transforming the result.
Not sure if this has any value yet.
>Yep, this is the relationship I was talking about yesterday.
Sorry. It takes me awhile to catch up!
I created some of the images in the original threads, but after seeing MA's amazing work, I didn't see the need to continue.
>BigInteger newE = -(ter.d * 2); ??
no. Your e formula doesn't create valid records.
newE = -(ter.d * ter.d ).
Question is does this record tell us anything new? Does it give us any information to relate back to any aabb or ab records?
>the dest_a = a - n - orig_d
the dest_a = a - n + orig_d
would be great if there was a way to do this without knowing the orig_d.
VA. Not sure if we're 100% correct, but this is our understanding thus far.
Fellow anons and VQC: Happy new year and God bless. This has been the most interesting and humbling of adventures.
>>2081
only tested on 1 record. Did give a way back to the original.
good observation.
I believe the following describes the move from any (e,n,t) to its f record.
from (c) -(cf)
(c).f = 2d + 1 - e
(cf).e = 2d + 1 - e
(cf).n = 1
(cf).d = d + (n - 1) * a
(cf).x = x - 1
(cf).a = (n + 1) * a
(cf).(x+n)^2 = c - f
Thanks. Am writing some code to verify this.
ignore this for now. only works in some cases.
Thank your for such a clear explanation.
I've been spending some time trying to understand the (f,1,t) records.
These can be created from any (e,n,t) by:
new.e = ( 2 * orig.d ) + 1 - orig.e
new.n = 1
new.t = orig.t
Don't fully understand the importance of these records, but can say that when you compare (f,1) records created from (1xc) and (axb), the a and b values are starting to get closer together.
Example below:
145=5x29
a x b *** =(1,5,4) = {1:5:12:7:5:29} = 145;
a x b f =(24,1,4) = {24:1:36:6:30:44} = 1320;
1 x c =(1,61,6) = {1:61:12:11:1:145} = 145;
1 x c f =(24,1,6) = {24:1:72:10:62:84} = 5208;
I believe I have figured out the formulas to create these records directly - but only for odd values of e.
e = 2*d + 1 - e
n = 1
d = d + (n - 1)*a + (a - e)
x = x - 1
a = (n + 1)*a - e + 1
Even values of e seem to be a little more tricky.
disagree. Binary search is interesting. But it's not the solution.
There are a simple set of formulas to describe record creation.
I believe there is another set of formulas to describe movement between records.
Understanding that movement is critical to figuring this out.
Correct. Only in (e,1).
Sample data:
(1,1,-4) = {1:1:32:-9:41:25} = 1025
(1,1,-3) = {1:1:18:-7:25:13} = 325
(1,1,-2) = {1:1:8:-5:13:5} = 65
(1,1,-1) = {1:1:2:-3:5:1} = 5
(1,1,0) = {1:1:0:-1:1:1} = 1
(1,1,1) = {1:1:2:1:1:5} = 5
(1,1,2) = {1:1:8:3:5:13} = 65
(1,1,3) = {1:1:18:5:13:25} = 325
(1,1,4) = {1:1:32:7:25:41} = 1025
(1,1,5) = {1:1:50:9:41:61} = 2501
(2,1,-4) = {2:1:41:-10:51:33} = 1683
(2,1,-3) = {2:1:25:-8:33:19} = 627
(2,1,-2) = {2:1:13:-6:19:9} = 171
(2,1,-1) = {2:1:5:-4:9:3} = 27
(2,1,0) = {2:1:1:-2:3:1} = 3
(2,1,1) = {2:1:1:0:1:3} = 3
(2,1,2) = {2:1:5:2:3:9} = 27
(2,1,3) = {2:1:13:4:9:19} = 171
(2,1,4) = {2:1:25:6:19:33} = 627
(2,1,5) = {2:1:41:8:33:51} = 1683
(2,1,6) = {2:1:61:10:51:73} = 3723
Confirmed. You can create any negative record by substituting a and b.
(1,5,4) = {1:5:12:7:5:29} = 145
(1,5,-8) = {1:5:12:-17:29:5} = 145
(1,61,6) = {1:61:12:11:1:145} = 145
(1,61,-66) = {1:61:12:-133:145:1} = 145
looks like x = d - a is the correct x.
and the formula for any negative x in (e,n) could be:
x = -( x + 2*n )
>Not sure if this is actually useful or if it's just a side effect or the rules.
we wouldn't be sent down this path if it wasn't useful. Question is how.
>that would be rowForAB(1, 1452) and rowForAB(1452, 1), etc.
my bad on formatting
rowForAB(1, 145145) and rowForAB(145145, 1)
and for the c=145 case, the difference equals 2c. The numbers 10658 and 10368 appear often when creating records from a=1 and b=cc.
And if you create records at a=aa and b=bb, you'll get n values of 288 which look surprisingly like 2*(c - 1).
Unfortunately, this doesn't hold true when looking at other test cases.
(f,1,t) gives some interesting combinations of a and b.
I agreed about the jumping. We've known how to iterate factors by t and d for awhile.
It appears that VQC is telling us the answer (or a part of it) lies in the negative space - looking into the mirror - like right is left…
You can use the following to create any valid record by ENT. For n = 1, you can simply iterate e and t values. n = 0 doesn't work.
For n 1, the t becomes tricky, so simply looping won't do it.
public static TheEndRecord CreateForENT( BigInteger e, BigInteger n, BigInteger t ) {
BigInteger x = GetX( e, t );
BigInteger a = ((x * x) + e) / (2 * n);
BigInteger d = a + x;
BigInteger b = a + 2x + 2n;
return new TheEndRecord( e, n, d, x, a, b );
}
private static BigInteger GetX( BigInteger e, BigInteger t ) {
if ( ( e & 1 ) == 0 ) { // even (performance improvement)
return 2*t - 2;
} else {
return 2*t - 1;
}
}
My understanding is that the big N record is where a=1, b=c.
his full comment was:
the hint that na, nb for any c can be found n entries apart in the cell at (e,1) also applies to the factorization a=1, b =c.
That's the big N (d+N = (c+1)/2 so N is bigger than usual).
So N and cN are part of the sequence of a and b values in (e,1), along with na and nb.
Also the a and b values in the (e,1) are involved in deciding whether (e,n) is empty or full. Look down column 22.
public static TheEndRecord CreateForENX( BigInteger e, BigInteger n, BigInteger x ) {
BigInteger a = ((x * x) + e) / (2 * n);
BigInteger d = a + x;
BigInteger b = a + 2 * x + 2 * n;
return new TheEndRecord( e, n, d, x, a, b );
}
I've been searching for formulas that describe changes between various records. Movements up and down by manipulating e, d, x, a, t, with and without factors.
The -x use in the a+2x + 2n is a very good approach.
Example of trying to understand an e = f jump.
If you look at that formula for a, you'll notice that it incorporates n, a, and e.
Perhaps there is another variable that needs to be toggled to get better results.
I'm going to get my code up to speed and see if I can play with it a bit.
agreed.