/vqc/ - Virtual Quantum Computer

>>12501

Reviewed some of your f_offset work (pb), but wasn't quite clear if you're calculating starting from only a given `c`? Or is `a` used with method? ty!

>>12502

Yo dawg! Mr. Melange back on the board, great to see you my man!! Thanks for acknowledging the perseverance, I've been holding down the fort.

We will finish what was started almost 7 years ago.

Thousands of hours of mental investment as a team.

I made a promise to myself and God to not let my time here be a waste.

I will keep my word to myself and God.

This is epic level world changing math.

I lost a lot to still be here.

I will see it through, with the help of God and our team, especially Sam aka Sheeeeitbaked to help me throw this ring in the fire.

>>12504

Ok, I can see the triangle you're looking for in your diagram.

Are solving for the base, which looks to be 1/2 (x+n) based on your diagram?

This takes us back to our studies on solving the (x+n) square, which seems to be what you're working on.

So nice to have someone else's work to review lol :)

>>12505

Your Big Idea is still a bit unclear to me, as far as a solution path goes.

That being said, you seem to be working it with excellence as your mind and the spirit of the Creator guide you.

Can you please take a few minutes to explain your solution process, like to a newb?

>>12506

>Another `key` aspect of the “row 1” solution, is an `offset` value for the t-values in (f,1).

>‘d’ is also used to determine the f_offset for the f-column t-vals.

>There is an assymetry between the rows of interest in the e & f column.

Yes, this is the key. The reason WHY is because the (-f,1) and (e,1) give us alternate factorizations of c, which allow us to derive (a) and (n) for any a[t] x location, as well as derive (b) and (n) for any b[t] x location. This is enough information to solve.

>>12507

>wasn't quite clear if you're calculating starting from only a given `c`

Yes, always starting from a given c value, then using the Grid to create (-f,1) and (e,1) and calculate a, b, n1, and n2

>>12511

Love you brother!

Our team is going on JRE together lol.

We are so close,

Thanks for hanging out tonight.

Blessings

Images appear to be broken again.

C'mon Jim & Ron.

Smh.

Working on code revisions now.

Something is slightly off.

Double checking all formulas.

Hello Anons.

Sheeitbaked here talking with VA.

We prayed in tounges.

We believe.

There is a Form.

Hello everyone!

>>12519

>>12520

>>12522

>>12523

Sheeeeeit, love you brother!

Thanks for all these cool AQC images, our new bread is now properly swagged out.

Got some more work done, writing code and examining output.

While crunching numbers, there’s a new relationship I found.

Every pair of (an) and (bn) that makes our c value always seem to have matching n values.

The key thing is that the matching n values get smaller and approach the solution (n) the closer we get to the correct (a prime) and (b prime) locations.

My working theory is that solution (n) is the lowest possible n value, but that remains to be tested.

So basically I have to write some new code.

Rather than testing for n1 - n2 = 0, we need to test successive loops to see if n1 and n2 (which appear to always be equal for any aTest * bTest = c) is less than the previous loop.

I'll post updates soon, I've been able to do about an hour a day in the evenings after IRL chores are completed.

>>12523

>Or maybe our sonoluminescent powered desktop quantum computers will look something like this

Love it. The d(t)vqc

>>12524

>Got some more work done, writing code and examining output.

Trying to do a bit this weekend. Have a few specific things to evaluate, making progress.

>>12514

>Here it is.

>>For a(n-1) and (an) the offset is as follows:

>>For (an) we know (xx +e) / 2 = (an) for any given i[t]

..

Ok, thanks for that. So if we don't know 'x', then need method to solve.

Looked more at how to explain best the method was using given only 'c' as input.

Will outline, but changing process, as found a shortcut.

Method using was essentially:

1) determine for row n=1, for the e and f columns, the quadratic for d, a, b [t] for each.

So with c6107

e, f, d, c, n, nN, nNm1

23, -134, 78, 6107, 36, 2976, 2975

Calculate 'base' values and next few elements elements:

nfn1 : dfn1 : xfn1 : afn1 : bfn1 for t of 1 at f = 134

1 : 77 : 16 : 61 : 95

1 : 113 : 18 : 95 : 133

1 : 153 : 20 : 133 : 175

1 : 197 : 22 : 175 : 221

1 : 245 : 24 : 221 : 271

Code determines equation for calculating a in (f,1) given [t]:

(-134, 1) a[t] = (2)*(t^2) + (28)*(t) + (31)

and

The equation for calculating b in (f,1) given [t]: (-134, 1) b[t] = (2)*(t^2) + (32)*(t) + (61)

afn1_base : afn1_2 : afn1_3 : afn1_4 : afn1_5

61 : 95 : 133 : 175 : 221

afn1_diff1_1 : afn1_diff1_2 : afn1_diff1_3

34 : 38 : 42

afn1_diff2_1 : afn1_diff2_2

4 : 4

bfn1_base : bfn1_2 : bfn1_3 : bfn1_4 : bfn1_5

95 : 133 : 175 : 221 : 271

bfn1_diff1_1 : bfn1_diff1_2 : bfn1_diff1_3

38 : 42 : 46

bfn1_diff2_1 : bfn1_diff2_2

4 : 4

Pick a random t value for the alignment, let's say '42', and calculate an (col 'a' for the f col).

For input f_grid t of 42, the 'an' value is 4735.

Next we find the related value in the e_grid column.

The target value is (an + d), or 4813.

(the an from t=42 in f).

Do same thing in e col to calc base, and formulas:

The equation for calculating a in (e,1) given [t]: (23, 1) a[t] = 2*t^2 + (-2)*(t) + (12)

The equation for calculating b in (e,1) given [t]: (23, 1) b[t] = 2*t^2 + (2)*(t) + (12)

..

Use the d col formula for the lookup.

The t value for target d of 4813 is 49.

The t offset is af_t - ed_t = 7.

using to look at known cases.

Given we know the 'a' and 'n' values, so in this case, n=36, a=31; an=1116.

Quadratic roots are: ((-)B_aen1 +/- sqrt(B_aen1^2 - 8*(C_aen1-an)))/4

Using the quadratic equation as a lookup, we should find the t value for 1116 in the 'a' values of the e-grid is 24.

And indeed, that is the first solution row with an.

Now, 36 rows down (including that row, so n-1 rows down), in the 'bn' column, we find the 7092 value [t=59].

The triangular method, finds the row element in the middle of these two [t=41].

Back to the f offset..

Having seen quite a few offsets and thinking through it, realized that:

1) f offset is independent of the e column, it doesn't vary for a particular 'd' or 'c', but is a fixed attribute of every f column.

2) Taking parity into account, can calculate for any f directly from the base x value.

So, look across the grid in f, at x in the first element in row 1. Base x (f[t]=1) and how it grows, provides the offset for any f.

>>12525

Bruddha, i know all of the math nerds work at their own pace, as this is a fresh way to view a problem who's solution has escaped the greatest mathematicians minds as long as we are able to understand.

It is potentially a revolution and a Renaissance for our species to figure out what it is that we are working on here.

VA has been plugging away for years, even teaching himself to code in the last few months because he believes we are getting close.

Lately VA has been getting tired. I don't want to say discouraged, because I talk to him almost daily and he has the utmost courage.

But with pma and the other math nerds seemingly falling out of the loop, it's just been up to me and my spiritual take on things to keep the vibes strong and positive.

Your take on this project ignites his spirit, ad well as mine because like VA, I believe we are close, and I believe The Best Is Yet To Come.

I Believe in The Greatest Possible Outcome.

So, MM, please work on this as you are able to, but even if you just pop into the threads to send VA some vibes, or post a meme, if you have the time, please do so Bruddha.

Blessings To All.

Past, Present, & Future.

>>12525

MM, great to see you, and thanks for posting your work!

>>12526

Thank you for the encouragement and kind words, my Bruddah. I also believe in the Greatest Possible Outcome.

> I don't want to say discouraged, because I talk to him almost daily and he has the utmost courage.

*holding back tears*

Hugs my man!

>>12527

The c movement idea is part of our solution.

We uncover a hidden data set of a * b = c using the offset.

Hidden within the numbers in columns (-f,1) and (e,1)

What makes it powerful enough to solve is that the Offset allows us to split any i[t](an) or i[t] (bn) into a, n1, b, n2.

To continue, we know that:

for every semiprime c value, (an) and (bn) will appear exactly once each in column (e,1).

At the correct locations, GetA * GetB will equal our c value, and the two n values (n1 for an, n2 for bn) will be equal.

This is not my discovery, it was hinted at many times.

I'm just a persistent anon.

The info we seek is embedded in the a[t] values in columns (-f,1) and (e,1).

By using the two columns together, we can split any (an) value in column (e,1) into (a) and (n1).

We can also split any (bn) value in column (e,1) into (b) and (n2).

This is the power of the Offset at work!

