/vqc/ - Virtual Quantum Computer

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.