Hey yea that is pretty cool. You have transformed a*b into a sum of consecutive odd numbers where a is the number of terms and b is the midpoint:
5*29 = 25 + 27 + 29 + 31 + 33 = 145.
The dots you drew can also be drawn similary to triangular numbers, but you are only adding the odd rows:
___
_e_
eee
eeeee
eeeeeee
>Second decision, if(GCD(e,d)!=1) return GCD(e,d);
>So the GCD between d and e is the end goal of Part 1? What do we use this for? Ideas?
If GCD(e,d) is not 1, that means e and d have a common factor, but then this common factor divides c because c = d*d + e. So this line of pseudocode tests for this possibility, where you will happen to get factor of c right away.
Right, the factor has to come in part 3. We have seen that we can sometimes add up 'leaves' on this tree and get a factor of c, but no consistent pattern has been put forth and VQC hasn't actually said yeah, add them up that's the secret. So depending how you define the function f(c), if you want it to return factors then either that's part 3 after the branching business; if the recursive part returns a factor then you are getting a factor from every subtree so you have to do something with that, could be worth messing around with, but seems more likely coming in part 3..
Also, for everyone's interest, the part 2 recursive tree has a time complexity of its own which we can compute. If this part is slower than log(bits of c) then VQC has misspoken, which I wonder about. It could still be fast enough to be revolutionary without being that fast.
Anon I like your work. Is this adapted from philogenetic software? I was trying to interpret your tree. Sometimes two sibling nodes have a "d^2 + e" relationship to their "uncle" node (sibling of parent node), and sometimes they are the factors of their uncle node.
examples pictured: 3073=921 or 55=25, vs 633 = 25^2 + 8
> If e != 0 we compute GCD(e, d) which also has a time complexity of O(log n).
Yeah this is already more than log (bits of c). As many of you know, bits of c ~= log c, example a 4 bit number is between 1000 and 1111 (binary), or between 8 and 15.
log (2^3)<=log c < log (2^4)
3 <= log c < 4.
So generally bits(c) - 1 <= log c < bits(c).
Then a time complexity of log (bits (c)) is log log c, and we are already slower than that. Like I said, log c is still very fast, it's an arrow instead of a bullet, when now the on the books factoring speed is a knife strapped to a turtle.
thanks
>The decision tree terminates upon finding a factor.
>Pre-factorisation, trim trailing zeros (in binary) or equiv is to divide by two until odd.
>This is 1 and c for primes.
>This is the square root for squares.
>This is the pair of factors that are not 1 and c for the product of two primes that are not the same numbers (not a square).
>This is the pair of factors closest to the square root for products of more than two factors (not including 1 and c as factors).
>We know that this function will return a factor, so for a prime number that means it will return either 1 og the prime itself (I'm assuming). This we can also use the function as a primality tester.
Based on VQC quote above, yes it looks like it brings back the two factors closest to sqrt (c). When c is prime you'll get 1 back, and c, so you'll know it's prime.
If your c might have more than two factors, and it spits back out c = ab, you can further put a and b into the algorithm. Like if you put 360 in, you should get: 1820 (not 1036 or anything else). Then 18 = 63 (not 29); 20=45 (not 2*10) etc.
>Do we also know the underlying pattern of d[t] - d and the growth of (n - 1) as a factor?
I personally have still not looked at this. I don't even know what growth of (n-1) as a factor means. One thing we still don't exactly do on these threads is define what we mean :)
I would like to see our results consolidated, with a list of claims / theories and results. The first part of the list would include vqc crumbs (interpretations and results) and the second part would include leads that anons are following (and could reference the first list). There are old crumbs and new ones which I think haven't satisfactorily been settled or maybe even understood.
example here
>Each "a" from the first row equals na because xx+e = 2na and na is half of that. That's BIG part of the KEY
a= na because n=1 in that row, that's obvious. so what's the other, non obvious meaning? If it was stated, I missed it. I'll look at this old nugget now, and post the result. but if we can work as a group on an organized list, that looks a little like the baker's post but longer and with results beside crumbs… or some other way… I think it'd help.
Yes you are right, I intended to do it earlier but I didn't get around to it. I'll have to chip away at a few of them, and maybe do a mini list. Expand if useful; hard to know which loose ends are most important right now.
ok still gotta work on the hint I was asking about, but… reading the pdf and getting excited here by the imagery:
>Integers are also related into families that you have noticed.
>Like fractals.
>They repeat.
>They GROW.
>Sea shells grow.
>Establishing which patterns govern which level of the fractal and which part of the branch of that fractal, will help identify
the factors of c.
>Think decision trees too.
————————————————————————————————————————
>If in doubt go back to the original (e,n) grid and look for MORE patterns!
>The strange is, the more you enjoy this the more it SINGS it's beauty.
>It IS beautiful.
>Like the Mandelbrot Set.
>Similar rules.
————————-
What kind of logarithmic spiralling fractal mushroom trip are we looking for here? Rules of mandelbrot set: The Mandelbrot set is the set of complex numbers c for which the function f_c(z) = z^2+c does not diverge when iterated starting at z = 0. We know that VQC's part 2 factor tree iterates taking roots, but for all sub-branches. The mandelbrot set looks at sequences. But it is self-similar (download / write yourself some fractal viewing software for inspiration).