Rather than moving i and j (PMA's example above), we are moving xA and xB to attempt to find the locations of (an) and (bn).

So for example, with c6107:

(an) = 31 * 36 = 1116

Correct x value = 47

(bn) = 197 * 36 = 7092

Correct x value = 119

What we have now is a search with enough info to solve, very similar to Tops‘s compass idea.

And PMA's post about using a c search could work well, when we use the Offset.

We can test any a[t] value and get (a) and (n) using xA.

We can then go to higher x values searching for a[t] = (bn) and solve for (b) and (n) using xB.

We then multiply together the (a) and (b) values to get a cTest value, while also comparing n1 and n2 to see if they are equal.

The other very cool thing about n1 and n2 is that they give us directional signals about which way to move x.

For example if (a) is lower than the correct a value, n1 will be less than n2.

Which also means (b) is too high and n2 will be greater than n1

The other interesting Offset pattern is this:

For (an) values, (a) gets larger as we move from the (na transform) toward a[1], while (n) decreases moving towards a[1].

Max (n) = N at the (na transform), while (a) = 1

So using the offset, we see that (a) and (n) move inversely to each other.

We are seeking two locations, xA and xB.

At the correct x locations, a * b = c and n1 = n2

Because (a) moves inversely to (n) we can test and triangulate the answer.

And we also can tell with each loop if we’re closer or farther from the solution.

I think this is a pretty good summary! I feel like crap over here, this cold is taking a lot of energy to battle.

Let me know if anything needs clarification lads.

I’ll do my best to check and respond.

Still have a lot of fam IRL work yet to complete this evening.

Hello anons.

Here are the updated offset formulas in c# code.

I simplified them to get rid of the messy d[t]-d and d[t-1]-d mess. >>12454

This is much simpler to follow.

private static BigInteger GetA(BigInteger e, BigInteger f, BigInteger aX)

{

return (((aX * aX + e) / 2) - (((aX + 1) * (aX + 1) - f ) / 2));

}

private static BigInteger GetB(BigInteger e, BigInteger f, BigInteger bX)

{

return (((((bX * bX + e) / 2))) - (((bX - 1) * (bX - 1) - f) / 2));

}

private static BigInteger GetN1(BigInteger e, BigInteger f, BigInteger aX)

{

return ((aX * aX + e) / 2) / (((aX * aX + e) / 2) - (((aX + 1) * (aX + 1 ) - f ) / 2));

}

private static BigInteger GetN2(BigInteger e, BigInteger f, BigInteger bX)

{

return ((bX * bX + e) / 2) / (((bX * bX + e) / 2) - (((bX - 1) * (bX -1 ) - f ) / 2));

}

>>12526

ty, keeping the faith as well. blessings all around.

>>12527

> adjust both large and small squares together

Exactly.

The L(T) and u(T) are keyed by [t]. Just realized in algorithm, the L(T) always integer. It's the u that varies and when integral, target element found.

>>12528

>So for example, with c6107:

>(an) = 31 * 36 = 1116

>Correct x value = 47

and the [t] = 24 ([tf] = 17)

>(bn) = 197 * 36 = 7092

>Correct x value = 119

That (bn) is in the 'b' column of e; [t] = 59.

It's also the value in the next row (an) for [t] = 60, x=119.

So it appears twice in col e, but never in col f (either a or b cols).

>>12530

Hope to have some Time this weekend and will look at code. (and good on you w/ the coding!)

>>12532

>A mousetrap for c6107

>But the design of the trap is the same for big or small c’s

Been honing traps in excel lately. Looking at the patterns and trends you mention.

Found an interesting one: two odd numbers share the same BigN, when crossing to next d (so last one and first e=1 in new d range).

Am clear on the "na transform" row (BigN) terminology. Looking at N. Helpful to look at continuous series of 'c'.

Reviewed the triangular chunks, but don't have nailed down yet. Need to try some scenarios with the "f minus 1 plus multiples of 2d" (odd n) that work properly, and have the e incorporated correctly. Seems the multiples of 'f' are independent of the e and f added (perhaps once initially).

Was trying to work on that, but going to be hectic next couple weeks.

Also, the gcd(c, ae) = 31 in the na transform row was lucky (thought "aha!" for a moment). Checked a bunch, but also looked at the gcd(c, d) while at it. There's a decent percentage of those in the smaller range reviewed, and that was part of the algorithm (check gcd d).

Let me know if you have questions on specific patterns may have observed. Enjoy.

>>12534

>Been honing traps in excel lately

Excel is the shit.

You can bust out a new idea with a small c in 5 minutes flat.

Thank you, Bill Gates.

You did at least one thing right.

>>12536

But you're still a Globalist POS, BG.

>>12535

>It revives my spirit to see you posts here on the board, my man.

Likewise.

>>12535

>Chris had mentioned many times about the value of going into negative x for a given set of a[t] values.

Indeed. Mirror, plus can see relevant features where midpoint was below origin.

Give you're working on rsa100, ran the offset:

The t offset is af_t = 2900232717816778692641445

Not sure if helpful, but the Offset factors are:

3 * 5 * 73 * 2648614354170574148531

An interesting pattern about the squares.

One below each, are two factors related to the d above.

So: 16, d = 4.

15 = 3x5

36, d = 6

35=5x7

81, d=9

80 = 8x10

… (each d is the peak of its parabola, Dm1 and Dp1 are factors one integer below).

>>12539

Hello MM!

>Mirror, plus can see relevant features where midpoint was below origin.

Can you please explain your terms Midpoint and Origin?

You seem to be onto something, and I'm doing my very best to follow.

Further explanation may show we're working on the same thing!

>Give you're working on rsa100, ran the offset:

>The t offset is af_t = 2900232717816778692641445

Is this a location [t] where something notable is happening?

>An interesting pattern about the squares.

This gets right to the main point of what I'm thinking on tonight.

We have two different sets of squares that provide the same c.

We know that c = (d+n) - (x+n)

The difference of squares.

The fact that (-f,1) exists means that we have

{e:n:d:x:a:b} values AND another set of values.

This gives us enough info to solve.

The reason why is hidden in the details.

For any (-f,1) factorization of c, a few very important things change in the (d+n) and (x+n) squares.

e is now (-f)

n is now (n-1)

d is now (d+1)

x is now (x+1)

a is the same

b is the same

So the (d+n) and (x+n) squares remain the same for calculation purposes, but d, x, and n are all shifted by 1.

The two independent columns in (-f,1) and (e,1) do all the work for us.

For example, when we compare the (an) and a(n-1) values for c6107 at the correct aX locations, we solve for (a).

(an) = 1116

a(n-1) = 1085

1116 -1085 = 31 = (solution a)

Now, with this knowledge, we can examine any [t] location, and solve for a OR b.

If we use the formula to solve for (a), we get the a value for that [t] location.

If we use the formula to solve for (b), we get the b value for that [t] location.

We are looking to triangulate or corner the [t] location where all the squares match up and we get a pretty pattern with a 1x1 hole in the middle.

>>5481

>>12541

The only thing we were missing was using the Offset between (-f,1) and (e,1) to solve for a, b, n, and (n-1)

Very interesting crumbs….

>>4682

>>5491

>>5763

>If we define properly the equality operator, i.e. when two objects are identical, AND WHEN THEY ARE NOT, and we do it properly, we classify numbers like integers differently and also other things, and then a whole bunch of things happen. In fact a whole bunch or category of problems *become trivial to solve* once we figure out what we were not seeing in terms of patterns.

>That's where we'll be going next with elliptic curve encryption and then further using the Mandelbrot Set as a computer.

Integers can be calculated in more than one way.

Especially with our problem regarding the difference of (d+n) - (x+n) and the two factorizations in (-f,1) and (e,1).

>12541

prime map…

That's actually helpful r/n.

>>12542

>The only thing we were missing was using the Offset between (-f,1) and (e,1) to solve for a, b, n, and (n-1)

So the "offset" posted is the f-offset. The amount to shift the f column t-values so the rows line up correctly (e.g. the "7" value for c6107).

RE 6107, the 1116 an also happens in e_a col at t(-23), and in the e_b column at t(-24).

and the 7092 (e)an is t(-59) and in b col of t(-60)

>>12540

>Can you please explain your terms Midpoint and Origin?

Midpoint of any d, e, f etc as it goes from negative to positive t, so e will go to zero (around the origin meaning t=0 axis) and back up in positive space.

f does the same thing, but the transition as number get larger happens in minus x. Also as f gets larger, there's a "bump", a hill in the valley (so end up with two minimums, haven't explored those patterns systematically).

>>12540

>This gets right to the main point of what I'm thinking on tonight.

Well, thought had found a new overlooked asymmetry and looped back to play with it this evening. Basically noted two different convergences to Triangle solutions using c1007 (not present in c6107, those columns match identically, also it's a different parity family).

The parity is critical.

Presently using f and d+n, odd/even for each, as the classification.

Even though little 'n' isn't known, bigN can be calculated, and shares the same parity with 'n'.

Therefore, d+n parity is known (even if the 'n' isn't known), from only a 'c' input.

Will have to get some images posted, the spreadsheet are fun (and v. interesting new patterns discovered).

ps - learned to count in binary recently..

>>12546

MM,

if Every Prime Number = 1.

And all other whole numbers were in fact fractions at best.

Would that change anything?

Referring to the last bits of

>>5763

What if our language has it, confused.

We say that "Prime Numbers" are a class of positive integer.

What if the only "Integers" are Prime Numbers, and all other whole numbers, since they have factors and are divisible, are really only a form of a fraction, at best.

And also, Every Prime is equivalent to 1.

Hmmm.

Sheeeeeeitbaked

>>12545

Hello MM and anons!

>RE 6107, the 1116 an also happens in e_a col at t(-23), and in the e_b column at t(-24). And the 7092 (e)an is t(-59) and in b col of t(-60)

Correct!

For cell (e,1) the [t] distance between t(60) and t(24) = 36 = n.

For cell (-f,1) the [t] values would be t(24) and t(59) = 35 = (n-1)

>>12546

Thanks for explaining your terms and posting diagrams, I've studied them closely. I understand your big idea that parities of d, e, f, N are a clue to when we can find working triangles for a given c value.

>An "even even" family pattern.

>(odd xX and x, so x + n odd).

>Triangles scarce in that town at the start.

>Just Imagine.

>Between 0 and 1 (well -1 and 0 for the "other side", 0 and 1) lies everything, continuous, inverse.

Just Imagine. That's a great mission statement. This quest has restored the joy of numbers and math I had as a kid. A simple childlike Faith that the divine patterns of the universe can be discovered because they have been left there like easter eggs for us to find.

In regards to building our mousetraps, do you have any ideas on how to catch the triangle(s) you're hunting for?

>>5491

>The "heart" of the problem is that breaking the problem down involves two sets of triangle solving (otherwise it is prime), with one set of triangles working on a triangular problem that is one unit longer than the other set. This is one reason why no current approach I have seen works

>>4682

>Integers are not a line continuum

>There are families based on geometry

>Shape.

>Symmetry.

>Triangles.

The same c value can be "built" using (-f,1) and (e,1).

The fact that two constructions are available to analyze means that with some simple formulas we can force the "DNA helix" of any given c to unwind for us.

We can extract (a) and (n1) from any [t] location using the GetA formula.

We can extract (b) and (n2) from any [t] location using the GetB formula.

We can then search intelligently for a* b = c, while also keeping in mind that at the correct xA and xB locations, n1 = n2

There is also another important relationship I remembered this week as I was turning the problem over in my brain.

We have a third calculation of n, which is (a + b) / 2 - d = n3

So at the correct aX and bX locations, n1 = n2 = n3

That's a nice triangle of n values lol.

I'm going to work on a new spreadsheet to see how n3 could help us solve.

Lost last post, let's try again..

Queue up Beatle's One is the Loneliest #

>>12547

>if Every Prime Number = 1.

..passes through..

So 1 actually most popular, least lonely #, everything passes through.

Link to >>5763 a good one..

Looking at the 'evens', and thinking best to classify similarly to treating any 'input c'.

Algorithm has couple steps that handle: the remove powers 2 and check if Perfect Square.

>>12548

>Correct!

>For cell (e,1)

+ the 'negative-t' which give the full curve. Was just saying to look at full parabola, quadratic, ..

>>12548

>parities of d, e, f, N are a clue to when we can find working triangles for a given c value.

Here's where had written quite a bit. Basically, just:

1) f (or 'minus e') parity

2) d+n parity

Those two combos give the 4 types/classes/families to start.

These are all calculated / known from any input c.

>>12550

>A "Prime-Centric Framework"

Love it!

>>12552

>Everything exists between 0 & 1,

Probably..

>>12551

Like the scissoring approach.

Cleaned up and tested some functions, in better place to move forward with parameters and classifications mapped.

