Oooooh I think I figured out how to find a and b for (e, n) for any given n for t=1.
That's devious VQC
You guys, we don't need any more drops or crumbs from VQC. We already have enough.
I've already solved generating (e, n) for any given e and n. It's just a matter of studying the patterns in (0,n) and (1, n).
I've started to look into the controlling of c and it looks very promising.
Take a look at (1, 1). The t = 2 has a = 5. Then go t + 5 steps, a = 85.
(1, 5) starts with a = 5/5 and b = 85/5. This appears to hold true for all (e, n).
Again, we want to find t = 1 for (1, 13). We find 13 at t = 3. We "save" this a (13) and then add 13 to t (3 + 13). We should get a = 481.
13/13, 481/13 = 1, 37. Also the first t = 1 for (1, 13).
However, there might be more to it.
In (1, 1) you'll find 481 (13 * 37). If you use this as a starting point you'll get (1, 37) starting with 13 (which is correct).
I think, in order to enumerate the "possible" n's you'll have to "jump" between n's.
Since we know that a=1, b=37 appears in (1, 13) you'll either have to jump from (1, 1) to (1, 13) in order to find it, or we might have to employ recursive factorization to "know" that 37 is a possible 'n' by factorizing 481 when we encounter it in (1, 1). But I don't think the recursive method is the way to do it.
Okay, so I'm back after spending the holidays with family.
I took another look and ended up rewriting my code and then took another look at this crumb.
So, 3 * 5 = 15. 15 * 15 = 225. It seems that 225 only appears in the following (0, n):
(0, 2, 255, 30, 225.0, 289.0)
(0, 8, 285, 60, 225.0, 361.0)
(0, 18, 315, 90, 225.0, 441.0)
(0, 32, 345, 120, 225.0, 529.0)
(0, 50, 375, 150, 225.0, 625.0)
(0, 72, 405, 180, 225.0, 729.0)
(0, 98, 435, 210, 225.0, 841.0)
I looked at n up to 5000 and didn't find any more occurrences of 225.
Brute force. I wrote some python code to enumerate (0, n) looking for a number cc. I set it to go up to n = 5000.
Note though, I don't know if there is any special relationship between x and a, b or c^2.
Also: x in that equation does not relate to x from the elements.
Not sure why it didn't print the 128 for 225 though. It should have. Which means my method for generating (e, n) records might be off.
The script generates (0, n) for n 1 up to 300 (but I tried for up to 5000 for 225) and compares 225 with the generated a. So it should have matched if my code was correct.
I'll debug it. Thanks for pointing out my mistake
I don't think I've managed to get a method to generate N's as well as I think.
What I've done is make a program that takes in an e and an n. Then it will look at (e, 1) and start looking at the factors there.
It's kind of simple though. If an a does not exist in the list, we add it. Then for each new a we check if it is divisible by any factors in the list. If it is, we divide a by that factor and add the divided part to our list.
It also adds every 'a' to the factor list as every 'a' is also an n in e.
However, my enumeration isn't complete as showed by >>1327. For 225 it failed to find 128.
Has anyone managed to get a proper method for enumerating (e, n)?
I feel a bit stuck.
I'm looking for patterns, but without knowing exactly what I feel stuck. It's like you can spend years pouring over any and all patterns in this grid.
Oh boy. I'm sad and happy. Sad that the greatest puzzle I've been working on for a long time is revealed, but also happy for it.
I've been investigating these (0, j) for 2 * (i + 1)^2 and found some interesting results. Will post shortly, just have to gather my thoughts and code.
Okay, so I've been digging a lot through patterns for a and d for (e, n). And I've found a lot of exciting things.
For these (0, n) where n = 2(i + 1)^2 I've discovered a way of finding aabb records. Unfortunately it's not as fast as VQC's method, but it's a step in (at least) a direction.
So let's start with these (0, n). aabb records will all appear in (0, n) where n = 2(i + 1)^2 for some i. This i is not easily found and is n + (x - 1). For a c with two primes there exists two records. One for aa * bb and one for a=1, b=cc.
The record for a=1, b=cc is easily found as it is at i = n + (x - 1) which can be found by setting a=1, b=cc and generating that record. I haven't found much use for this record, but I haven't ruled out any usefulness neither.
The other record can be found by iterating over the possible (0, n). During my search this morning I discovered an equation for getting d[t] for any t in (0, n) (fitting the equation mentioned). I used some algebra and found an equation for reversing this. That is, finding t for a d. This means if I know the n where aa*bb appears in, finding the t for that record is done in constant time.
This works fine as aa*bb will have d = cc so I find a t where d = cc for (0, n), but then again I have to iterate through the different n's, which is a brute force method.
This yields a nice result for small values, but won't work for big numbers as RSA-100.
Some more results:
To find the t for a given a at (e, 1) (for any e):
def getTFromA(e, a):
if e % 2 == 0:
return math.sqrt((a - (e / 2))/2)
else:
t = a - int(e / 2) - 1
t = int(t / 2)
t = t + 1
t = int(math.sqrt(t))
return t
Equation for even e: sqrt( ( a - (e / 2) )/2 )
Equation for odd e: floor(sqrt((a - floor(e / 2) - 1)/2 + 1)
To find the a for a given t at (e, 1):
def getAFromT(e, t):
if e % 2 == 0:
return (e / 2) + 2t*2
else:
return int(e / 2) + 4 * ( (t * (t + 1) ) /2 ) + 1
To find the t for a given d at (e, 1) (for any e):
def getTFromED(e, d):
if e % 2 == 0:
t = d - (e / 2)
t = t / 2
t = t * 4 + 1
t = t / 4
t = math.sqrt(t) + 1
return -1/2 + t
else:
t = d - (2 + int(e / 2))
t = t / 2
t = t + 1
t = math.sqrt(t)
t = t + 1
return t
To find the d at a given t for (e, 1) (for any e):
def getDFromET(e, t):
if e % 2 == 0:
return (e / 2) + 4 * ( (t * (t + 1) ) / 2)
else:
return (2 + int(e/2)) + 6n + 4( ( t * (t - 1) ) /2 )
I've used the getTFromED when looking for the aabb record as the d = cc in that record, but without being able to have a nice way of knowing which (0, n) the aabb record is in, it requires the brute force method.
I'm looking into patterns for the n * a and (n - 1) * a now.
(0, 172872, 589, 588, 1, 346921)
Here, the n = 2MM which leaves M = 294.
2M is also equal to c - 1.
Not sure if you posted that somewhere
When VQC refers to n * a and (n - 1)*a does he refer to specifically the n - 1 or the previous n?
For example in the column for e = 1 we have n = 1, 5, 13, 17 etc. So if we take (1, 5, 2) where a = 17 and b = 53. Is he talking about n * a (17 * 5) and (n - 1) * a (17 * 4) or (17 * 1)?