I apologize for necesitating an emergency bake. I was busy.
In a clearer format (the one I keep) (also, fixed some typos):
post 1, glossary - https://pastebin.com/gWV7vySY
post 2, rules - https://pastebin.com/cE195ptk
post 3, code - https://pastebin.com/heweAtWs
I've taken a few steps on formulating Shor in terms of and linking it to the language of the VQC and I've found that the possible values in the most important step of Shor (period finding) are actually related to N-n.
The possible period values found in calculating Shor's algorithm with random m values from 1 to c-1 all originate from the prime factorization of N-n.
An example, c=253, (the number we are looking at here is the second number in each bracket, which is the period value arrived at when the first number in the bracket is used as m in Shor).
https://pastebin.com/beY9hPx0
N-n = 110 = 2 * 5 * 11 which means we expect to find that a combination of these 3 factors results in every possible period value, and that is what is found in the data. 55, 22, 10, 5, and 110 are period values in the data and they are all products of a combination of 2, 5, and 11.
You find the same thing for other examples (it takes a lot of computing to calculate these examples)
6107, N-n = 2940: (in the attachment, I had to put it into a pdf because 8chan doesn't allow text files)
2940 = 2^2 x 3 x 5 x 7^2, so we expect every period value (second number in the brackets) to have a combination of 2, 3, 5 and 7 as a factor (note, it still counts if it's missing one of these factors from the prime factorization because it can be written with the factor it's missing to the power of 0)
145, N-n = 56: https://ghostbin.com/paste/2cg75
123, N-n = 40: https://ghostbin.com/paste/fqu8u
287, N-n = https://ghostbin.com/paste/7te9u
So the first noted connection between Shor and the vqc happens to be N-n and smooth numbers.
A concept you all might find interesting, from the General Number Field Sieve (it is pretty simple if you know what a smooth number is.)
Let's say we're going to look at 3-smooth numbers, numbers which at most have 3 as a prime factor. We can represent all of the 3-smooth numbers as evaluations of:
2^x * 3^y = 3-smooth number
where the exponents determine which number it is. For example, 12 = 2^2 * 3^1
We can represent this in a different notation called exponent vectors (the premise of the notation is simple, don't let that scare you).
Since we know we're looking at 3-smooth numbers, we only need to know the values of the exponents to represent a given 3-smooth number.
2^2 * 3^1 becomes (2, 1). (I haven't confirmed a connection here, but does this look familiar?)
So, our 3-smooth numbers become sets of exponent values. E.g, (3,1) = 24. We can also define multiplication of these "exponent vectors." Since a pair of values now represents a number, we can simplify multiplying these pairs by adding their exponent values instead of calculating the actual multiplication.
(4,2) = 144
(4,1) = 48
(4, 2) times (4, 1) = (4+4, 1+2) = (8, 3) = 6912 = 14448 (This also defines squaring a 3-smooth number, as in (2,1) times (2,1) = (4,2) = 1212.
Incidentally (or maybe not), any exponent vector that only contains even exponent values happens to be a perfect square. As in, (4,2) = 12*12, (4,4) = 36^2, (6,2) = 24^2, and so on. (This type of notation is used in GNFS to find one of the nontrivial squares (i^2 or j^2) which, interestingly enough happen to be equal when you are operating in GF(c) where c = ab, a field modulo c. When you are operating in GF(c) (you may have seen Galois fields in my ECC explanations), i^2 = j^2 (mod c) and i^2 - j^2 = 0 (mod c) (because they are equivalent to c, when it's modulo c then it's 0 since c%c=0).
So there you have it. Smooth numbers in Shor, smooth numbers in GNFS in a relatively simple introduction, and N-n as a smooth number.
Any k-smooth number can be represented this way, this paper introduces the concept with 19-smooth numbers.
An example of this type of notation with a number we're familiar with:
N-n for 145 = 56 = 2^3 * 7^1
So if we define that as a 7-smooth exponent vector with 2 inputs it'd be (3, 1). It's also not the difference of two squares so it isn't found in the grid, at least in positive e and positive n.
As an example, all of the period values for 145 can be represented as one of these exponent vectors.
2 = (1, 0)
4 = (2, 0)
14 = (1, 1)
28 = (2, 1)
The same is true for all N-n from what I have seen so far. All of the period values can be represented in the exponent notation for the prime factorization of N-n, as further proof that N-n's smoothness determines all possible period values evaluated in Shor's algorithm for c.
c is b-smooth.
If you write c in exponent vector notation then every c value is in (1,1) because c = a^1 * b^1.
Interesting paper - this paper details a factorization algorithm for determining what it has termed Nf(N), or what we would call 2*i, or a+b
Follow up paper, I like this guy:
His paper includes finding a variable that is equivalent to d or d+1. Then calculating square's difference from c, which is either e or f.
Someone should tell him we simplified his work.
for future reference on our variable names (we are working on formulating these papers in the language of the VQC)
d = floored sqrt(c) = sqrt(c)//1 = sqrt(c) with no decimals
g = sqrt(c)
So we'll call the actual square root of c with the decimals g
When we formulated this first paper (A-Quick-Way-to-Factor-Large-Semiprimes.pdf) in the terms of the VQC, we found that the VQC language simplifies the approach greatly and requires less steps.
In this first screenshot I have here, Kurwzeg's "Nf(N)" (a polynomial equation with c as the input multiplied by c again, in number theory c is N and pq is ab) is equal to 2*i or 2(d+n) or a+b.
In essence this paper is saying Kurzweg has developed a method of factorization that is equivalent to searching for the value of a+b or 2(d+n). We find that we can greatly simplify his work using our equations.
The equivalent equations in the terms of the VQC:
c = ab
c = i^2 - j^2
His Nf(N) is equivalent to 2*i, so, if we iterate for 2i in the same manner he does ("using MAPLE math program," screenshot two), we can derive the factors by
i = 2i / 2
j = sqrt(i^2 - c)
a = i - j
b = i + j
Some formulae for deriving Kurzweg's variable k (from solution values j and i so far), in (A-New-Method-for-Factoring-Large-Semiprimes.pdf)
if (c%6) == 1 {
k = ( ( sqrt( (2j)^2 + 4c ) - (c+1) ) / 36) * -1
}
if (c%6) == 5 {
k = ( ( sqrt( (2i)^2 - 4c ) - (c-1) ) / 36 ) * -1
}
in the program "calc," they'd be written as (in the same order as above for the cases of which to use):
define kF(c, j) = (-1(sqrt((2j)^2 + 4*c) - (c+1)))/36
define kG(c, i) = -1((sqrt((2i)^2 - 4*c) - (c-1))/36)
examples of k values (examples c's from the paper):
kF(34417, 72) = 945
kF(21428053, 594) = ~594964.444
kF(21428053, 594)*36 = 21418720
kG(106577, 369) = ~2950.889
kG(106577, 369) * 36 = 106232
kG(732010841, 29229) = 20333020
In his paper,
G = (2i)^2 = 2(d+n)^2
F = (2j)^2 = 2(x+n)^2
So, in the second paper, Kurzweg's second factorization method went from being a search for 2i to being a more informed search for 2(d+n)^2 or 2(x+n)^2 based on the remainder of c%6.
Interestingly, (c-1)/6 or (c+1)/6 is always in the ring of Z, which is number theory speak for it's always a whole integer, and which one it is is based on whether c%61 or c%65, respectively.
Also, an idea on what the point of the remainder tree was:
We were told to repeatedly divide each term by 2 until it was no longer a multiple of two. What does that make? A list of odd numbers, which also isolates the primes.
So , hypothesis:
with smooth numbers you are looking at the primes that make up a number by multiplication and with the tree you are looking at the primes in the remainders.
The tree wasn't the solution, it was a hint.
Kurzweg's 3 papers all have confusingly similar names, so I'm going to give them distinct names:
(A-Quick-Way-to-Factor-Large-Semiprimes.pdf) = the 2i paper, the 2(d+n) paper (because that's the value he's searching for, in his terms, Nf(N))
(A-New-Method-for-Factoring-Large-Semiprimes.pdf) = the 2i^2 and 2j^2 paper, because this paper contains a description of an iterative search for the values of 2i^2 and 2j^2 in our terms
(A-New-Approach-to-Factoring-Semiprimes.pdf) = the d, e and f paper, because the variables d, e and f all show up in this paper (I'll show how in a moment).
Next I'm going to outline his paper (the d e and f paper) in terms of our equations. I'm going to use greek letters for his variables that don't exactly map to ours because we've almost taken up the entire alphabet, and he introduces a lot of different variables.
A NEW APPROACH TO FACTORING SEMI-PRIMES:
step 1:
g = sqrt(c)
g is a variable we've defined before, this one includes the decimals
step 2:
α = the closest whole integer to g (d or (d+1))
step 3 - realize that there are two unknown values which add and subtract from α to make a and b:
a = α - β
(where β = x or x+1)
b = α + γ (this isn't a y (why), this is a γ (gamma))
(where γ = (x+2n) or (x+2n-1))
step 4 - which become, if we rearrange:
α * (γ - β) - β*γ = c - α^2
In our terms,
β*γ = x * (x+2n)
or
β*γ = (x+1) * (x+2n-1)
Here's where it gets fascinating:
c - α^2 = e or f
step 5, solve for (β*γ) and (γ - β):
β*γ = δ + ε (where δ and ε are an unknown integers)
γ - β = (c - α^2 + δ + ε)/α
δ < α
step 6, eliminate γ from the equations and set δ=c - α^2 (I'm not sure of the exact path of this mathematical jump so I'll figure it out later if it is important):
β^2 + β*(ε / α) - (δ + ε) = 0
step 7, solve for β:
β = -(ε / (2α)) + sqrt( (ε / (2α))^2 + (δ + ε) )
step 8, since we know ε / (2*α) must be an integer (because it's defining β and a = α - β), we can get to the value that we need to search for to factorize:
let ε / (2*α) = ζ
β = -ζ + sqrt( ζ^2 + 2αζ + δ)
step 9, rearrange for factors:
a = (α + ζ) - sqrt( ζ^2 + 2αζ + δ ) = (α + ζ) - η
b = (α + ζ) + sqrt( ζ^2 + 2αζ + δ ) = (α + ζ) + η
letting η = sqrt( ζ^2 + 2αζ + δ )
step 10:
α and δ are known from c ( δ = c - α^2 and α is the closest integer to g (d or d+1)), so now it just becomes finding a value of ζ that makes η evaluate to a whole integer.
next, Kurzweg solves for ζ and defines the search as between 0 and 1 (decimals), but I don't think that is the right direction to go with this.
I'll program an algorithm of this tomorrow.
research to sort through.
http://algo.inria.fr/seminars/sem00-01/morain.html
Kurzweg contacted.
Location of forum and of us was not revealed, only mathematical concepts shared in order to prove we are serious and are making enough progress (even to the point of improving on current research).
Pursuit of more of his research and his expected interest in our research was made clear.
if (e, n, t) = (e, n, d) then sqrt(2d) ~= sqrt(x)
There was a "ghost in the machine," so to speak, as to the reason why some of the records are invalid in the screenshots, but the code has been corrected to reflect the original idea of the movement from (-(odd column), 1, -(d+N)) to (col, 1, -(d+n). Also, it wasn't terminating in one step, I just forgot to print out the movement, but Chris has already said an instant prime test will be included with the solution.
VQCGUI revision 3, includes source
https://anonfile.com/37C6mej1b4/VQCGUI-0.0.3_7z
try navigating from a[t] = N record to a[t] = na record, you will see amazing patterns in the values on the right.
sqrt(2d) has an intricate relationship with the x values.
(yes I know there's a typo, too late to recompile).
Enumerate the patterns in the first row (and into negative x).
It will be something that was there that you didn't c that will trigger it.
I will come back to clarify the other by the end of the week but briefly. Using the values of RSA 100 just as a large number example is a suggestion. In column e, the values at (e,1) for each element includes a value for a[t] which is an. The value bn is at a[t+n]. At (-f,1) the value a(n-1) is at the same value x in that cell as "an" for (e,1), the value b(n-1) at cell (-f,1) is one element less than bn at (e,1). This difference is key. It is not the only key, as you are seeing. I have found three, not including yours. Those three are in row 1, column zero and the side by side diagonal cells from the origin. There may be infinite keys.
Two sets of equations that run together and then merge, lock and key.
diagonal = one thing that is one unit apart from another thing, the offset is one
just paraphrasing vqc
//using the diagonal to find pairs that are one row apart
c1541
e=20, f = 59
sqrt(e) = 4, sqrt(f) = 7
sqrt(f) - sqrt(e) = 3
2d = e + f - 1
{20:732:39:38:1:1541} i[t] = 771; j[t] = 770; sqrt(d[t]) = 6; sqrt(2d[t]) = 8; f[t] = 59
{-59:731:40:39:1:1541} i[t] = 771; j[t] = 770; sqrt(d[t] = 6; sqrt(2d[t]) = 6; f[t] = 140
140 - 59 = 81
difference between f[t] in (e,N, t) and (e, N-1, t) = 81
{20:6:39:16:23:67} = 1541; i[t] = 45; j[t] = 22; sqrt(d[t]) = 6; sqrt(2d[t]) = 8; f[t] = 59;
{-59:5:40:17:23:67} = 1541; i[t] = 45; j[t] = 22; sqrt(d[t]) = 6; sqrt(2d[t]) = 8; f[t] = 140;
140 - 59 = 81
sqrt(140) - sqrt(59) = 4
difference between f[t] in (e,n, t) and (e, n-1, t) = 81
{20:1:770:38:732:810} i[t] = 771; j[t] = 39; sqrt(d[t]) = 12; sqrt(2d[t]) = 17; f[t] = 1521; c[t] = (d+N)^2 - d^2
{-59:1:770:39:731:811} i[t] = 771; j[t] = 40; sqrt(d[t]) = 27; sqrt(2d[t]) = 39; f[t] = 1600; c[t] = (d+N-1)^2 - d^2
1600 - 1521 = 79
sqrt(1600) - sqrt(1521) = 1
{20:1:154:16:138:172} f[t] = 289; c[t] = (d+n)^2 - d^2
{-59:1:132:17:115:151} f[t] = 324; c[t] = (d+n-1)^2 - d^2
324 - 289 = 35
sqrt(324) - sqrt(289) = 1
I'm making the most progress working backwards, seeing that it's not about going from c to n, it's about going from d and e to n and N.
"Two sets of equations running together."
since f=(x+1)^2 at (e,1), f increases in squares by t of the opposite parity of e. if e is even, f increases in odd squares, and if e is odd, f increases in even squares.
eventually you realize x+n is so special because it's a view of the diagonal, of the key
diagonals
difference of squares
rsa100u = 529865753494301776968715634328960133662340771465
Chris dropped a different formula at the very end of RSA#12 for N that I didn't notice.
We've been using
N = (c+1)/2 - d
but
N = (c-1)/2 - x
also works
Yes, just for (e,1). I apologize for the false positive by not clarifying that.
Also, 2 values of c at (e,1) (a different idea)
2 values of c in both columns in -x and +x
145:
{1:61:12:11:1:145} (1, 61, 6)
{1:1:10368:-145:10513:10225} (1, 1, -72)
{1:1:10658:145:10513:10805} (1, 1, 73)
{-24:1:10500:-146:10646:10356} (-24, 1, -72)
{-24:1:10792:146:10646:10940} (-24, 1, 74)
34117:
{261:1:581950858:-34117:581984975:581916743} (261, 1, -17058)
{261:1:582019092:34117:581984975:582053211} (261, 1, 17059)
{-108:1:581984790:-34118:582018908:581950674} (-108, 1, -17058)
{-108:1:582053026:34118:582018908:582087146} (-108, 1, 17060)
rsa100c:
{61218444075812733697456051513875809617598014768503:761302513961266680267809189066318714859034057480651323757098846024549192056136964455981270339102876:39020571855401265512289573339484371018905006900194:39020571855401265512289573339484371018905006900193:1:1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139} (61218444075812733697456051513875809617598014768503, 761302513961266680267809189066318714859034057480651323757098846024549192056136964455981270339102876, 19510285927700632756144786669742185509452503450097)
{61218444075812733697456051513875809617598014768503:1:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306382919000431748126203278565987540269446653259579647945903160561369722164795555272230598393346522221773:-1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306384441605459670659563814184365672906876371327694609326591818469864302287758814225128252393697214227912:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306381396395403825592842742947609407632016935191464686565214502652875142041832296319332944392995830215636} (61218444075812733697456051513875809617598014768503, 1, -761302513961266680267809189066318714859034057480690344328954247290061481629476448827000175346003069)
{61218444075812733697456051513875809617598014768503:1:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306385964210487593192924349802743805544306089395809570707280476378358882410722073178025906394047906234051:1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306384441605459670659563814184365672906876371327694609326591818469864302287758814225128252393697214227912:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306387486815515515726284885421121938181735807463924532087969134286853462533685332130923560394398598240192} (61218444075812733697456051513875809617598014768503, 1, 761302513961266680267809189066318714859034057480690344328954247290061481629476448827000175346003070)
{-16822699634989797327123095165092932420211999031886:1:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306384441605459670659563814184365672906876371327694609287571246614463036775469240885643881374792207327717:-1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006140:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306385964210487593192924349802743805544306089395809570668259904522957616898432499838541535375142899333857:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306382919000431748126203278565987540269446653259579647906882588705968456652505981932746227374441515321579} (-16822699634989797327123095165092932420211999031886, 1, -761302513961266680267809189066318714859034057480690344328954247290061481629476448827000175346003069)
{-16822699634989797327123095165092932420211999031886:1:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306387486815515515726284885421121938181735807463924532048948562431452197021395758791439189375493591339997:1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006140:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306385964210487593192924349802743805544306089395809570668259904522957616898432499838541535375142899333857:1159163035527489297252269855748911245456985761764903865191919139010631678686397433667992819640306389009420543438259645421039500070819165525532039493429637220339946777144359017744336843375844283346139} (-16822699634989797327123095165092932420211999031886, 1, 761302513961266680267809189066318714859034057480690344328954247290061481629476448827000175346003071)
Also another thing worth noting, the b value at the record in (e,1) where a=N, b=N' (shadow N)
shadow N = 2d+N
Tempted to try but I'm not even gonna bother trying to open that.
In its current state, this doesn't scale and it doesn't reach a correct n-1 value for several examples.
Was watching some videos and reading some literature on the Riemann Zeta function today. It's really fascinating stuff. There's a lot of calculus and number theory behind it, but basically if the Riemann Zeta hypothesis is true, then you can calculate the exact number with no error of how many primes there are beneath a given integer.
You can already do this with the more accurate version of the prime number theorem and a formula that gives you the amount of error (calculated with the zeros of the Riemann Zeta function), but nobody is sure it's correct because it depends on the Riemann Zeta hypothesis.
Correction: "with no error" -"with an extremely small margin of error about the equivalent of a calculation."
Hey look it's our friend mod 4
Then you find it's all connected
If you look at the patterns of n in a[t] you find pairs of elements of the n we're looking for multiplied by different a's and b's for a different, smaller c, that are separated by n for that c's elements
If you could calculate two multiples of n where the coefficients of n are not multiples of eachother you could calculate n by doing gcd(na, nb)
Kind of like the GCDFactor algorithm, but intelligent navigation. This may be the lookup.
These particular patterns may be coincedence but this is the approach I'd like to be investigated:
c21428053:
N=10709398
n=38
So we want to find a way to find multiples of 38 in e,1 (work backwards).
In e,1 if we look for n and its multiples, we do find
{412:1:318:14:304:334} a = n*8 t=8
{412:1:470:22:448:494} a = n*13 t=13
8*13 = 104
104's n value = 5 and these elements are 5 elements apart.
So we find our n times a different set of a and b for a different c with elements that are that c's n apart at e,1.
and gcd(n8, n13) = n
so if two multiples of n are found, n can be split from them efficiently (unless the two coefficients are multiples of eachother, as in 7 and 21)
an interesting observation: N%4=n%4 generally
this is so sad, Alexa factor integers in logarithmic time
www.wired.com/2011/01/partition-numbers-fractals/
"Fractals solve the problem of calculating partitions"
The Part contains the Whole.
(c, n) spreadsheet.
same diagonal line patterns as the grid.
What do we get when we sort numbers by their distance from a square instead of as a line?
2, 5, 10, 17, 26, 37, 50, 65, 82, 101
3, 6, 11, 18, 27, 38, 51, 66, 83, 102
4, 7, 12, 19, 28, 39, 52, 67, 84, 103
5, 8, 13, 20, 29, 40, 53, 68, 85, 104
6, 9, 14, 21, 30, 41, 54, 69, 86, 105
7, 10, 15, 22, 31, 42, 55, 70, 87, 106
8, 11, 16, 23, 32, 43, 56, 71, 88, 107
9, 12, 17, 24, 33, 44, 57, 72, 89, 108
Approaching the grid as a fractal
N of 5 = 1
N of 17 = 5
N of 37 = 13
65 = 5*13
See pattern.
Understand.
Then build.
[iterating d for e=31], relevant c=287
32
35
40
47
56
67
80
95
na = 56
so e,1 in our grid analyzing every value of d in d^2 + e for us. understanding why the grid is configured the way it is is a good exercise.
We want to master the pattern of factors of a[t] in e,1.
Every n value that exists in column e is a factor of a[t] in e,1.
e,1 as a catalog of all valid n values.
What does "position of column 0" mean?
From our even column, (f or e), distance from column 0 can be expressed in jumps of 2n (where n=1), but not for the odd column.
anyone ever notice how 145 is the sum of squares?
I'm thinking fractals. That has to be what we are missing here. It's a way you can turn that massive search space into nothing—because the same patterns that apply to the massive apply to the small, in a fractal.
Okay, but if the goal is to rethink our approach to mathematics as a way of rewriting it, then why would any musing be unwelcome? None of them are things that have been completely explored
It is the unity and enumeration of all grid patterns.
>Enumerate the rules.
>Win.
>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.
Two threads in a program, one starts with c=ab, the other starts with c=1c. The equations run independently and encompass all grid patterns, then eventually merge.
c=ab {
d = sqrt(c)
e = c - d^2
f = 2d+1-e
n = (a+b)/2-d
x = d-a
(d+n)^2 - (x+n)^2 = c
(d+n) + (x+n) = b
(d+n) - (x+n) = a
a[e, 1, t] = na
b[e, 1, t] = na+2(x+1)
a[-f, 1, t] = (n-1)a
b[-f, 1, t] = (n-1)a+2(x+2)
}
c=1c {
d = sqrt(c)
e = c - d^2
f = 2d+1-e
N = (c+1)/2-d
X = d-1
(d+N)^2 - (X+N)^2 = c
(d+N) + (X+N) = c
(d+N) - (X+N) = 1
a[e, 1, T] = N
b[e, 1, T] = N+2d
a[-f, 1, T+1] = N-1
b[-f, 1, T+1] = N-1+2(d+1)
}
The equations keep enumerating patterns until they merge.
cont'd
c = ab {
[1] the entry (e, 1, t+pna) where p is any multiplier of na will contain a multiple of na in a[t]
in other words, na will be a factor of a[t] in that element
[2] the entry (-f, 1, t+1+p(n-1)a) where p is any multiplier of (n-1)a will contain a multiple of (n-1)a in a[t]
}
c = 1c {
[1] the entry (e, 1, T+pN) where p is any multiplier of N will contain a multiple of N in a[t]
in other words, N will be a factor of a[t] in that element
[2] the entry (-f, 1, T+1+p(N-1)) where p is any multiplier of N-1 will contain a multiple of N-1 in a[t]
[3] a[-f, 1, T+1+1(N-1)] = N*c
a[-f, 1, T+1+1(N-1)] / a[-f, 1, T+1] = c
}
They will merge when enough patterns are enumerated. Continue enumerating these patterns -reach solution.
A question to answer (to define the equivalent pattern for the ab thread). In (-f, 1, t+1) where a[t] = (n-1)a, what defines the multiple of (n-1)a that appears at (-f, 1, t+1+(n-1)a)?
Two independently running sets of equations that apply every pattern to trivial and solution values respectively.
Note for clarification: the N's and n's used here are from c only since we're working in row 1
Equation threads cont'd:
c = ab {
[3] a[-f, 1, (t+1)+(n-1)a] = (2d+1)[t+1] * (n-1)a
a[-f, 1, (t+1)+(n-1)a] / a[-f, 1, t+1] = (2d+1)[t+1]
}
c = 1c {
//since c is equal to 2d+1 of the na transform record at T+1 in cell -f,1, c appears as our multiple of (N-1) when we go (N-1) elements down
[3] a[-f, 1, T+1+1(N-1)] = N*c
a[-f, 1, T+1+1(N-1)] / a[-f, 1, T+1] = c
}
//a factor of 2d+1 of t in -f,1 is added when we go na cells down
Clarification:
(notation is being pushed to its limits here), pattern [3] applies to going (n-1)a and N-1 elements down from the -f,1 transform record where a[t] = (n-1)a or N-1
t of this record is written t+1 since it is one element below the na transform record in e,1, which we derive from x or X using the t from x formula
bcbb19fc1667fcda9370c0d09a7f7f02
final piece
fractals:
Mandelbrot: recurse over f(z) = z^2 + c over and over for random complex points and color them based on whether they stay bounded or tend to infinity
Remainder tree: recursively calculate c = d^2 + e
fractals and nature. viewed this way we see the pattern of a a tree stump
If e-d = 1 c = d*e+1
I didn't find i[t], i[t] found me!
Math without art - no such thing!
"I knew this would make a swastika eventually" v2
I don't believe you! Prove identity.
Why are you lying.
But just so you know. I tried this before. People don't die of liver failure.
Correction - natural logarithms are logarithms calculated with e as the base
I'm not Chris you faggot
The number line isn't a line. It looks more like a Mobius strip (much like the 8ch logo), with e and infinity on different sides of the same point.
0 doesn't exist - the remainder of taking everything away is Euler's number.
The remainder of taking everything away is e.
The CMB (Cosmic Microwave Background) has a thermal black body spectrum at a temperature of 2.72548±0.00057 K.[4] (Wikipedia)
2.72548 plus/minus 0.00057
e=2.71828
There is a connection between base, e (of c), Euler's number, d^2+e, O(log t where t=bitlength of c) hints
"This pattern GROWS in a certain way"
O notation is about how efficiencies grow
.
Good morning. Last night things were difficult and I did not react appropriately. I want to say that I am thankful to Chris for everything, for sharing all of these revelations and things which we know by faith are true. Before this, I was not good at math and had no way of approaching the subject, especially for special avenues like this one. But now I have been given one.
We will solve this. The enumeration of all patterns given is almost complete. And when we do, the limits of the Virtual Quantum Computers we can create will be what we dream up. Extension to Discrete Logarithms will be swift ["The DLP can be thought of as a 2 dimensional version of the factoring problem."] Patterns in the Mandelbrot show that Devices which Calculate all Values exist in the realm of mathematics. Fractal image compression using exact self similarities - Image manipulation using universal self similarities [The Eye] - Engineering desktop cold fusion by a sonoluminescence feedback loop - Inverting Hash Functions [special type of value table]
The world will never be the same.
All products of odd numbers and all products of pairs of even numbers are the difference of two squares.
Different view of c%4==2
"26 Holocaust's of a happening if VQC is legit. I am not joking."
I love me from the past.
odd*even = a multiple of 4 + 2
I'm seeing a lot of discord in your formatting, I have some ideas for formatting it better but I'd have to know what you're using to make it.
first coordinate = the column
second coordinate = the row
third coordinate = the index
first + second coordinate = the cell
first + second + third coordinate = the entry
record generation:
if (e is even): x = 2t - 2
if (e is odd): x = 2t - 1
a = (xx + e) / 2n
d = a + x
b = a + 2x + 2n
c = ab
It is a 7 dimensional object indexed by coordinates of 3's. If you find things easy to picture in seven dimensions, why not try it.
a
No one way functions.
Good insights, AA. Since factorizing d and e enable the factorization of c, then that also means that the patterns in the factorization of d apply to every number inbetween d^2 and (d+1)^2.
n and n-1 patterns here
notice how only one n is taken up between each square?
Anyone have a copy of the old threads that includes pictures? The archive only saved the thumbnails
On the occasion of the death of 41:
"When his breath departs, he returns to the Earth. On that day his plans perish."
https://pastebin.com/QnrNYQra
Since we can find where c appears as a[t], we can go up one and have c as b[t].
Here is a record where a multiple of a appears next to N:
{41:1:52:7:45:61}
This record's coordinates can be calculated from N.
This is what occurrences of b[t] = c look like.
c145{289:1:144:-1:145:145} (289, 1, 0) c = 21025 f = 0{281:1:142:1:141:145} (281, 1, 1) c = 20445 f = 4{265:1:140:3:137:145} (265, 1, 2) c = 19865 f = 16{241:1:138:5:133:145} (241, 1, 3) c = 19285 f = 36{209:1:136:7:129:145} (209, 1, 4) c = 18705 f = 64{169:1:134:9:125:145} (169, 1, 5) c = 18125 f = 100{121:1:132:11:121:145} (121, 1, 6) c = 17545 f = 144{65:1:130:13:117:145} (65, 1, 7) c = 16965 f = 196{1:1:128:15:113:145} (1, 1, 8) c = 16385 f = 256{-71:1:126:17:109:145} (-71, 1, 9) c = 15805 f = 324{-151:1:124:19:105:145} (-151, 1, 10) c = 15225 f = 400{-239:1:122:21:101:145} (-239, 1, 11) c = 14645 f = 484
CONTEXT – Seeing the Bigger Picture.
CONTEXT – Using ALL of Row One.
a[1] = c
a[2] = c
a[3] = c
…
The "n is the same thing as a" remark starts to make sense when you realize that c at a[t] functions as an an value and a OR b can be n, since t+a and t+b both have the same factor
Let's say we have a way to find the first valid n in a column efficiently.
Assuming your assertion is true for all semiprime c, we can make c the product of three primes where the a value that we want is the smallest valid n value by picking the closest prime to d (perhaps by the nextProbablePrime() function in Java), since d a in a semiprime. Thus, calculating the first valid n value would be equivalent to factoring.
Making this prime that is known to be bigger than a as the third factor of c, qc, the a value we want would be the smallest factor of c making the lookup reveal itself more easily.
Twilight Zone.
I should have known the unified field theory would be subject to this..