Have been exploring the "Max" zones (not just Big N and it's pattern over all integers, but Big X (xN) as well).

The Triangular patterns:

New observations was that for either the Trivial (Tu associated with BigN) or the Solution Tu:

For every triangle u associated with odd integers, the height is one more than the base, u. 1/2(b*h) normal normal approach for area.

But noted that (x+n) = (T base+ht).

So, for c427 (7*61):

same "EVEN EVEN" type as RSA100.

The range 403:4:439 has Even f, Even d+n (and therefore, ODD x+n), and we know n is even, therefore x is ODD for these (and they're also ALL 4km1 type, so NONE are the sum of two squares, only difference, the trivial and the factor(s) if not prime c).

Trivial:

xN = 19, nN = 194, xN+nN = 213

Tu = 106, ht=107, sum=213

Solution value:

xpn = 13+14 = 27

Tu base = 13, ht=14, sum = 27

The xpn don't necessarily have diff of 1, for example in same class for c416, x+n = 24+15=39.

Tu(base)+ht = 19 + 20 = 39

The Tu base and ht are always n, (n+1)

These 4km1 all give integral values for the Tu. for all 4kp1 it ends in .5 (1/2 Triangular num).

Another relationship:

For any even c:

2*(T(c) - dpnN^2 - xNpnN^2 +1)/3 = c

and for any odd c:

2*(T(c) - dpnN^2 - xNpnN^2) +1 = c

Not sure implications, but interesting to have a Triangular number relationship, that includes the two trivial Squares for nN.

Wishing you all a good rest of week.

>>12551

Something that would be helpful to add to your excel diagram: the 'd' subcolumns.

for the 'b' column, not sure how that is calc'd, but the 155 is a key value (it's 2d-1)

It's also 2*j-1

x+e + x_f for the na row (you have those columns) = 155.

That's a key # in the solution.

If you don't have 'd' handy, here are the quadratics that will generate any t, minus to positive:

Coefficients for e = 23.0:

d: A_de = 2.0, B_de = 0.0, C_de = 11.0

a: A_ae = 2.0, B_ae = -2.0, C_ae = 12.0

b: A_be = 2.0, B_be = 2.0, C_be = 12.0

Coefficients for f = -134.0:

d: A_df = 2.0, B_df = 30.0, C_df = 45.0

a: A_af = 2.0, B_af = 28.0, C_af = 31.0

b: A_bf = 2.0, B_bf = 32.0, C_bf = 61.0

f_offset for ef Row Shift: 7.0

nN Big n is: 2976.0

Target value: 3053.0

Root 1: 39.0 + 0.0im

Root 2: -39.0 - 0.0im

Target value: 2976.0

Root 1: 39.0 + 0.0im

Root 2: -38.0 - 0.0im

The 'd' value matches for both e and f subcols 'd'.

Calc d for t=39, you'll find it's 3053.

and in that row, i=3054, j=78.

What is 3053?

(c-1)/2

>>12504

>In hindsight, after working through another crumb, will say that's true, but also add that it doesn't appear only once..

>Also now in hindsight, thought had gone a 'different' direction with bringing the square and triangular numbers together, and now `c` the method was/is completely related to BigN (minus x).

>To be clear, had/have developed a working algorithm. Not completed for "EVEN EVEN" cases (of the 4 'types' of c noted), which is current priority

Ok, the ODD ODD, EVEN EVEN naming is all sorted. Ha, was on the same track all along (clear in hindsight).

And the 'k' and 'k2' embedded in algorithm? All related.

This is encouraging.

>a b c k k2 k_parity k2_parity xpn_parity

all the same methods.

Only diff is this algorithm "Slides along the Envelope Curve", versus starting and space and heading to it, watching the remainders.

After some power series (interesting pattern to codify), will be going that direction.

Hello all, I am GAnon from way back I have been working on this stuff too still.

I've discovered in N=1 and N=-1 each X value is a polynomial such that

E,N are fixed

For N=1:

D values are the polynomial 2*i^2 + 2*i*(1-e%2) + (e // 2)

A values are the polynomial 2*i^2 - 2*i*(e%2) + ((e+1)//2)

B values are the same polynomial as A, but instead of A(i) you use A(i+1)

X values are the polynomial 2*i - (e 2)

For N=-1:

D values are the polynomial -2*i^2 + 2*i*(1-e%2) - (e//2)

A values are the polynomial -2*i^2 - 2*i*(e%2) - (e+1)//2

B values are the same polynomial as A, but instead of A(i) you use A(i-1)

X values are the polynomial 2*i + (e % 2)

So for abs(N) == 1:

D values are the polynomial sign(N) * 2*i^2 + 2*i*(1-e%2) + sign(N)*(e//2)

A values are the polynomial sign(N) * 2*i^2 - 2*i*(e%2) + sign(N) *( (e+1)//2)

B values are the same polynomial as A, but instead of A(i) you use A(i-1)

X values are the polynomial 2*i - sign(N) * (e % 2)

Not sure if this has been touched on but it's kind of neat

>>12556

I have tried to check if the Sign(N) can be replaced with N (as it works for abs(N) = 1) but it looks like it only works for the N=1 or N=-1 row

Hey there GA! Great to read you hope all is well..

And good to see you're still exploring The Grid. Have enjoyed and learned much each time coming back to it.

>>12556

>I've discovered in N=1 and N=-1

still trying to understand/replicate how this works:

>E,N are fixed

>For N=1:

>D values are the polynomial 2*i^2 + 2*i*(1-e%2) + (e // 2)

..

Good you mentioned using 'i' (or 'j'), one thing on list was to add those coefficients for root-finding / lookups in i, j. Did that and good validation of grid calc using different methods.

Can you help understand what "N" is?

If it's row 'n' in The Grid, I don't believe there are any N=-1 if e>=0.

Adjusted settings in the grid generator using the python code:

def createTheEnd(path, theend, i_max=4096, x_min=-64, y_min=-5, x_max=64+1, y_max=64):

Need to match the parameters for the output of TheEnd:

def outputTheEnd(path, theend, i_max=4096, x_min=-64, y_min=-5, set_size=25, x_max=64, y_max=64):

So the y_min=-5, should take into the minus n..

Observed valid cells as f>=3 and f%2==1 (ODD only).

These are unique cells, in that they only contain one element, t=1 (not infinite elements). x=1 for any element in this n=-1 row for f.

These are the squares, transformed (projected) from the Origin cell (0,0), so for every element in (0,0) x=0, and transform to f: x+1.

With t as the index used.

Need to be careful with f-side when the t-offset (f_offset) is applied.

Generate with no offset the initial rows for obtaining general quadratic. Then use that with the shifted t to calculate an "aligned row".

For e>0, here's how I generate starting elements using t as an index (diff lang, should be clear) in n=1:

x = 2 * (t - 1) + e % 2

a = BigInt((2 * ((t - 1)^2)) + ((e % 2 + e) / 2) + (t * (2 * (e % 2))) - (2 * (e % 2)))

..

carry on to finish off:

d = x + a

b = a + 2 * x + 2 * n

i = d + n

j = x + n

Also, just to close out the f in n=-1:

If you'd like to generate them:

simple function to start from 1 and go up to desired d (dlim):

```python

def generate_values_for_negative_n(n, dlim):

if n < -1:

return "No valid cells."

if n == -1:

results = []

f = -3 # Starting point for valid cells at n = -1

d, x = 2, 1 # Initial values for d and x

while True:

a = d - x

b = a # enumerated pattern + 2 * x

cell = {'f': f, 'n': n, 'd': d, 'x': x, 'a': a, 'b': b}

results.append(cell)

# Print or store the cell data

print(f"Cell for f = {f}, n = {n}: {cell}")

# Update for next iteration

f -= 2 # Move to the next odd integer in the negative direction

d += 1 # Increment d as per the pattern

# stop the loop

if d > dlim:

break

return results

```

# example call

generate_values_for_negative_n(-1, 10)

If you want to just generate a specific range, can do:

If specific range, have function:

```python

def lookup_cell_f_n_minus_1(f, t, output_mode=None):

if abs(f) < 3 or t != 1:

if output_mode in ("all", "export"):

return "Invalid cell; for n = -1, f must be <= -3 and t must be 1."

else:

return None

elif f % 2 == 0 or t != 1:

if output_mode in ("all", "export"):

return "Invalid cell; for n = -1, f must be ODD and t must be 1."

else:

return None

n = -1

x = 1 # x is consistently 1 for all cases based on the definition

# Determine the value of d based on f

if abs(f) == 3:

d = 2 # Special case for f = -3

else:

d = (abs(f) + 1) // 2 # Use integer division for odd f values greater than 3

a = d - x

b = a # Adjusted based on requirements

c = a * b # Calculate c based on a and b

i = d + n

j = x

# Construct the cell as a dictionary

cell = {'f': -(abs(f)), 'n': n, 't': t, 'd': d, 'x': x, 'a': a, 'b': b, 'c': c, 'i': i, 'j': j}

return cell if output_mode is None else (cell, "Output as per requested mode.")

def cell_f_n_minus_1_range(fnm1_range):

results = []

for f in fnm1_range:

result = lookup_cell_f_n_minus_1((f), 1)

print(result) # Should print the cell without any invalid message

results.append(result) # Collect results

return results

```

fnm1_range = range(-3, -12, -2) # start at -3, stop before -12, step -2

cell_f_n_minus_1_range(fnm1_range)

{'f': -3, 'n': -1, 't': 1, 'd': 2, 'x': 1, 'a': 1, 'b': 1, 'c': 1, 'i': 1, 'j': 1}

{'f': -5, 'n': -1, 't': 1, 'd': 3, 'x': 1, 'a': 2, 'b': 2, 'c': 4, 'i': 2, 'j': 1}

{'f': -7, 'n': -1, 't': 1, 'd': 4, 'x': 1, 'a': 3, 'b': 3, 'c': 9, 'i': 3, 'j': 1}

{'f': -9, 'n': -1, 't': 1, 'd': 5, 'x': 1, 'a': 4, 'b': 4, 'c': 16, 'i': 4, 'j': 1}

{'f': -11, 'n': -1, 't': 1, 'd': 6, 'x': 1, 'a': 5, 'b': 5, 'c': 25, 'i': 5, 'j': 1}

>>12562

>It is row n=1 in the grid. I've got several values and they all check out to me.

Ok will take a closer look, would be good to have generating functions based on 'i'.

From the image, except for some signs, the values align with e=4 column.

Now trying to understand "f" subcolumn?

Starting with your t=1 row (from image), with all rows e=4, and associated 'c' value for each (e,f) (as c can be calculated given e,f)

t = 1, f=-7, c=29

t = 2, f=-15, c=85

t = 3, f=-31, c=293

t = 4, f=-55, c=845

t = 5, f=-87, c=2029

t = 6, f=-127, c=4229

t = 7, f=-175, c=7925

t = 8, f=-231, c=13693

Regarding polynomials, the f series for t=1:8 is quadratic, while the resulting c series is polynomial (4th power as 4th diffs = 96), so likely associated with product two quadratics.

Always interesting patterns…!

Are you able to do a "t lookup"?

So in >>12558

you have t=24 highlighted (a solution row).

Just as a lookup in subcol a in 'e' for 1116 gives t=24 (row you highlighted), are you able to lookup 2976 and get t=39? Able to target any value across the subcolumns (d, a, b, c, i, j) to obtain the t-val?

Have a good one!

>>12564

Typo:

A(i) is

>2*n*i^2 - (e%2)*2 + n*((e+1)//2)

>2*n*i^2 - (e%2)*2*i + n*((e+1)//2)

>>12563

> are you able to lookup 2976 and get t=39?

Since we have the formulas here:

>>12564

We can just use the pythagorean theorem to solve for D,A or X.

So if we wanted to solve for i for D(i) = M

The equation would be (suppose M even)

M = 2*n*i^2 + 2*i + n*(e//2)

quadratic A = 2*n

quadratic B = 2

quadratic C = n*(e//2)

M = (-2 +/- (sqrt(b*b - 4*(2*n)*(n*e/2))) / (2*(2*n))

M = (-2 +/- sqrt(b*b - 4*n*n*e)) / (4*n)

Then M would be the i input to the D function. Could do the same for the others

Then

The f subcolumn is just 2*d + e - 1. I it's the -E value for a cell that shares a C value in (n-1) I believe.

>>12566

I meant "suppose E even" sorry about that, not M

>>12566

>pythagorean

I mean quadratic equation lol

Progress?

>>12552

>I'd start drawing triangles between the floating decimals and solve world hunger and out sonoluminescent powered quantum desktop computers and void energy power generators on the side of every house/home/shelter/dwelling place on Planet Earth.

Well said, bruddah!

>>12554

>The Triangular patterns

>Only diff is this algorithm "Slides along the Envelope Curve", versus starting and space and heading to it, watching the remainders.

Pretty sure we're working towards being able to sort the triangle patterns by their remainders.

The remainders should decrease as we approach a working (an) * (bn) pairing.

Kinda like, "look I made a triangle, but there's some extra left over!"

When there's none left over, we reach our solution triangle(s).

>>12556

GAnon, good to see you!

I'll study your output now.

>>12569

Yes. The team is working again. Many thanks to Sheeeeeit for getting the vibe right once again.

>>12570

Good to be back! I have been plugging in outputs for the vars endxab for a given (e,n) sequence into OEIS and have found several polynomials in each of them. I wonder if this also is a map for polynomials and I'm curious if we can find other patterns there. And since polynomials can be multiplied I am wondering if we can somehow say that a given D*D + E is of the form f(x) = x^2 + E and then somehow use the knowledge of polynomials to find another form of it somewhere else.

Also notice that when broken down, (a) and (n) move inversely to each other from a[1] to a[na transform].

This sheet uses decimal remainders, which don't show the actual modulo. Next sheet will have the actual mods.

Was reading a description of the Fermat Factoring algorithm and it made me realize how useful the letters in VQC are. I rewrote it in terms of the letters a,b,c,d,e,f i,j,n,x and I instantly realized what was going on.

So, what's known as the Fermat's factoring method is a brute search for (x+n) using f as the starting number and adding (2d + l) (where l is the iteration number starting from 1, and incrementing by two each time) until the f variable becomes a perfect square. It's a bit slow and can be optimized using VQC patterns but no solution.

>>12571

> for a given (e,n) sequence into OEIS

Very useful, a prime source for tying sequences/patterns in grid with known maths.

>>12564

>Yeah do you mean find the value for T in (e,1) N=1 row?

(e,n,t) value for a "target" lookup in a subcolumn (either 'e' or 'f' parameters).

If you've got the an, a(n-1), bn, b(n-1) as 'target_val' lookups working, may try:

m*target_val^p

where m is a multiple of the target_val, and p the target_val raised to a power p. Found interesting results at Higher Powers and plan to return to these patterns.

>>12570

>The remainders should decrease as we approach a working (an) * (bn) pairing.

How are you using bn and b(n-1) in your algorithm? You'd label as the "bn transform".

The 'one different' in the t difference for the an and bn vs a(n-1) and b(n-1) is a key asymmetry.

The difference of the t values for an and bn (in ae) is n (60-24), and the sum of the t values is (x+n +1) (60+24).

The difference of the t values for a(n-1) and b(n-1) is (n-1) (59-24) and (x+n) (59+24).

The difference in the target values is a and b.

1116 - 1085 = 31

7092 - 6895 = 197

The diff of the an and bn:

7092 - 1116 = 5976

The diff for the a(n-1) and b(n-1):

6895 - 1085 = 5810

(5976 - 5810)/2 = 83 = (x+n)

The sum of the an and bn:

7092 + 1116 = 8208

The sum for the a(n-1) and b(n-1):

6895 + 1085 = 7980

(8208 - 7980)/2 = 114 = (d+n)

This is the case for Big N values for respective t's as well.

The lookup value for BigN quickly grow (as it's 'c' multiplied by BigN or BigN -1).

So while the first lookups are for 2976 (t=39) and 2975 (t=39),

the lookups for the b records are:

18174432 (t=3015) and 18168325 (t=3014).

The same Difference and Sum calculations shown above also provide the Big N outputs (the Big X + Big N, and Big D + Big N).

- Note: for any "Prime" solution (where 'c' is Prime), where a=1, this is the same as the solution value (the Big N solution is the only solution).

Recent work was to generate the respective 'f' records for each e row. This will be in n=0, because e -> f the nf = ne -1.

Determined the t-values for the f elements, which are the same for all rows.

Currently using the Big N t-values and the factor jumping, the "a[p+1-t]"

See in the "Grid Patterns" thread:

>>6561and >>6579

>>12577

>Currently using the Big N t-values and the factor jumping, the "a[p+1-t]"

Some additional context..

>>6858 (VQC RSA#13)

>Then we want to show that if p is a factor of a[t], p is also a factor of a[p+1-t] for some column e.

This is also part of the "a[p+1-t]" am exploring, which is an extension of the Grid Patterns post.

Validated for jumping elements in the same (e, n1) column given a factor p at an element.

AA, if you're still interested, relates to:

>>8328 (RSA#14)

>It's basically the same wording as

>>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

>(which was VQC at the start of Grid Patterns)

>>8330 (RSA#14)

>I'm trying to verify if it's me or the crumb.

Can provide an example.

Will update with any learning for current work, which includes a twist on this..

>>12577

>>>12571

>> for a given (e,n) sequence into OEIS

>Very useful, a prime source for tying sequences/patterns in grid with known maths.

An example:

Column e=1.

Valid n rows (using grid output) are:

1, 5, 13, 17, 25, 29, 37, 41, 53, 61, 65, 73, …

OEIS: https://oeis.org/A004613

Numbers that are divisible only by primes congruent to 1 mod 4.

–

Another example:

Column e=2

Valid n rows (using grid output) are:

1, 3, 9, 11, 17, 19, 27, 33, 41, 43, 51, 57, 67, ..

https://oeis.org/A215816

Odd numbers n such that the Lucas number L(n) can be written in the form a^2 + 3*b^2.

These Lucas numbers L(n) have no prime factor congruent to 2 (mod 3) to an odd power.

>>12578

>if you're still interested

I don't think any of the ideas anyone is currently talking about are going to lead to the solution, but I wish you all the best of luck. I'm still here every day even if I don't post.

To summarize, for c6107:

at t =39 (na transform), our calc for (bn) mod b = 31

Which is our solution (a prime).

Why do we get (bn) mod (b) values that equal (a prime)?

Especially, why do we get (a prime) values when using GetB and GetN2?

(a) and (b) must be more closely related than expected.

Concept is valid.

Now needs code and testing for large c values.

Step 1: get a wavelength list of (an) mod (a) values for a given c

Step 2: Look for repeating values.

Step 3: get a wavelength list of (bn) mod (b) values for the same given c

Step 4: Look for repeating values

Step 5: Test all values for a * b = c

What’s the deal with needing to identify an A in the N 1 row? What would that help us do

>>12589

What do you mean? It would allow us to factor c.

>>12590

Suppose I can do that already how would I factor C? I’m just trying to get caught up

>>12591

If you've forgotten any of the patterns, most of them are covered in the grid patterns thread.

>>9575

>>9576

>>9577

>>9578

There are several elements in (e,1) you can use to solve (if you can find them). Where a[t]=an (and in (f,1) where a[t]=a(n-1)), the GCD of that a value and c is the a we're looking for (you could do the same thing with a[t]=bn or b(n-1)), and the time complexity of GCD is O(log n) where n is the bigger of the two numbers (and two O(log n) algorithms run one after the other is effectively still O(log n)). You can find the n from the (0,n) element where a[t]=aa and b[t]=bb by getting the a value from the (0,1) element where x equals the (x+n) we're looking for (or the d value in (1,1) where x is (x+n)-1). If you had either of those elements you would also obviously have x+n already. There are a bunch of examples of stuff like that. There are a ton of things that would solve if we could get to them but if anyone had figured out how we wouldn't be having this conversation. I don't remember when you were last here regularly but not a whole lot has happened since around when Covid started, if that helps. Chris has been here like three times in the last four years and has presented a couple new concepts but obviously nothing that led to a solution.

>>12592

I’ll take a look at the thread but o guess what I’m saying is we can’t jump to a[t]=an because those are both unknowns, and we can’t jump to (0,n) aa or bb because those are also unknowns, but I’ll refresh my memory. Thank you

>>12593

>we can’t jump to a[t]=an because those are both unknowns, and we can’t jump to (0,n) aa or bb because those are also unknowns

The entire point of this board is figuring out how to get from knowns to unknowns

Hello everyone!

Ok, I think I’ve finally found the key to making some sense of the aan(n-1) crumbs. Follow my train of thought if you will….

So we know that in (-f,1) any given a[t] value represents a(n-1).

In (e,1) we know that any given a[t] value at the same [t] value as above represents (an).

When multiplied together, we get aan(n-1).

Same for b(n-1) and (bn), with the difference that b(n-1) occurs at [t-1] relative to (bn).

What the aan(n-1) and bbn(n-1) values represent is a perfect square ( a * a ) or ( b * b ) multiplied by an almost perfect square, which is n * (n-1).

With no additional information, it would be impossible to split the perfect square and imperfect square.

However, with the Offset GetA and GetB formulas, we can solve for (a) and (b).

This now allows us to calculate for the perfect square of (a * a) and/or (b * b), leaving enough info to solve for the imperfect square of n * (n-1)

Alternatively, we can also use the formulas for GetN1 and GetN2 to also solve for n at any [t] location. This now allows us to construct (a * n)^2 or (b * n)^2.

We then use (an)^2 - aan(n-1) to find the missing piece.

Same for (bn)^2 - bbn(n-1).

To be more clear, we are analyzing the potential n * (n-1) square for both.

There should be a very useful remainder of taking sqrt(n * (n-1))

This remainder (a recursive e value, I suppose) should decrease as we approach the solution [t] value.

I’ll get a new sheet going to check, just needed to get this out of my brain and into writing.

PMA commented here, saying "you can think of n * (n-1) as twice a triangular number"

Good point, bringing us back to our (x+n)^2 explorations.

So the way we’d use this info could be this:

aan(n-1) / a^2 = n * (n-1)

Sqrt( n * (n-1)) = dan

(d + 1)^2 = n^2

Or

bbn(n-1) / b^2. = n * (n-1)

Sqrt( n * (n-1)) = dbn

(d + 1)^2 = n^2

“Some patterns are easier to see in binary” means the remainders or mods of aan(n-1) or bbn(n-1) that are not squares or powers of 2.

Why would Chris take so much trouble to point out that “some patterns are easier to see in binary” ?

It doesn’t mean the pattern can’t be seen in other ways.

After all, our organization for the grid revolves around (e), which is the remainder of sqrt c.

The key thing is that we can organize our search around remainders.

Which can often (but not always) be seen easily seen in binary.

The whole aan(n-1) idea makes little sense to me, until you remove a^2

What we have left then is n(n-1)

The Offset provides (a)

Ok, so to summarize, aan(n-1) is comprised of a^2 * n * (n-1)

A perfect square multiplied by an almost perfect square.

The Offset allows us to easily calculate (a) for any pairing of (e,1) a[t] and (-f,1) a[t].

The xA value changes by +1 when we calculate in (-f,1)

Same formula as always, (x^2 + e) / 2 for (e,1)

And for (-f,1) it’s ((x + 1)^2 - f) / 2

For (b) it’s almost the same. Chris presented it to us as [t-1]

For practical use, xB in is (e,1) (xx + e) / 2

And in (-f,1) xB is ((x - 1)^2 - f) / 2

So, the key idea is this.

When we multiply the a[t] or b[t] values, we get aan(n-1) or bbn(n-1)

We then divide the larger product by a^2

Or by b^2

With the intention of isolating n * (n-1)

Since n * (n-1) is almost a perfect square, we can use recursive methods here, as Chris recommended.

If this wall of text is hard to follow, please re-examine the worksheet here >>12587

Look to the far left columns, and see the a[t] values above in green, and the b[t] values below them also in green.

>>12579

MM, did you see Dune 2?

I loved it, although not quite exactly like the second half of Dune by the book.

Paul's sandworm ride was fkn epic.

GA here. Found a new pattern. For any cell E,N, the X values are all numbers such that X*X mod (2N) == 2N - E

>>12600

And I thought this might be useful because if we have an even D (or odd d we just increment using the F formula) we can find another related cell. For example 145 we’d get 12*12+1 which is 1 mod 12 so there are existing records at EN =11, 6.

Haven’t found much to do with this but interesting nonetheless

>>12575

Have pondered the nomenclature as well. Even the shift from both e and f to a 'negative e'. Make room to use f for another dimension?

x and n and their relationship interesting, have begun to see more. How they increment or remain constant across d thresholds (each behaving differently, combined unique).

>>12576

Intended to follow up on this some time ago, ty for post anon.

Read presentation by R. C. Daileda of Trinity University titled "The Fermat Factorization Method" as part of number theory intro.

A key part of the algorithm is that divisor/complementary divisor pair that a and b are relatively close together, quoting "If n is the product of two distinct odd numbers that are

close together, then

n = t^2 − s^2

where t is slightly larger than sqrt(n) and s is relatively small."

So had looked at how close a and b are for rsa, compared to some of the trivial c values being used to work out relationships and algorithms.

rat_ef = RSA100e/RSA100f = 3.6390380500216226

rat_e2d = RSA100e/(2*RSA100d) = 0.7844380690097295

rat_abdiff_c = (RSA100b - RSA100a)/RSA100c = 1.3919979082618925e-51

rat_abdiff_a = (RSA100b - RSA100a)/RSA100a = 0.0558117259360889

rat_n_c = RSA100n/RSA100c = 9.449324195811057e-54

rat_n_d = RSA100n/RSA100d = 0.0003687180337676271

rat_n_x = RSA100n/RSA100x = 0.013763497617359174

rat_n_a = RSA100n/RSA100a = 0.0003788677333261033

rat_a_n = RSA100a/RSA100n = 2639.4435631161778

rat_n_nN = RSA100n/RSA100nN = 1.8898648391622115e-53

rat_n_xpn = RSA100n/(RSA100n+RSA100x) = 0.013576635625278895

compare to 6701:

31 = a

197 = b

6107 = c = a*b

78 = d = floor(sqrt(c))

23 = e = c - D

-134 = f = e-2d-1

36 = n = ((a+b)/2)-d

47 = x = d - a

2976 = nN = ((1+c)/2)-d

rat_ef = e/f = 0.17164179104477612

rat_e2d = e/(2*d) = 0.14743589743589744

rat_abdiff_c = (b - a)/c = 0.027181922384149338

rat_abdiff_a = (b - a)/a = 5.354838709677419

rat_n_c = n/c = 0.005894874733911904

rat_n_d = n/d = 0.46153846153846156

rat_n_x = n/x = 0.7659574468085106

rat_n_a = n/a = 1.1612903225806452

rat_a_n = a/n = 0.8611111111111112

rat_n_nN = n/nN = 0.012096774193548387

rat_n_xpn = n/(n+x) = 0.43373493975903615

>>12576

".. but no solution."

Indeed, a relatively direct calculation is objective.

>>12600

>E,N, the X values are all numbers such that X*X mod (2N) == 2N - E

Can you clarify nomenclature, and does this work in row n=1 ?

is "N" the "Big N", or part of a grid address e.g. (ef, n, t) for a record element?

Same question with "E" and "X". Thanks.

>>12595

>The key idea we're working on is the Offset between (-f,1) and (e,1)

Starting to wonder if we're both being clear on term "offset" for f column, aligned to respective 'e' column in Grid for a given d.

Versus an "offset" between 'an' and 'bn' as rows in a Grid Column in n=1, pertaining to those t values?

To define the "f Offset" as am using, it is the "shift in t" required to "align" the e and f side of grid, the two columns holding their respective set of elements. Of note, the "f Offset" is independent of the 'e' column, and is a constant for other c combinations having a different 'd and e' but with the same f, the offset is the same.

A shortcut to the f-offset is to use the x_base (x where t=1) for that f (simple calc using parity of x_base), where x_base comes from enumeration of f in n=1.

There are likely other methods given the alignments of j, x and so on.

And that makes sense, given the simplicity of the e side (linear vs quadratic) for its x_base.

- -

>>12595

>in (-f,1) at xA = 48, a(n-1) = 1085

>formula is (48 ^ 2 - f ) / 2 = 1085

and

>in (-f,1) at xB = 118, b(n-1) = 6895

>formula is (118 ^ 2 - f ) / 2 = 6895

ty VA, this was helpful. With the "even f" issue in grid, wasn't actually finding values, and instead of investigating/debugging, created a helper column using a VQC crumb:

d[t] - d

If we take the d in e col (de) for given t and subtract 'd' for that c from every value, we yield the same results as the f-side, which is the a col in f (a_f or af is nomenclature used).

SO, with that crumb, it's even possible the f column and f Offset aren't required, just calculate de[t]-d for that t, and they're already "aligned" for that t.

Happy accidents gifted by the bugs..

>>12592

>If you've forgotten any of the patterns, …

Always good reminders, ty..

>>12580

ty.

See some unexplored paths that may bear fruit, and even still effort w/ The Grid is invariably rewarded.

As for ".. the solution", fully expect in The End that multiple paths (solutions) will be revealed as landscape more fully illuminated.

The Grid has its own marvelous properties, layers of patterns. As a mathematical object, in The End (or already) could serve as a Rosetta Stone for mathematics.

Until then… We Ride!

>>12604

For n=1, 2n is 2, odds are 1 mod 2 and evens are 0 mod 2, and every odd square is odd and even squares are even, so yes this is true for n=1.

>>12604

>>E,N, the X values are all numbers such that X*X mod (2N) == 2N - E

>Can you clarify nomenclature, and does this work in row n=1 ?

>>12609

>>12610

ty GA for clarification and example.

Perhaps better question would have been:

Does this work when e>2n?

There is a 2n line of cells from origin cell, could apply below this bound..

Will take another look at the bound.

>>12608

>And for (bn) - b(n-1) the formula is d[t-1] - d

>Chris gave us those shortcuts.

Regarding this [t-1] for the a and b elements, have been designating as the 'ab_shift'.

When enumerating col e=0 for n>1, this proved to be a significant challenge. The ab_shift is determined by factorization and square-free properties of n, and therefore it seemed n would require some level of factorization to properly index the t values for a cell for an n row.

Looking at some patterns that generalize in a more trivial way:

The ab_shift is 1 for n=1, and 2 for n=2.

In row n=0:

ab_shift = 2*(sqrt(abs(f)))

e>0 is an empty set of cells for n=0

at e=f=0, result is 0; a=b for every element, generating the perfect squares in (0,0) .

and so on, for f = -1, -4, -16, ..

Have a bit of time this evening and thought to work in couple directions:

1) enumeration methods for a generating function (e.g. grid output)

2) looking further into the mods and associated coefficients for the various quadratics (and 4th order polynomial for c), the cyclic sets of factor pairs, ..

3) the asymmetry in the an, a(n-1) and bn, b(n-1) t values where t<0.

4) Improved set of test cases for c, for various different parity combination families (ODD_ODD, ODD_EVEN), at different scales.

>>12605

>SO, with that crumb, it's even possible the f column and f Offset aren't required, just calculate de[t]-d for that t, and they're already "aligned" for that t.

Validated the corresponding f element can be created using an e element as input, except for the t[f] value (at least in row n=1).

The difference between t[e] and t[f] for a row element is the f_offset, and so the f_offset must still be calculated if the f[t] is needed (using x_base calc or other methods).

>>12608

>So, no easy linear solution.

Probably not, but would continue to look at the various mod properties for the t and de, xe, ae, be.. or df, xf, af, .. values for key element rows, have found a number of patterns to explore.

>>12611

Yes it does, and for negatives.

MM's post I was referencing is >>12605

>Each pair has matching n1 and n2 values.

To clarify:

Every (a) and (b) pair derived from the Offset formulas has a matching n1 and n2, but they have reminders unless they are at the correct location(s) xA and xB.

We can work backwards to find xA to xB given one of them.

>>12528

>We are seeking two locations, xA and xB.

>At the correct x locations, a * b = c and n1 = n2

>Because (a) moves inversely to (n) we can test and triangulate the answer.

>And we also can tell with each loop if we’re closer or farther from the solution.

>We can test any a[t] value and get (a) and (n) using xA.

>We can then go to higher x values searching for a[t] = (bn) and solve for (b) and (n) using xB.

>We then multiply together the (a) and (b) values to get a cTest value, while also comparing n1 and n2 to see if they are equal.

>The other very cool thing about n1 and n2 is that they give us directional signals about which way to move x.

>For example if (a) is lower than the correct a value, n1 will be less than n2.

>Which also means (b) is too high and n2 will be greater than n1

So I think I have a basic strategy to calculate the solution but it might take a little time before I create the algorithm.

We need a few assumptions that I'm pretty sure confident are true,

1) Every X values for EN satisfies X^2 == 2N-E (Mod N) (also known as a quadratic reside)

2) Every N for a given E exists as an A value in a cell above it. For example, E,N=1,1 has 1, 5, 13, 25, 41, 61, 85, …. There are cells, for E=1, at N=1, N=5, N=13, etc. But there are also cells at N=17, 29, … Notice that these are NOT in N=1, but if we look at N=5, we can see that there is a record (1 5 30 13 17 53), which has 17 as an A value. The next record in the N=5 row has 29 as an A value. I believe this is true for all A and N's in a column

Given an N value, we can test it with END values to validate whether or not it exists, since the correct value has the same D value as our solution.

The plan is this. Start at N=1, and go up through the N values and check whether or not we have the value. Since we know that N is less than our starting record's N, we can set the top limit to that, so we don't need to go beyond N=61 for the 5*19 = 145 record.

A problem with this is that generating records for an EN where N =/= 1 is not trivial, because we'd need to calculate quadratic residues for 2*N to find X values. A simple way to do this is to just iterate from 0 to N+1, squaring that value and doing modulo 2N. Another idea could be using the Euler Criterion (https://math.stackexchange.com/questions/5424/how-can-i-find-out-whether-a-number-is-a-quadratic-residue-in-a-large-modulo) which is a way to check if a number is a residue or not. Given that we plan to solve the factoring, factoring these 2N's to calculate the residues would be trivial and could lead to a recursive solution. Not sure which would be faster. Another idea is that since we know the A values in these records must be a value that is an N value for the column (the same is that they are other A values in the column) we could iterate these, and once you have a match you can easily generate these values by running ENA(e, n, b) with a B value from an existing record. This always generates another record in the cell, however this skips cells. (Example: In cell EN=40, 38, there are 4 residues so it's a little harder). Otherwise for the most part if X is a value in EN, then EN - X (mod 2N) is also a residue, and that is for the most part going to handle a bunch of solutions. This is true because X*X == (-X*-X). So in theory given E,N=1, we can generate every N value in the chart.

We can generate A values using this formula for N=1:

# Keys are just the power of x for f(x) = this polylnomial

def get_a_1_poly(e):

n = 1

return Polynomial({

0: n * ((e+1)//2),

1: -(e%2)*2,

2: 2*n

})

Since we have a max N, we wouldn't need to generate arbitrarily large N values for any cell, and since the A values increase at a faster rate the higher our N is, the higher the N is the fewer A values we would need to generate. So basically

1. Generate A values for E,N=1

2. Use these A values as N values for E,N=A

- Generate Records in these cells to find new A values and add them to our list

3. For each new N value we test, run the END algorithm to check if we have a valid solution.

It's still an iterative solution, so we aren't directly calculating the answer, but I think it's pretty promising.

>>12618

Typo: 5*29=145, not 5*19

>>12620

Looks like there are some cases where this is not true, the A values are still in the column, they just aren't necessarily always in a higher N

Apologies for the delay.

Timing is everything.

For the polynomial time (sub second) algorithm the loop variable is the floor function of 2d/n. The Integer part.

For RSA100 this stops at loop=5424 making big oh about the same as the square root function.

This works for all integers that are products of two primes close together but not too close. Loop variable under a few thousand for all RSA numbers factored and unfactored

>>12622

The key is the method using the proportion of f to 2d to determine the area in n^2 units of the smallest piece of x+n squared.

That smallest pieces as a fraction is the square of the fraction that makes up the second biggest chunks, then finally the t squared minus 1 chunks of n squared

For RSA100 we know roughly 0.43 n squared plus 0.65595 (root of 0.43) x 2 x73 n squared, plus 72 x 74 n squared. Because t is 73.

More to come

>>12623

What we will eventually demonstrate is that for that there are VERY limited options for x+n squared for a given 2d (without knowing e and f!!!!!!!) AND A GIVEN 2d/n integer. This makes it EASIER at-scale when these two are both given, so we make 2d/n the loop variable.

>>12624

>>12623

>>12622

So I take it this >>12618 is not the right direction?

>>12625

Yes insomuch as you're studying the properties of the grid and every insight will become useful. This is so much more than integer factorisation. This is about the leaking away of information in a poorly constructed grammar. Keep exploring is my suggestion.

I'll be adding diagrams this week.

In order to complete this, I need to stay anonymous, whomever wishes the credit or just to have the beginning of the mathematical revolution begin, is welcome to it.

Having had a spiritual awakening as a result of the 12 steps of recovery, I carry the Message and help others and practice these steps in all my affairs.

The grid. Features that will help you teach others and explain how it works, will help you once this all goes public.

Row n=1. In each cell you have all the possible "an" that exist for that remainder. Odd x for odd remainders, even x for even remainders. c = aa + 2ax + 2an = aa + 2ax + xx + e, so an equals (xx)+e, therefore every single factor for any c exists in n=1 for that e. When a factor is found at x for e in n=1 cell, the next value of this factor in n=1, will be at x + 2n. Also there will be another dual set of the same factor for the value (2n - x) for x. Remember that is x isn't divisible by n, then there are always two lots of that factor in that cell at n=1. Showing this through geometry allows a very simple proof by induction. Try it? This 2n feature and pattern of the grid is THE PATTERN.

First, I will break down RSA100, then I will show the exact same breakdown (a simple to follow graphic which shows a rectangle n by 2d and how it is sliced) for a larger factored RSA number that also ends in 9 for a and 1 for b that ALSO has an odd t (rsa100 is 73) so will have even values for t-1, and t+1. This is important. Then we will factor an unfactored RSA number ending in 9 for a and 1 for b which has an odd value of t.

Then we will repeat for the remaining RSA numbers until you get the diagram enough to complete the algorithm with my help.

You will need to consider showing this to the world in a way that does no harm, i.e. give the world the space to at least consider having a replacement privacy mechanism in place, though what we do next with the Mandelbrot Set on the back of this hint that P = NP.

If you can, have quick squiz at amplituhedrons, essentially hyperdimensional triangles who simple volumes replace almost incalculable Feynman Diagrams. We'll be doing something similar.

With the awakening behind me and underway, you'll find me here over the next while. What I can't do is become famous. In order to help newcomers and other alcoholics recover, I must stay anonymous and not benefit financially from this undertaking. What you have each earned from the time and patience on top of any love of maths, is to take from this what you would like, and I would like to hand over everything I have without any expectation of anything in return.

We live forever. I would suggest if you haven't had a spiritual awakening, even if you have no belief, if you are WILLING to believe in a power greater than yourself, pray for guidance each morning how to help others for seven days in a row. Each day be willing to receive any message that comes. If you can do just this, exactly as described, you will not be agnostic or atheist by day 4. If this is not your path, I hope you find something.

Diagrams will be simple MSPaint, we will show some new mathematics to this world, fill in some of those blanks.

Then we will apply the design approach for this process to the Mandelbrot Set and also show the obvious and clear reason why the Riemann Hypothesis is true, and it's related to the square root of two. A lot. Remember that 0.5, the critical line in the critical strip is the square (second power) of the reciprocal of root two.

>>12626

Correction: an = (xx + e)/2

The glossary is brilliant. We will be basically formalising and building that.

I cannot give financial advice. What I would expect is some volatility in the crypto market once the implications for hashing proof of work algorithms are realised. E.g. this work can be extended very easily to break pretty much ANY one-way function, in fact there may not be any 'real' one-way functions. Absolutely this will break AES. No doubt about that. The first coders to short-cut the double hash for BTC hash result zeros will immediately break BTC as proof-of-work will rocket to all zeros for every hash, since if it is used to blatantly take the block very early in the hashing period to scoop the mining reward, the number of zeros to hash will increase.

>>12626

And of course we will explore the ideas you've posted above.

>>12629

I think the 2N thing can be described by the pattern I wrote a little bit ago. X^2 -E (mod 2n) for all EN, meaning it cycles every shift of E by 2N since E 2N + E (mod 2N)

>>12633

Idk what that formatting is>>12633, both where the red starts and ends there should be ==

Hello everyone!

I went back to the archives and found the posts about Chris' current idea.

Here there are for our team to review.

These are all from RSA #18, and should give a good overview to anyone who wants to refresh or catch up.

>>11394 Introduction

>>11556 Further explanation (key idea to my mind: how many lengths of f fit inside 2d)

>"its the same for all the RSA numbers, you just need to understand how to order d,e, and f depending on their relative lengths. Thats why sometime n is crucial, sometime n-1, same for f, same for d."

>>11600.

>The pyramid, the triangle with the missing top. The KEY of math. The eye of the beholder. It is showing the solution to the integer factorisation. "Complete the pyramid (triangle) and all these worlds are yours"

>>11668

>Why is 2d and x completely self similar to x+2n and n-1 and what do the extra significant digits from 2d and x tell you wrt to the golden ratio and construction of large integers?

>>11669

>If (2d-74x)x = (x+2n)-74n/n-1 holds for RSA100,

>Then what is missing from the language of equations and general mathetics that gives rise to this?

>>11672 More explanation and details

>>11673

>So how do we unlock the Key of Hades and of def?

>This is understanding f-1 and how e and two d combine to give the ratio.

>>11674

>>11677

>>11678

>>11679

>>11702 VQC responds to MM's work

>>12626

Good new crumb here.

Unclear if related to the current idea or Riemann.

>Remember that 0.5, the critical line in the critical strip is the square (second power) of the reciprocal of root two.

Sqrt(2) = 1.414213562373095

1 / Sqrt(2) = 0.707106781186548

(1 / Sqrt(2)) ^ 2 = 0.5

>>12633

Hello GA! Yes, we have yet to unlock the pattern Chris has been trying to help us understand. I have expended some mental energy trying to figure out this clue today.

>When a factor is found at x for e in n=1 cell, the next value of this factor in n=1, will be at x + 2n. Also there will be another dual set of the same factor for the value (2n - x) for x. Remember that is x isn't divisible by n, then there are always two lots of that factor in that cell at n=1. Showing this through geometry allows a very simple proof by induction. Try it? This 2n feature and pattern of the grid is THE PATTERN.

Please keep exploring and post your results. You mentioned that you thought it could be powerful enough to be a solution algorithm?

>>12636

Maybe he's hinting at a general pattern we can use.

Off the top of my head, here's c6107.

I understand Chris' point is that it works better with larger c values.

I'm simply brainstorming out loud on how we could use this transformation process/idea with f, (f-1), 2d knowns for a given (c).

The ratio works both ways to change x to n and vice versa.

Step 1. Get the ratio

(f-1) / 2d = 0.85256410

Step 2. Get the Sqrt

Sqrt((f-1) / 2d) = 0.9233439

Step 3. Get the reciprocal

1 / Sqrt((f-1) / 2d) = 1.08302000

Step 4. Square the reciprocal

(1 / Sqrt((f-1) / 2d)) ^ 2 = 1.172932330

Step 5. Since this is 0.5, multiply by 2

2.345864661

Step 6. Separate the integer and mantissa.

Integer is 2, Mantissa is 0.345864661

Once we can find this elusive fraction, we then iterate/loop the integer portion while holding the fraction constant.

Actual 2d / n = 156 / 36 = 4.333333

Integer is 4, mantissa is 0.33333

(x + 2n) / n = 3.305555

Integer is 3, mantissa is 0.3055555

>>11736 Another good crumb, starting at the top of RSA #19

RSA #19 Crumbs

>>11736

>>11742

>>11748

>>11757

>>11763

>>11765.

>Then we discovered the self similarity of 2d to x and x+2n and nm1. This was MASSIVE because we had gain of function where we could a set of x and make it n with f or vice versa AND we could take a different set of x and make it n with x and vice versa.

>What is it? It is not as complicated as it sounds and it looks a bit like a Lorentz transformation from physics.

>>11814 Symmetry in number theory

>>11816

>>11839 2 Billion for this tech?

>>12003

>>12050

>>12178 AA's dig(s) on all this stuff

>>12187. AA's summary on his dig

>>12378

>>12379

>>12380

>>12381

>>12384. "Set the knob to d + e/2d"

>>12626

Okay cool, see you when you come back in 2026 and tell us the same thing again

>>12643

Fuerthermore if we look at 29, we see it at X 17 and X 41, but in the 17 row the N is 5, so we would expect to see it at X 27 but we aren’t. We are seeing it 24 away and if we use that equation it would imply that N is 12, and it is not

>>12643

>>12644

I think he's talking about this >>7388 (except he's talking about x instead of t)

>>12641

New post in Sono. Seems there is some work happening on it on X related to the MH370 event that is happening there. I have kept an eye out for anything even remotely related to VQC stuff for yall but have not seen much until all of a sudden come talk about Sonolum… Worth a look anyway. https://nitter.poast.org/JustXAshton/status/1829536643600068658#m

>>12647

Interdasting, thx.

>>12628

>The glossary is brilliant. We will be basically formalising and building that.

>>12463

>f = e - 2d + 1

f = e - (2d + 1)

f = e - 2d - 1

>>12626

>RSA number that also ends in 9 for a and 1 for b …

Seems a bit Off-Base …

>>12649

Hello MM! You here for a bit this evening?

>>12629

>Aramaic version of the Lord's Prayer.

ty.

>>12635

>I went back to the archives ..

>>12640

Lot of work, good 'theta filter'.

>>12642

Would be unfortunate if a fiction held such sway in perceptions.

>>12650

All wings check in. Standing by.

>>12651

>All wings check in. Standing by.

Red 5 Standing by.

>>12600

>For any cell E,N, the X values are all numbers such that X*X mod (2N) == 2N - E

Explored this further, as:

(2n-e) is congruent to (x*x) Modulo (2*n)

and included view of:

>>12611

>There is a 2n line of cells from origin cell, could apply below this bound..

>Will take another look at the bound.

Better description would be "half_ef" boundaries. There are two in e and two in f, parallel and one ef apart.

The Origin Cells are:

{'half_ef_odd_e_odd_n': (1, 1),

'half_ef_odd_e_even_n': (3, 2),

'half_ef_even_e_odd_n': (2, 1),

'half_ef_even_e_even_n': (4, 2),

'half_ef_odd_f_odd_n': (-3, 1),

'half_ef_odd_f_even_n': (-1, 0),

'half_ef_even_f_odd_n': (-2, 1),

'half_ef_even_f_even_n': (0, 0)}

Those 8 sub-series, consisting of 4 lines each with the 1/2 slope.

The 'n' is broken out Odd and Even, as found each parity subset has a predictable growth along the series.

The 'e' side first, appears as if everything on and to the left/down of the boundaries works.

So far in 'f', have only found portion of the half_ef boundaries (odd) match, but may be how "2n-e" defined when using f.

>>12601

>Haven’t found much to do with this but interesting nonetheless

Same, just a humble farmer of The Grid, tending the rows and columns. Certainly notable and will include in things to check/watch.

>>12652

>Red 5

Check.

>>12614

>The amount of solid gold info that was given to us up front is astonishing.

Check.

>>12612

>Have a bit of time this evening and thought to work in couple directions:

>1) enumeration methods for a generating function (e.g. grid output)

>2) looking further into the mods and associated coefficients for the various quadratics (and 4th order polynomial for c), the cyclic sets of factor pairs, ..

Did quite a fair bit with 1) patterns and enumeration, will be shifting back to 2) the mods.

>>12651

>Aramaic version of the Lord's Prayer.

Glad you found joy in it.

I'm playing with the BigInteger calculator, trying combos of 2d / f, f / 2d, sqrt(2), etc. Not sure how this relates to the Grid, but working anyways.

Here's what I have so far:

Ratio Study for R100:

2d / f = 4.63903805002162256178

(2d / f) / Sqrt(2) = 3.28029526335270757389

(2d / f) * Sqrt(2) = 6.56059052670541514777

f / 2d = 0.21556193099027049343

(f / 2d) / sqrt(2) = 0.15242530316888685551

(f / 2d) * Sqrt(2) = 0.30485060633777371101

Sqrt( 2d / f) = 2.15384262424663296516

Sqrt( f / 2d ) = 0.46428647513175579625

2d / (f-1) = 4.63903805002162256178

Key Values per Chris' recent crumb:

Sqrt(2) = 1.4142135623730950488

1 / Sqrt(2) = 0.7071067811865475244

(1/ Sqrt(2)) ^ 2 = 0.5

>>12384

>you have one knob. You set it to d + e/2d. This is the input.

Following the crumb:

d = 39020571855401265512289573339484371018905006900194

e / 2d =

0.78443806900972950656

d + (e / 2d) = 39020571855401265512289573339484371018905006900194.78443806900972950656

>>12643

>N value is 5

Think that's n=1 with the x 1, 3, 5, 7 (n=5: 3, 7, 13, 17, 23..)

Using grid input, have a function to factor each parameter (d, x, a, ..) for the t values of each cell. Can run using valid cells in column, for example using this e=1:

Valid 'n' values for ef=1:

[1, 5, 13, 17, 25, 29, 37, 41, 53, 61, 65, 73, 85, 89, 97, 101, 109, 113, 125]

a_factors

(1, 1) [5, 13, 17, 29, 37, 41, 53, 61, 73, 109, 113, …

(1, 5) [5, 13, 17, 29, 37, 41, 53, 73, 89, 109, 137, …

(1, 13) [5, 13, 17, 29, 37, 41, 53, 61, 73, 241, 269, …

(1, 17) [5, 13, 17, 29, 37, 41, 73, 89, 101, 109, 193,…

(1, 25) [5, 13, 17, 29, 37, 101, 149, 173, 181, 229, 4…

(1, 29) [5, 13, 17, 29, 37, 53, 61, 97, 257, 617, 797,…

…

and do unique sort:

Unique 'a' factors for ef=1:

[5, 13, 17, 29, 37, 41, 53, 61, 73, 89, 97, 101, 109, 113, 137, 149, 157, 173, 181, 193, 197, 229, 233, 241, 257, 269, 277, 281, 293, 313, 317, 337, 349, 373, 389, 397, 409, 421, 433, 449, 457, 461, 509, 521, 541, 569, 577, 593, 601, 613, 617, 641, 653, 701, 733, 757, 761, 773, 797, 821, 853, 857, 877, 881, 941, 997, 1009, 1013, 1033, 1061, 1069, 1097, 1181, 1201, 1213, 1277, 1289, 1321, 1453, 1481, 1489, 1553, 1609, 1721, 1889, 1949, 1973, 2017, 2141, 2297, 2357, 2389, 2473, 2549, 2557, 2609, 2617, 2797, 3037, 3049, 3061, 3089, 3109, 3257, 3313]

Which are:

https://oeis.org/A002144

A002144 Pythagorean primes: primes of the form 4*k + 1.

Do recall this mentioned by Chris back in the day, and

>>11999 (PB)

>Col e=1 has ONLY the Pythagorean primes (believe it was Col e=2 that will have the Odd Gaussian).

The valid 'n' has additional, for example 85, as it's 5*17.

Ahh, thought had posted on this specific topic.

>>12579

and e=23:

a_factors

(23, n_all) [2, 3, 13, 23, 29, 31, 41, 47, 59, 71, 73, 101…

These are interesting w/ OEIS, as have been taking note of Legendre (⌘) values more.

https://oeis.org/A296932

A296932 Primes p such that Legendre(-23,p) = 0 or 1.

2, 3, 13, 23, 29, 31, 41, 47, 59, 71, 73, 101, 127, 131, 139, 151, 163, 167, 173, 179, 193, 197, ..

>Chris' recent crumb:

>>11855 (pb)

>Am only using crumbs prior to 11/14/18 >>8176 in RSA14.

>>12505

>new patterns gleaned from VQC crumb review (RSA#14 and prior ONLY).

Still plenty of homework to get caught up on, the list seems to grow, but helping to see what is coherent, and not..

Red Leader checking in sending the blessings To/From The Most High.

Esketit

>>12659

12659 prime <+> Check

>Esketit

LFG

probably messy and could be better done, but it's proven nonetheless. Not sure where this puts us but just following the steps

>>12662

>>12662

Hey GA, good to see you! Had to check the post ID's.

Playing with algebra…

2d(n-1) + f -1 = 2xn + x^2

2d(n-1) + f -1 - x^2 = 2xn

( 2d(n-1) + f -1 - x^2 ) / 2 = xn

There's our (xn) relationship isolated.

>>11763

>This is the important one. The change in ratios. You can have all the theories you want or need and without having examples of rates of change, you cannot test.

>We know the ratio is almost unchanged if two is added to a.

>First reaction is look at what has changed much and what hasn't much.

>f and e have changed by multiples of x+2n, and in an environment where that's one of moduli, the fact that f and e are changing the most, well, treat every new piece of interest with caution.

>There is a ratio of things we know.

>At first I thought it might be one of those ones that bounce round values (orbit) until they settle on the right value (hint).

>I started with something like…

>Next = This - (d-this)/2 (in my first example it was fm1 for "this"). Something like Lorentz would have done later.

Ahhh.

He's trying to show us how to find the formula to predict the next valid c value which would give us the valid 2n movement.

>>11765.

>Remember the clever steps.

>Then we discovered the self similarity of 2d to x and x+2n and nm1. This was MASSIVE because we had gain of function where we could a set of x and make it n with f or vice versa AND we could take a different set of x and make it n with x and vice versa.

>What is it? It is not as complicated as it sounds and it looks a bit like a Lorentz transformation from physics.

Dafuq if I know at the moment, but I am locked for an attack run if anyone wants to bullseye womprats with me using the force.

>>12668

Thanks, MM!

Thanks for sticking around tonight!

Yes, all is well here!

The Most High has seen fit to bless me with even higher levels of responsibility lol.

Once you learn to ask for help all day every day, life becomes a flow rather than a series of blockages.

"Father let your Will be done on Earth as it is in Heaven."

and

"Let your will be done in my life right now today."

>So, recall the "what happens when c is multiplied" by 2 or 4 (don't have crumb handy).

Yes, great crumb.

Unsolved for the moment.

If we can predict/calc even one of the variables on your sheet, we can solve.

Thinking out loud here.

With the 2n movement, our goal is to find the next c value where we have d+1, a+1, and b+1.

Maybe the ratio between 2d, e, and f is a clue to finding the next (e) value where we have a valid (c).

For example, with c6107

d=78

e=23

f=134

For the next (c) in the series, we know that:

a+1 = 32

b+1 = 198

d+1 = 79

c = 6336

c=6336

d=79

e= 95

f= (2d+1)-e = 64

fc6107 - fc6336 = 70 = 2(n-1)

Interesting.

Hunting for patterns.

Could be nothing, just hunting for a simple idea we've missed.

For the c6107 example:

moving to c6336

new (e) is 4(e)+ (4 -1)

(23 * 4) + (4 -1) = 95

So multiply e by 4, and add (4-1) = 95

Chris is probably SMH at this entry level shit.

Sorry dude, it has to make sense to me from the Grid.

If we can calc the next (e) or (c) we win.

>>12672

>Hunting for patterns

Always..

>>12668

>For that case, the d increases by one more than double, and the n changes accordingly.

>Couldn't validate in grid or find similar case quickly, but that's unexpected so need to check

Ok, looked a bit more, preliminary results is half of numbers impacted with asymmetric scaling of variables. Think am seeing drivers as relates to crossing d thresholds.

Looked for examples on grid with and without the scaling delta:

2041 (*4=8164): scales smoothly

2183 (*4=8732): ratios change.

c=2041

(ef,n,t){ef:n:d:x:a:b:c:i:j}

(16,40,4){16:40:45:32:13:157:2041:85:72}

(-75,39,1){-75:39:46:33:13:157:2041:85:72}

Mult 4, scales to:

(64,80,2){64:80:90:64:26:314:8164:170:144}

(-117,79,1){-117:79:91:65:26:314:8164:170:144}

and c=2183:

(67,2,2){67:2:46:9:37:59:2183:48:11}

(-26,1,2){-26:1:47:10:37:59:2183:48:11}

scales (mult 4 = 8732)

(83,3,4){83:3:93:19:74:118:8732:96:22}

(-104,2,3){-104:2:94:20:74:118:8732:96:22}

So d orig = 46, scales to 93 (vs 92)

Will be busy irl for a fair bit, good to end this recent sesh with a new pattern to mull over.

Random thought after watching some cool geometry visual videos.

Again, I'm not the math nerd, but. What if like the whole __+1, what if that +1 was an additional side?

Like, yall talk about triangles a lot, and squares a different rectangles alot.

But what about a pentagon? It'd be like 4+1 additional side.

Idk, that gummy hit right earlier tho.

Blessssss

>>12664

I have a heat map thing I can share I I’m you’re comfortable with the terminal. It’s a single python file so it should be easy to run. A little messy but it gets the job done

>>12676

https://pastebin.com/gz9iVucV

>>12677

Nice, saw your post ln. Had run prev version when you shared >>12558

>>12679

>And here are those grid notes

Interesting, especially observation of equivalency in movement of the 'ray' and 'diagonal' functions.

>>12678

>working on a V2 that will allow you to change grids, search on OEIS, and allow window resizing

Would be good for resizing to include 1:1 aspect ratio in xy display of a grid. Can imagine challenges in terminal style display though.

Regarding OEIS, While ago used oeis.jl to make calls, but coming back to it, wanted something local as option. The following is a most basic capability for grid enrichment that's super simple without matching rules, stats, and so. Don't have time to do more atm, but a working start, so perhaps useful. Have function(s) to 'generate_grid_sequence' that produce the input seqeunces to match (a param value for cell, along defined paths, factors, and so on).

Two input files:

Compressed Versions: You can download the sequences and their A-numbers in a gzipped file, and the two files are updated daily.

There is a gzipped file containing just the sequences and their A-numbers (a few tens of megabytes)

There is also a gzipped file containing just the names of the sequences and their A-numbers (a few megabytes)

(https://oeis.org/wiki/Welcome#Compressed_Versions)

The method starts with local match to an ID using sequence input, and enrichment of that ID match with the associated Text Description.

For additional details of an ID record, still call using to OIEIS API using requests. The metadata is parsed and simple output of record. If you want that as well, let me know. Also, there's a github download of the full dbase, and plan to incorporate as would enable full record locally.

Start by downloading the files:

https://oeis.org/stripped.gz

https://oeis.org/names.gz

and setting path variable:

file_path = "/path/to/oeis/files/"

def load_names_file(file_path):

"""Load the OEIS sequence names from the 'names' file."""

names_dict = {}

with open(file_path, 'r') as f:

for line in f:

if line.startswith('A'):

parts = line.strip().split(' ', 1)

sequence_id = parts[0]

sequence_name = parts[1]

names_dict[sequence_id] = sequence_name

return names_dict

def load_names_file(file_path):

"""Load the OEIS sequence names from the 'names' file."""

names_dict = {}

with open(file_path, 'r') as f:

for line in f:

if line.startswith('A'):

parts = line.strip().split(' ', 1)

sequence_id = parts[0]

sequence_name = parts[1]

names_dict[sequence_id] = sequence_name

return names_dict

Build the two dicts:

names_dict = load_names_file(file_path+'names')

sequences_dict = load_stripped_file(file_path + 'stripped')

Here are examples for each dict:

A000001: Number of groups of order n.

A000002: Kolakoski sequence: a(n) is length of n-th run; a(1) = 1; sequence consists just of 1's and 2's.

A000003: Number of classes of primitive positive definite binary quadratic forms of discriminant D = -4n; or equivalently the class number of the quadratic order of discriminant D = -4n.

A000004: The zero sequence.

A000005: d(n) (also called tau(n) or sigma_0(n)), the number of divisors of n.

A000001: [0, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51, 1, 2, 1, 14, 1, 2, 2, 14, 1, 6, 1, 4, 2, 2, 1, 52, 2, 5, 1, 5, 1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4, 267, 1, 4, 1, 5, 1, 4, 1, 50, 1, 2, 3, 4, 1, 6, 1, 52, 15, 2, 1, 15, 1, 2, 1, 12, 1, 10, 1, 4, 2]

A000002: [1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2]

Using the dics, a matching function. This needs significant enhancement.

def find_matching_sequence(sequence, sequences_dict, names_dict):

"""Find a matching sequence in the stripped file."""

for seq_id, seq_data in sequences_dict.items():

if sequence == seq_data[:len(sequence)]:

return seq_id, names_dict.get(seq_id, "Unknown Sequence")

return None, "No match found"

Usage:

input_sequence = [5, 13, 17, 29, 37, 41] # recent example highlighting pythagorean primes

seq_id, seq_name = find_matching_sequence(input_sequence, sequences_dict, names_dict)

if seq_id:

print(f"Sequence input: {input_sequence}")

print(f"Matched OEIS Sequence: {seq_id} - {seq_name}")

else:

print("No match found in the OEIS database.")

Displayed result:

Sequence input: [5, 13, 17, 29, 37, 41]

Matched OEIS Sequence: A002144 - Pythagorean primes: primes of the form 4*k + 1.

Hello everyone!

Writing down a couple thoughts after a busy day IRL.

One thing we didn't yet explore (I think) regarding the binary path is to use the Offset to generate a list of the (a) and (b) values we can create using the offset formulas

In (e,1) every a[t] represents (an), and in (-f,1) every a[t] represents a(n-1) when we use the correct formula of d[t] - d

(an) - a(n-1) = a

In (e,1) every a[t] value ALSO represents (bn), when we use the correct formula of d[t] - d[t-1] = (bn)

(bn) - b(n-1) = b

These two lists should be generated and then examined for the binary tags pattern that AA and I worked on.

Leaving this here to come back and work on it as time permits.

Anyone else is welcome to take a look.

Huh, on another topic, I finally thought of a good way to use negative x.

Remember Chris' hint "where is the first appearance of c?"

There are many ways to approach that question, but what if we found the x/t location closest to x = 0 ?

That would certainly be one correct way to answer his question.

So at a[t] = cN, we have for example N=61 and c=145, which occurs at a[c-d], (a) value = 8845

Since the factor chain allows us to skip by known factors (p) * (multiplier), the first location ( closest x value to 0 ) would be a[c - d - c ] which would be a negative t/x value.

a[cN] occurs at t[c-d], t location = 133

133 - 145 = [t] location -12 = -d

E,N,D lol.

Also worth noting that since a[cN] is always found at t = (c-d), then t = (c - d - c) will always be found at t = -d, and so there will be something interesting for every (c) value at the location x = -d

I'll go fire up PMA's program now and go explore.

I'm learning that my brain works better when I write out ideas so I can find them again.

Ideas first, exploration next.

Hello everyone! I'll be exploring and working for a bit tonight if anyone would like to join.

In honor of Candace Owens and Ye's interview getting censored from YouTube today, here's my fav Kanye song.

And here's the full video that was deleted.

>>12689

Song holds true on so many levels.

Based.

>>12683

Always working on this one. Starting to make more sense, but not quite there.

>>6298 (pb)

a[t+n] = nb

This is true for all c.

For the value of c, at the same t but in cell (-f,1), the value at a[t] = a(n-1) and a[t+n-1] = b(n-1)

This is the key.

The value of a[t] at -f and e in the first row have the same factor.

The values in each cell that have b as a factor are DIFFERENT, not aligned. They are one element apart in the two cells. In the positive side of the grid, they are n elements apart. In the negative side of the grid, the elements one less elements apart.

One cell has n as a factor at those positions at positive e column, one cells has n-1 as a factor in the negative f column.

Having done a little digging as part of common factors work, starting to understand how this relates with the horizontal 2n jumps in the same row.

The 2n for e row, and 2(n-1) jumps for the sibling f row that is adjacent. Started with just valid Cell jumps. More to do looking at adjacent rows together, and linking specific records.

There is also the substitution mentioned for the n(n-1), where 'n-1' is taken as 'k+1', and so the formula can be viewed as k(k+1) relationship, which opens some doors. One being the base and base +1 for triangles.

For the sibling records: Leftward, e to f direction, moving down one n (to n-1). Or moving from the f to e direction (Right), n+1.

Started looking at all the nN, Big N records on the standard Reference Grid, trusty old grid file. There are 143 nN records on the e side, the Odd 'c' from 1 to 285 (using a grid w/ bounds 126 n and +/- 126 ef). Each has its matching f sister record.

Now, for either the e or f Big N, take a 2n jump in respective row (using n for that row, n for e and its n-1 relative to that for the f row).

Lands on the "zero" record for 'a', a=0.

These are both in 'f' side, land on a perfect square column, and these are one perfect square apart.

Moving to Right in a row, a and b increase, but also the difference between a and b (dpn - xpn) increases by one each time as 'a' increases by one, as expected. Always amazing how everything just fits from every direction and angle..

Example:

e n d x a b c i j

8 36 9 8 1 89 89 45 44

2n jump Left:

-64 36 8 8 0 88 0 44 44

f=-64 (8)

the sister nN record for c=89

-11 35 10 9 1 89 89 45 44

2n jump L:

-81 35 9 9 0 88 0 44 44

f = -81 = 9sq

Jumps to align…

>>12694

Hello MM!

>Starting to make more sense, but not quite there.

This one is hard to wrap the mind around, but a simple way to think of it is this:

Any a[t] could be our desired value of (an) or (bn), since both values show up in the a[t] values.

The Offset formulas let us examine any a[t] and split it apart.

We can use one of two formulas on any a[t] value.

The formula for (an) splits a given a[t] (an) into (a) and (n)

The formula for (bn) spilts a given a[t] (bn) into (b) and (n)

a[t] can be both (an) and (bn) simultaneously, although for a given (c) they will never be at the same x or t value.

>>12691

Hello everyone!

Ok, so here's the key values we need to calculate a[-(d-1)] and a[cN] in R100.

d = 39020571855401265512289573339484371018905006900194

e = 61218444075812733697456051513875809617598014768503

N = 761302513961266680267809189066318714859034057480651323757098846024549192056136964455981270339102876

c = 1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139

to get the a[t] value at location a[-(d-1)] we need to use (x ^ 2 + e) / 2

(d-1) ^ 2 = 1522605027922533360535618378132637429718068114961241429070121879315400928060760053102344942663437249

(d-1) ^ 2 + e = 1522605027922533360535618378132637429718068114961302647514197692049098384112273928911962540678205752

((d-1)^2 + e) / 2 = 761302513961266680267809189066318714859034057480651323757098846024549192056136964455981270339102876

so this ^^ is our a[-(d-1)] value for (a).

a[cN] = 1159163035527489297252269855748911245456985761764844452273019692547376719952718746900975791334864896860941730129573747284683693577098289638054481691680548132250078131478572544813505933684401944555764

>>12700

This ^ is a[cN] / a[-(d-1)] = (c)

Hang on. It looks like I simply found the mirrored value of a[N].

I'll double check, and if it's a bust, I'll get back to brainstorming.

>>12698

>N = 761..

Value doesn't check out? Can ping from your programming thread for tools/checks and will take a look.

nN = (1+c)/2 - d = ((d-1)^2 + e) / 2

That's seems useful form.

And a Grid Property:

For all Odd 'c', 'dm1sqpe' is Even.

c=6107

nN = 2976

dm1 = 77

dm1sq = 5929

dm1sqpe = 5952

dm1sqpediv2 = 2976

>>12685

>Remember Chris' hint "where is the first appearance of c?"

Had read and noted that crumb with recent enumeration, and seeing your post wanted to come back to it and dig more.

Believe understand the meaning though not 100% how to use it as/in a Step. Will get back with example.

An observation though, as am reminded VA of your post some time ago of an Indiana Jones moment, taking a Step of faith.

While Time has passed, it seems with each crumb worked deeply, put in its place on a broadening map, that less faith is needed.

The grid and its rules, once enumerated and generalized, has yet to disappoint.

>>12705

>Interesting detail:

>Same layout as our alternate formula for the (x+n)^2 area:

>xx + 2xn + nn

>New formula to explore:

>((e+1)/2) ^ 2 +(2 * ((e + 1)/2) * (f /2) )+ ((f-2) ^ 2)

= (d+1) ^ 2

Same type of formula, but this one describes (d+1)^2 instead of (x+n)^2

Just wanted to clarify to avoid being confusing.

>For c145, that hypotenuse would be 1^2 + 1^2 = sqrt(2)

To clarify, this was a quick calc for c145, e=1

So the small square would be ((e+1)/2) ^ 2

And the larger square would be (f/2) ^2 = 144

To find the hypotenuse of the small square would be sqrt(1^2 + 1^2) = sqrt(2)

Chris' recent posts about sqrt(2) brought this to mind.

Not sure how important this is, but writing it down anyways.

>>12705

>Ok, visualize the old MS Paint that Chris gave us.

Definitely! Noting 'case' classification: "d square plus e where e is odd and d is even"

>(e+1)/ 2 because e is odd. And f/2 because f is even.

Did you double-count the corner "ONE"?

Intend to do a bit of work later, perhaps the case classifications (types, sub-types based on parities). Import for, and brilliant reminder to:

>.. Sheeeeeit … think on geometry.