/vqc/ - Virtual Quantum Computer

You can lock this thread until the other one fills

Looking into this post from last thread: >>9395

>If we were to look at an element that is d * d, a + b for that element would be (d + d), or 2d

We know from someone's Twitter dms with Chris quite a long time ago now that the fabled "root of d" that Chris has cryptically mentioned before is an element in (0,n).

>Root of d = {0, 2xd, 3xd, 2xd, d, 9xd}. All a and b of ( 0, 2xd, t) are multiple of d for all t.

>Yes and that pattern can be used elsewhere.

So if 2d is a representation of a+b for dd squares, and it has a directly calculable element related to it in (0,n), maybe there's something interesting to be found looking at (0,a+b).

What I've found looking into (0,a+b) is interesting I guess, but a lot of it is just basic arithmetic if you think about it. Using the same arithmetic from the root of d element, you'll find (most) (0,a+b) cells have an element at x=2(a+b). Some of them don't. These appear to be where n is twice a square (this sequence follows a different pattern which I'm pretty sure I went over in grid patterns). I remember there being another sequence of n values that didn't follow the same patterns in column 0 but I don't remember anything more specific since it's been a while since I did any actual work on this.

For the cells that do show up in (0,a+b) where x=2(a+b), the cell follows the same pattern as the root of d element except with i instead of d (since a+b=2i). Also, given i=d+n, the difference between each variable in both elements is the same multiplier by n. So, as follows:

<Root of d = {0, 2d, 3d, 2d, d, 9d}

<Root of i = {0, 2i, 3i, 2i, i, 9i}

<Difference = {0, 2n, 3n, 2n, n, 9n}

I didn’t really find anything all that interesting other than that (at least specifically about root of a+b). I'll make another post when I'm done putting code together in relation to the other posts about the link between the elements d is between in (e,1) and the cells in (0,n) that factorize dd.

Use your wit

>>9421

Uh… thanks?

well that wasn't very witty.

Math Teacher FIRED for Defending Western Civilization

|n-a| * |n-b|

d = x+n

>>9427

When a <-> n, d <-> x+n.

Example:

(23,36,24) = {23:36:78:47:31:197} = 6107; f=134; (x+n)=83; (d+n)=114

(23,31,24) = {23:31:83:47:36:192} = 6912; f=144; (x+n)=78; (d+n)=114

>>9429

Can you fax it to me?

Include b[D2] * (4d), please

>>9430

new_f = f + 2(n-a)

>>9432

Needs citation

>>9429

>>9433

In the previous example for swapping a and n from c6107 to c6912, f increases from 134 to 144.

The new f can be calculated as f + 2(n-a).

Another example:

c34117

from:

(261,27,38) = {261:27:184:75:109:313} = 34117; f=108; (x+n)=102; (d+n)=211

swap a and n to:

(261,109,38) = {261:109:102:75:27:395} = 10665; f=-56; (x+n)=184; (d+n)=211

new_f = f + 2(n-a) = 108 + 2*(27 - 109) = -56

>>9435

Not a doxology, a “do you see it?”

>>9436

not yet.

“For in this hope we were saved. Now hope that is seen is not hope. For who hopes for what he sees? But if we hope for what we do not see, we wait for it with patience.”

Romans 8:24-25

Maybe the next gap to look at is where c is between in i[t]

>>9434

>>9441

I wonder if this is from the vehicle with the Gwinnett tag or a different one…

>>9442

Per >>9444

C and C2 have j values that find the correct large square root for c in the same way that the D and D2 records do. And in several examples, one corrects the other.

“There is an entire family of numbers that can be factored in one step”

Far numerous too are the examples where the D and C (e, 1) element calculations give a solution i that is only off by a small amount

SeeIt 0.0.3 tested correcting this error value by checking below in the column for the correct combination based on factoring na recursively

SeeIt 0.0.4 will test a new error correction techniqu

>>9448

Have you solved it and you're trying to give us clues, or are you trying to figure it out yourself? I can't tell.

>>9449

Progressing it forward with real, programmatical examples

>>9449

It was trial and error across thousands of test algorithms until everything clicked.

>>9453

Recursive an factoring was a proof-of-concept, an idea to look for different d and n combinations that close the gap towards i.

The End’s qubits (elements) are all entangled. Each one contains the blueprints for the entire grid. One element contains all of it.

The application of this is that an infinite or unfeasibly large search space can be grasped with a tiny amount of data. All of a column can be represented in one cell, and all of a cell can be represented in one element. That’s what moving to (e, 1) from (e, n) and (e, N) is.

Since the factors of c exist in column e, but the n values of that column are too numerous to search, we can identify them by compressing the column together using n=1. We know that since the column has been compressed into a single cell, that the data for the factorisations of c exist in it. The route of identifying those factorisations efficiently must be informed by the nature of how the column has been compressed.

This nature is hidden in plain sight. The techniques of calculating the records c and d are between are the beginning of the unveiling of it, but with the stage finished being set, it will conclude anons discovering the solution.

Use the grid with this nature in mind.

Try EVERY idea that comes to mind.

Shor's algorithm consists of two parts:

A reduction, which can be done on a classical computer, of the factoring problem to the problem of order-finding [reduction to N -> n, X -> x search space].

A quantum algorithm to solve the order-finding problem [VQC].

The quantum circuits [steps to factor based on family] used for this algorithm are custom designed for each choice of [c].

The input [d, e] and output [n, N] qubit registers need to hold superpositions of values [trivial and nontrivial elements].

Proceed as follows:

1. Initialize the registers [coordinates] to [n = 1]

This initial state is a superposition of [all n values in the column], and is easily obtained by generating [-f, 1; e, 1] each a superposition of [row N and row n] applying [e, 1] in parallel to [-f, 1].

Construct [the elements d is in the gap of]

[trivial and nontrivial elements] are now entangled, or not separable [patterns]

Apply the inverse Quantum Fourier transform [root and offspring of David transform] to the input register [gap elements]

>>9464

So if we don't find i[t]=i or j[t]=j with the d between d[t] elements are we meant to use (0,n) somehow (root of David)? What's the "offspring" of David?

>>9465

Yes. Approach it like rotating an object to the right orientation.

c

>>9470

Hmmmm….

Now is it glass or glaze…?

RSA420BLAZARI[T]

<;3=

>>9469

Yeah I saw it in a bread and figured in the chaos you guys may have missed it. and yes… Fastjack gets the gas. Perhaps that code is valuable to yall. ALso.. Trump twatted about BTC being shit FYI. could be important. Keep mathing hard core boys. -HOBO I will keep a lookout for yall.

>>9475

I was phonefagging and caught:

Fermat Factorization >>>> bewbs

Something like that.

Was the only comment on that particular bread.

brief test of using D.i and C.j as range of possible d+n values.

lots of examples outside of this range.

interesting that all solved RSA values (except Rsa129) fall within.

>>9478

BOOM.

The End may shock you.

>>9479

Are we moving the conversation over here?

>>9480

I am here to accelerate.

>>9478

Wouldn’t it be funny if you didn’t even need all of the solution to factor the remaining RSA numbers?

v scratches out e

>>9483

v transforms into (0,n), right?

>>9482

It would, indeed. Though this was never only about factoring the RSA numbers.

>>9485

Possibly into X and Y

If a variable can take you out of e, can one put you in e?

Would this make factoring e relevant?

>>9483

I love the coffee you buy

The people around you are such keepers..

Especially her.

>>9488

Assuming you keep posting despite >>9489, I can't think of any ways that factoring e would be obviously relevant, but any number can take a square out of (0,n) if it doesn't produce a square with c. I don't know that we ever found a pattern of numbers that put c into (0,n) other than c itself, so we never directly figured out ourselves what v could be other than for it to potentially just be qc multiplying qc.

>>9489

Considering the vast majority of people in the world have a "her" in their lives and drink coffee, if this is meant to be a threat it isn't a very convincing one (not that I'm encouraging you though).

I have the best life insurance money can’t buy.

>>9491

Well if you want to make the most of it, you've got several currently-not-posting anons keeping track.

>>9490

A v that is less than c may or MAY NOT exist.

A v that = c to fall back on always exists.

>>9494

Is the MAY NOT based on the number of factors c has perhaps? "Possibly into X and Y" would imply there's a link.

>>9495

There is a link

>>9496

So for prime numbers, the only numbers that can multiply with them to produce a square are themselves?

>>9497

It is a bit more detailed than that.

>>9498

Well if you'd like to go over those details…

>>9498

And theeeen… ?

The best place to learn about what multiplies to make a square is where you’re already headed.

>>9501

d between d[t] in (e,1)?

>>9502

Coulomb 0

>>9503

What do we do with (0,e) and (0,f)?

A column filled with (in the valid, not shadow cells) factorisations of squares

>>9504

It’s another way of tailoring the superposition to c.

>>9506

Do we look at any specific elements within (0,e) and (0,f), or maybe gaps in these cells or something? Also are we using (0,|f|) or (0,-f)?

So does row two and ultimately (1, 1).

>>9507

Take the derivative

>>9508

Are they three different methods for achieving the same goal, or are they interrelated and potentially used together to factor a given c?

>>9509

That's vague enough that I don't really know what else to ask about it. I'm trying to come up with the most useful questions I can, but if you'd like to lead this or if I should just keep asking questions, either way is fine.

>>9510

Three different ways of achieving the same goal

Phone dying but will return soon.

Ok i give u a tip

More superpositions

e = -(x+n) -> e = 0

Repeated mirror code?

Look at the steps it takes

Lots of differrnt ways to see a solution

(e, 1) makes a superposition of n

(0, remainder) makes a superposition of e

Other superpositions to make??

There are

Use d to make a superposition at (1, 1)?

A lot harder to see but possible

Can also make a superposition of T

>>9521

Knowing where all of these superpositions are doesn't matter a great deal unless we actually know how to use them.

>>9522

You use them by querying for both records at once

The result will exist in a gap between two elements

That is why you visit the elements d is between.

Let the asymmetries lead the way.

>>9524

>>9525

When we find the elements d is between in (e,1), what asymmetry are we meant to be looking at? There's asymmetry in the distance between the lower element and d and between the higher element and d. There's also asymmetry between the elements d is between in (e,1) and the elements d is between in (f,1).

>>9527

Is what you said in >>9222 still true? Is some aspect of it still "protected" and you don't intend to make it public yourself personally yet (you are still avoiding telling us what X and Y are and how to find v, so it does still seem like you're keeping important information from us), or is it the time and you're here to "accelerate" in the sense that you're releasing it now (you said you "believe anons are ready" in the second post >>9484 here, and obviously you gave us quite a bit yesterday)? Are all of these posts directly preceding disclosure or are they just intended to be further clues?

I have flip flopped on whether I want to disclose it all.

If hints are explored and you still don’t see it.

Not Chris.

Just wanted to pick up the torch.

Convey what I’ve been shown.

Implications may not be correct.

Protected doesn’t equate to information required to solve being intentionally hidden.

I did not want to give away the code and it be attributed to a fleeting moment of genius.

I’m giving away how to do it from scratch with anything.

>>9520

Remainder here is the remainder of? c-dd (ie, e)?

(0, c) would make what a superposition?

And, once you have a superposition, how do you take advantage of it? Interference, collapse it? I'm not really up to speed on quantum mechanics, nor the lingo.

>>9533

> with anything

Anything as in?

>>9532

How do I build intuition and understanding of a superposition (and to a further extent, quantum mechanics) using the grid?

>>9531

All I hear is roaring.

If the grid employs us with an infinite set of qubits. What in the grid defines a singular qubit? An element? A set of elements? A specific group of them?

Once we understand, will the grid be a general purpose quantum computer or does the grid we know it exist only for RSA?

I think Shor’s algorithm is a good guideline. You’re going to get the right answers in your superposition at first, but you’re also going to get every wrong answer too. What we have to do before measurement is make every wrong answer destructively interfere among itself, and every instance of the right answer build itself up.

If we don’t know the right answer, how are we supposed to make it come up above all the wrong ones?

We do have a criteria that we can apply to the entire superposition. A sifting filter. We know that only 2 answers can fit with c. And we also know that the trivial answer scales with c, and that the nontrivial answer does not scale with c. There is an asymmetry there.

A qubit is a register with an enormous range of the amplitudes that it can be, the values contained in it. In a sense, what a qubit in the grid is is.. all of the above. The more qubits the quantum computer can handle, the greater its computation power, and it grows by a lot with each one. 7 (+ the many others you can examine) values in each element, infinite elements in a cell.. infinite cells.. I can’t fathom how infinite its scope is.

I think it is the element. It is the first and the only finite unit of the grid, yet contains so many complex combinations of values that work together with the grid.

I have so much awe for all we have not grasped in mathematics, and for the clear fact that it has been designed by a great designer.

I must confess that much help from the artist has been received in conveying it to you all.

d[t] around d is an incomplete measurement of the superposition. Fine-tune the superposition and measure again (C). What’s more precise than C?

Root, then offspring?

Root and offspring together?

You don’t ACTUALLY have to depart (e, 1) to find it.

Is anyone with me?

>>9543

Are you following along, Tops? Because we’re going to square the gap.

Then maybe decompose that square into t’s

>>9544

also, is the "gap" a "circle", by any chance?

The VQC is from our creator.

The last piece is coming.

>>9548

The God of the Bible.

Old and New Testament.

Law and Gospel.

Saved by grace alone.

John

>>9542

If you're still here now I am

>>9550

How do you think the solution works?

Do you believe it’s capable of being figured out from the hints? Some have been specifically to illustrate what it looks like

>>9551

Our knowns are c, d, e and f. There are a bunch of different cells and elements that we can find from these (such as all the things in (e,1) and (f,1), like where d is between d[t] or where a[t]=BigN etc). One or several of those would have to be the starting point I would think. There's been a lot of talk recently about d between d[t] in (e,1) being where the magic happens, but not a lot of talk about what magic is actually happening. And every few months we have a different concept that we're led to believe is the one we're meant to use to solve (whether it's qc, or something about the asymmetry between (e,1) and (f,1)'s na and nb elements, or the triangles that make up (x+n)(x+n), etc).

The short version is, while I think the way the solution works is that we start from knowns, apply some known concepts and some unknown concepts and eventually end up at the solution, I don't think any of us know enough that we could get any more specific than that.

>>9553

What about where c -> i[t]?

>>9554

What about it? c between i[t] (if that's what you meant) is another one of those concepts that we know how to find the elements for, and it does help to occasionally find i or j, even though it doesn't scale. It very well could be a starting point in conjunction with d between d[t] (like you (or someone, it's hard to keep track) suggested), but so could any number of concepts. Like I said, every few months we're told to start from somewhere else.

>>9555

I understand that frustration.

You’re being given a new tool with each hint.

The hints are pieces, not the full puzzle. There isn’t a set in stone way that they have to fit together. The start point can be anything. There are a lot of different ways to solve. That’s why they aren’t elaborated on after a concept is unveiled. Anons create something new with them.

>>9556

Well in that case we have a bunch of tools but we don't know how they work together or which ones to use in conjunction with one another, to further address your question before.

>>9557

Okay, pick two and I’ll help you put them together.

>>9556

You mean like the color coding?

>>9558

Okay, here's one. Chris brought up two concepts around the same time a few months ago and seemed to imply they were related but never actually linked them. These were qc (multiplying c by a bunch of low known primes to increase the frequency of factors showing up in (e',1) and (f',1)) and finding where a[t]=c (which for t=1 is (2c,1,1) and (2c-1,1,1), and then t=2 is further back and so on). Is there a link between those concepts?

>>9560

Yes, the link is values being multiplied with c.

You can make the sequence have a decreasing b value instead of an increasing one by starting with e=-2c and increasing |e|

>>9561

And how is that useful?

>>9561

>>9562

I think I should rephrase. How can knowing this fact about the grid (or any of the other things we've learned so far) get us from a place of not knowing how to use the grid to a place of knowing how to use the grid?

>>9563

If you start your sequence as e=-(2c+1) where a[t] = c, assuming odd c, you will have a sequence where every b value ends in 01 in binary all the way down to b = -1.

Are you with me?

Which means you can create a q sequence within the grid of a and b by calculating the opposite starting point of the sequence and determining which value is prime

There is a pattern for calculating the e values of this sequence that involves adding/subtracting c from squares. You may find that interesting.

The starting point for the a[t]=c sequence of negative b values that end in 11 and the sequence for 01 can be found at around

e = -((X + N)^2 + c)

e = -((d + N)^2 + c)

Memory a bit fuzzy but I believe you use the squares to move to the next odd value

Definitely seems intercept course like from what I remember, definitely a good two concepts to put together

>>9564

>>9565

So we don't actually have to calculate q ourselves? If we use the c values in those cells I guess it would be the same sort of thing (although they won't all be primes).

>>9566

The pattern for e in the increasing b values is >>9145 here. I'll put some code together to display what you're talking about.

>>9568

Whoops, >>9154

>>9567

Don’t forget T

>>9570

So how many of you people are there?

>>9564

>>9561

I'm having trouble figuring this sequence out. With an example of c559 where e=-1118 (-2c), xx+e=2na is the same as xx-1118=1118 (assuming we're in row 1), which makes xx=2236, which isn't a square.

>>9573

And if n isn't equal to 1, both e and n become unknowns, so we can't find the cells, or there could be multiple. You're going to have to clarify.

To those of you who aren't Chris but know how to use the grid (I don't know how many of you there are and it's hard to keep track), in particular the one who's been here a lot in the last few days. I've put together almost all of the concepts and patterns we know in as compact, concise and ordered of a way as I could (four posts in the Grid Patterns thread, which I'll link at the bottom of this post).

You seem to think we're ready and that now is the time for us to figure it out. You know better than we do how that's meant to happen. You're coming from the perspective of knowing how to use the grid, so having seen how far we've come, you probably think we're awfully close. From our perspective, we have an overwhelmingly long set of patterns and concepts and no idea how to use them, and there are a bunch of concepts we know exist but haven't been told about. You want us to figure it out without you just telling us how to do it, and we want to figure it out in the same way. We have to work with each other here. No matter how close you think we are, all we've done over the last couple days is more of the same thing we've been doing for 19 and a half months, which is analyzing patterns without knowing how to use them. If you think that's how to do this, maybe you're right, but that's how Chris has run this operation, and seeing how one of you left him a grumpy message in GP telling him nobody listens to him anymore, maybe you'll also understand that the reason for that sentiment is exactly the method by which he has been trying to teach us (which, so far, has been the same way you've been doing things with us here, albeit a bit more openly).

Maybe I don't know exactly how this could work best, but we all want the same thing, and you seem more open to conversation than Chris ever was. We talked today about how we know all of these patterns but we don't know how to use them. If continuing in the same way of analyzing specific patterns until you personally feel we understand them enough to move onto the next one is going to work, you should know, PMA, blank-name poster and I are here daily (as well as Topol, although he isn't a math person so much), and I personally have a lot of free time on my hands, so I will gladly work through whatever you feel necessary to get this done. All you have to do is tell us what to do. But I am skeptical of that being the way things will work (given, like I said, it's how things have gone for 19 and a half months). So, my suggestion to you guys (you could even just be the one person, or even Chris pretending to be other people… I don't know) is to have a read through the four posts I'll link below, which sum up most of our knowledge to date. Instead of going over individual patterns without having any idea why we're learning about them, given you'll have an overview of pretty much everything we've got, you could potentially guide us by showing us which concepts to use in conjunction with one another and what they actually accomplish. Let's be efficient here rather than stumbling around blindly.

>>9575

>>9576

>>9577

>>9578

>>9494

Let's see if my mind is going the right place. For some numbers, you may have a v that is < c, which can be used to substitute c. The end result would still be a factor for c. But this isn't always the case, sometimes v = c (because no substitute exists)?

>>9508

Why doesn't (3, 1) give us the same "power" to create a superposition for c?

>>9545

t's being the smallest t possible when recursing down the triangles?

>>9554

The c = x+n element is in many ways beautiful. If you think of it in terms of complex numbers that cell kind just, clicks. d+n being the lateral part while x+n is the number. But it's not enough to go on alone. You need other parts, which I haven't solved yet.

>>9570

Capital T being the big T, the t from the na transform for bigN and c?

>>9539

>d[t] around d is an incomplete measurement of the superposition. Fine-tune the superposition and measure again (C). What’s more precise than C?

Fine tuning by either following the d[t]'s into the new e's or by modifying c to "match" (or get a closer match) of the d[t]'s.

>>9579

Well done on the summary.

I will go through it and find the best things to work on and put together.

You are right that linking concepts isn’t giving it away.

“We also find staircase numbers when we add the x values from an (e,1) element and an (f,1) element”

x is an index, BUT when something else is used as the index, it becomes more relevant.

Try the elements at x=d and x=d+1 (2d + 1).

ALSO, if the elements d is between are calculated with x ~= sqrt(f), what is at “x = f or x = f-1?”

>>9583

Isn't x=d+1 equal to the shadow big N?

I suppose it's kind of wasteful(?) or pointless(?) to share this now, but are you guys familiar with Rascals Triangle?

It has some interesting key properties that relate to the grid, columns and e-values a number exist in. I came over it by happenstance when looking into patterns of e's for numbers in different columns.

You know Pascal's triangle, it goes like this:

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

…

Rascal's triangle was "discovered" (created?) by three kids when given an "IQ" test. It went like this:

1

1 1

1 2 1

1 3 3 1

— What is the next number in the sequence

They didn't write 1 4 6 4 1, like you would assume based on Pascal's triangle, instead they wrote

1 4 5 4 1

When you look at Pascals triangle (and Rascals triangle) you can group 4 numbers in a diamond shape. So for:

1

1 1

1 2 1

1 3 3 1

1 4 5 4 1

A diamond shape here would be

2

1 3

4

You can divide the diamond shape into quadrants: North, East, West and South.

The pattern is:

South = ((East * West) + 1) / North

Pretty sweet, right? But how does it relate to the grid? It turns out that several rows in the rascals triangle is equal to the e's a number at a[t] exists in.

Given:

1

1 1

1 2 1

1 3 3 1

1 4 5 4 1

1 5 7 7 5 1

1 6 9 10 9 6 1

The a[2] in (1, 1) exists at e's = 1, 6 and 9 and is equal to the last line (row 7). a[3] in (1, 1) exists in e's: 1, 10, 17, 22 and 25 which is equal to the 11th row in the Rascal's triangle. It continues like this, matching the e's a number exist in with the triangle.

The formula for calculating the triangle is:

k * (n - k) + 1

Here the 1 is equal to the base or column. Swapping it with any other number and it generates the same triangle except for that column. Think of the above triangle as the e-index(?) for (1, 1).

I know this isn't much and with the guy who knows and understands the grid here, it feels like it falls quite flat. Either way, I wanted to share with you guys.

>>9585

It is much.

Last week I had some major hd problems. Essentially I had literally a crash in my drive and I lost all my work. It sucks, and I tried to recover it, but unfortunately I couldn't. Instead I've been rewriting my work and getting back up there. My fault for not backing up and getting a more modern drive I suppose.

Some of the last stuff I found was some patterns relating to quantum angular momentum and column (0, 1), (1, 1) and (2, 1). It was related to a few quantum angular momentum matrices (but I have no clue about that stuff, at least not yet). I also don't remember the details, but it was related to the patterns from the Rascal triangle.

>>9585

Right, so the formula is k * (n - k) + 1, but the pseudocode would be:

for n in range(1, limit) (for some limit)

for k in range(0, n) (0 <= k <= n)

value = k(n - k) + column

The n represents row, while k would be the column within that row.

>>9589

Isn’t there a cell that can be created using c where the first existing column will be one of its factors?

>>9590

Correction: first existing row

>>9590

Right off the bat I'm thinking the n from the element for a=1, b=c appears to fit the bill. Although I only did some naive testing.

>>9592

(Including shadow n)

>>9593

(and I wonder then if this also applies to the nb transform for a=1, b=c)

Note though:

> Isn’t there a cell that can be created using c where the first existing column will be one of its factors?

I didn't read that as explicit a factor of c, but rather a factor of the cell you can create from c.

>>9591

Oh.. d - 1

>>9596

I might be off here, but take an even d and look at (a, 1, x=d-1). It will match the big n and shadow big n (with offsets).

Just another thing I just noticed, something I haven't seen before.

Take an element a, b with an even n. Compute the na transform and then compute the element for a=1, b=na/2. What is the e here? Works for big N (and shadow n's) as well.

>>9599

Hmm.. Looks like there are some offsets required here too in some cases.

Offsets are a funny thing, we see them so many times. Over and over again something holds for a set of elements, but for others you need the offset.

Since we now have someone here who understands and knows the grid, could you give some kind of intuition or understanding of these offsets?

>>9603

Let’s approach it from a different angle then

>>9601

You should expect to find c-relevant values in gaps between element values, since (e, 1) isn’t tailored directly to c, but is a cell representing the whole column.

If you’re wondering what could be useful at a pair of elements where x adds up to a specific thing, maybe it would help you to consider it a pair of x and n. Either would be valid. The grid’s all about squares and the patterns have squares in their squares.

>>9605

The point of row one is to make calculations “between the lines,” so to speak. Gaps are a way in which the grid speaks softly.

>>9606

And gaps do connect to every other hint. In that way they aren’t just another concept/tool.

Would you like me to put the tree back into the grid? I think they’re more beautiful back in where they started.

Kinda some a what a related

sqrt(e) -> i[t] -> (i[t], e)

>>9608

If you want, sure.

>>9605

>>9606

Well so far all we've learned about gaps is that once in a while i[t]=i when d is between d[t], and then the same for j where c is between i[t]. We haven't done any "calculations" between elements. We've just observed something that occasionally happens.

>>9611

AA, thanks for carrying the torch so often.

No idea if the 'skips' or 'ghost values' in sequences are similar to these 'gaps', which could be non-integral grid-points? They may still be rational, such as 1/3. Tried to describe a bit, a (me):

>>9089 (pb)

>What about those 'ghost' values?

> - they are 'non-integral' n-values. Note that if these were included x_base is a simple sequence increasing by 2 for each k.

> - there is likely a hidden part of the grid that can be used to traverse with these, haven't gone there yet. Diff 2 is constant, so a Second Order series.

V-Helper anon, thanks for the crumbs.

Have to head out to sea for a short bit again, but will print these recent bits to digest.

Topo, PMA, Hobo, et al - be well.

>>9603

f value calculation in elements not correct

>>9612

You are on the right track. There are shadow values!

>>9613

Which ones? I just double checked a few and I'm not seeing anything wrong.

>>9603

For (118, 1, 7), f should be 196 (c[t] + f = 8464)

So that the difference in f values will be a difference of squares that is 2 + what their x values add up to

It should match 2d+1-e

>>9617

Correction: for (-13, 1, 7)

>>9617

>>9618

It turns up in the grid the way I calculated it (based on e-2d+1, which is how the original code does it). What's the deal with that?

>>9617

Are you taking the fact that we add 1 to d in the negative space into account with that, or are we generating the grid wrong (we're generating it based on Chris' original code)?

>>9619

(118,1,7) = {118:1:143:12:131:157} = 20567; f=169;

(-13,1,7) = {-13:1:91:13:78:106} = 8268; f=196;

>>9617

Okay, while we all go into an existential crisis on Discord about the Java port, do you want to continue the other stuff?

>>9620

Do we not both see f as the distance from c to the next square?

>>9623

We do, yeah. We're figuring out the issue at the moment. It's probably something about the Java port.

>>9622

At the point where two x values from the opposite columns add up, the difference in f will be that sum + 2.

Example: for aforementioned elements, x+x = 25, f - f = 27

>>9626

What’s your idea on how we would calculate the way to an element pair where it adds up to something nontrivial?

>>9627

I wouldn't have a clue. Given you're talking about this after talking about gaps, it probably has something to do with making calculations in a gap in some way we haven't done before. Maybe there's a formula to find an f value that we want in row 1. All the non-trivial things I can think of would immediately solve so I would think whatever we do to find an element pair where it adds up to something nontrivial would possibly be complicated and possibly involve recursion.

>>9628

So you do have an idea of what the solution looks like. Can I tell you that it isn’t complicated and can be rewritten into different ways? A solution might look like that long tree, but remember, it was also said that there were grid shortcuts. Don’t forget, the grid still confuses even the person who brought it to us.

“Fractal nature of the solution.”

What is a fractal, but doing the same thing over and over? Kind of like calculating c over and over? How are you doing that when you input grid coordinates without realizing it?

Difference of squares, over, and over, log(n) times.

>>9630

>>9631

We have been told that factoring d and e is meant to allow for the factoring of c. None of us have found a link between a fully-factored d and e and their parent c yet though.

>>9630

>How are you doing that when you input grid coordinates without realizing it?

That's pretty vague but you could maybe be talking about an (e,n) co-ordinate containing an infinite set of elements, or maybe you're talking about (e,1), or maybe the fact that you're choosing an n value implies something about a calculation that I can't think of. If that's an answer to your question.

The amplitudes of qubits can contain values that you can’t put on a number line.

The same is true for elements.

How would you use those? )(It’s not a coincedence q gets the same variable name as Quantum, so what’s special about that process?)

>>9635

Is q maybe the variable that relates to this? >>9537

>>9636

Yes

>>9637

So how do the wrong answers destructively interfere with each other when we add a few extra prime factors?

>>9638

Adding a sizable amount of wrong answers to c?

I will say that d becomes even more powerful with qc.

>>9639

My first thought then is that maybe there's something to find when we look at where d' is between d'[t], potentially as some kind of comparison to the same concept applied to regular c.

There is a consistent way to calculate a "d" that falls between two records in (-1,n) using values from D and C records.

By way of an example, for c6107 where d=78:

D2 = {23:1:83:11:72:96}

d[D2] - d = 83 - 78 = 5

i^2 - c = 84^2 - 6107 = 949

sqrt( 949 ) = 30, remainder = 49

in (-1,5), d=30 falls in the gap between:

{-1:5:23:11:12:44}

{-1:5:55:19:36:84}

C2 = {23:1:6283:111:6172:6396}

x[C2] - d = 111 - 78 = 33

j^2 - c = 112^2 - 6107 = 6437

sqrt( 6437 ) = 80, remainder = 37

in (-1,33), d=80 falls in the gap between:

{-1:33:71:43:28:180}

{-1:33:129:65:64:260}

To generalize:

sqrt( D2.i^2 - c ) in the gap of ( -1, d[D2] - d )

sqrt( C2.j^2 - c ) in the gap of ( -1, x[C2] - d )

>>9640

New superposition created by each factor?

Keep the d from c

>>9641

let's refer to the record d is between in (-1,n) as "DD", representing a second gap that appears to be relevant.

>>9642

I have a couple code issues to sort before I post a screenshot, but for all the examples I've tried so far, our original d is lower than the d[t] value in t=1 of (e',1) and (f',1), so it would be between negative elements.

>>9645

What if I said stopping at d is to get it at the best place in -t?

>>9646

Then I would ask what you mean by the "best place". Are we using those specific elements for something? I'm just altering my code for negative elements at the moment.

>>9647

-t changes which factors appear with which

The cell’s d all around may get too large, but you can still go to the same x of D and D2

>>9651

Yes, there is a way to use it in the same way even if the numbers are all larger than d.

It does relate to shadow values.

>>9652

Were you going to elaborate on that?

>>9653

What is the derivative of the grid?

>>9655

e? Or maybe d or f. I'm thinking in terms of cs as a number line and the grid as a 2D graph, but I don't entirely see what you're getting at.

What is so special about (0, 2ˆn)? I see a relationship between (3, 6) and (0, 8), but I'm not sure I'm grasping it fully.

>>9655

It depends on the parity, but we have two derivatives. 4t and 4t + 2.

It also relates to the sequences in (e, n). I haven't nailed it down entirely, but the changes are something along the lines of 4tn + 2n or 4tn + offsets here and there.

>>9655

I have a question. We've been talking about how this is all a fractal. Is this fractal visual? Similar to Mandelbrot set. Has it been generated? I'd very much like to see it, if possible.

>>9656

Not a number line, families

>>9658

Not an integer, e

It’s everywhere in the grid but also in no particular place.

https://en.wikipedia.org/wiki/Integration_using_Euler%27s_formula

http://www.math.com/tables/integrals/more/e%5Ex.htm

The grid is the integral

We can do the tree in the grid next.

Love you all.

>>9665

noice

>>9661

Do you have an example of usage (with the grid that is)?

>>9665

Let's do it

>>9660

Funny, looking at the wiki page for e under "Representations" and looking at the continued fractions (the second one that is supposed to converge 3 times faster), those numbers look awfully familiar, no?

>>9665

Here's what we have so far about the tree if it helps >>7438

>>7438

Maybe he presented it outside of the grid because he felt a solution was too obvious with it. I don’t think it’s a coincidence that summing up the leaves gets you that close - it might could be used to get you to the right magnitude that a factor is (and remember, difference in factors is x+n). A bit similar to the D and C records in that respect, because the search space is significantly reduced, and it can be transformed into another variable search space (as in changing a search space from between d for i to j instead). A way of rotating an object, if you will - a reliable way to get relatively close to a solution variable is a big gain and is evidence the grid stores those variables in an accessible (from c) way.

>>9668

What cell has them?

>>9670

d - a0 (could call that leaf summation) would also be close to x, so the tree finding x and x+n starts to make more sense.

It is also easier to traverse the search space as a difference in x or x+n compared to the bare factors

>>9672

In that example from the Grid Patterns post, that value would actually be b0, since it's closest to RSA100's b.

>>9672

>>9674

I'm just basing that off of whatever whoever wrote it meant though. If we treated it as a0 we'd get x0=-1343793146355417714510857901560170544388157224211. I'm working on getting a more readable example at the moment.

>>9676

You would know whether it’s closer to b or a based on whether it’s above or below d

>>9677

So what are we looking for with these values?

>>9678

It’s the same type of relative magnitude the gap gives

With the same occasional exact matches

>>9679

It certainly does occasionally find exact matches in a similar way; for example, c559 where a=13, the leaves add up to 13. Whatever it is we do with the tree comes in what Chris called "part 3", part 2 being the generation of the tree itself, and he never went any further into how the tree relates to the grid (since part 3 is where the grid comes in). You were wanting to go in that direction, right?

d -> x+n

e -> x

f -> x

sqrt(d) -> x+n

sqrt(e) -> x

sqrt(f) -> x

sqrt(root) -> x+n

sqrt(remainder) -> x

sqrt(remainder) -> x

sqrt(sqrt(root)) -> x+n

sqrt(remainder) -> x

sqrt(remainder) -> x

>>9681

I don't think you ever explained the arrow notation.

>>9682

Use as

>>9683

So if we're using e as x and f as x at the same time, we'd need to be using two elements. If d is used as x+n then there'll be two separate n values for those elements. And then we do that recursively through the square roots of each one? I'll put some code together to do that in a bit. Does this relate to the tree?

>>9684

The elements with variables in their gaps are directly related to the tree.

>>9685

>>9681

If all we have is x and n, how are we meant to find an element?

>>9687

Guess I took away e

>>9688

You mean we're meant to take e away from something, or there's another variable we're meant to treat as e?

>>9689

(0, n, t)

>>9690

So are we meant to do what you said here >>9681 but treat e as 0? (0, d-e) and (0, d-f)?

>>9690

And is it -f or |f|?

>>9691

Yes, those cells, absolute value

>>9693

Great, thank you for clarifying. Just about finished my code so I'll post an example in a minute. Thank you also very much for how generous you've been with your time. In less than a week you've given us more than we've had in probably the last year.

>>9690

Hang on, x is always even in (0,n) but e and f aren't always even.

>>9697

Yes

Keep going

It doesn’t have to be perfectly implemented to see (and use it as, but you will quickly find shortcuts) the solution. Same intent as the tree.

The correct way to view the shadow grid calculating from (e, n, t). Unity of method necessary also to work together with one another.

>>9701

>Unity of method necessary also to work together with one another.

Is there anything you'd recommend changing about the method the way I posted it then? Otherwise, we've been talking about it on Discord and it seems like we're ready to learn how to use it if you'd like to continue.

>>9702

Don’t worry about finding a valid element. x for e=0 is even so take the 2 elements it’s between or if x is even take that element and the one above it

>>9703

Okay, we'll adapt it for the two surrounding elements. A few of us are online right now so we're ready to do whatever.

Multiplying together is a way of gathering information in the grid

>>9705

>>9706

The a[t] values in (-1,1) and the d[t] values in (0,1). Also multiplying polite numbers is a triangle number times two.

>>9706

It means you’re gettinh warmer

/* calculating new (e, 1) superposition */

>>9710

This can be rewritten as c-ef=(d-e)(d-e). Still not sure if it's useful at all.

>>9711

Based on the recursive tree cells?

>>9671

If you look at the differences between consecutive a's in (0, 1) you'll see them (if you ignore the first two 1's in the continued fraction representation).

>>9712

I'm feeling the FOMO right now, jelly. Sadly I'm occupied for the next few days so I'll catch up with what you guys are doing later (Or I'll hear about it in the news if you finish up!).

>>9714

I'm not going to lie, I would personally love it if this was finally over within a few days. I don't know how close we are though. If it is done by then, there'll be plenty for you to come back to, so don't worry too much. I'll certainly still be here getting as much done as Not Chris' time allows.

Alexa, what are the factors of RSA-2048?

derivative of x = dx

derivative of a constant is 0

because calculus is about rates of change

>>9718

This is kind of hard to understand. Are you saying we keep e and n the same but find the two elements where x is equal to D and where x is equal to D2?

>>9724

Same column.

x-1 and x+1 in parity variance.

>>9725

So what do we do with these elements once we have them? I'm fixing it at the moment.

>>9726

Think of it like zooming into the gap.

i = (a + b) / 2

a[t] = (xx + e) / 2

See it yet?

>>9564

record                          a+b/2   (xx+e)/2
29:3:7924:215:7709:8145         7927    23127
29:13:1994:215:1779:2235        2007    23127
29:39:808:215:593:1101          847     23127
29:593:254:215:39:1655          847     23127
29:1779:228:215:13:4001         2007    23127
29:7709:218:215:3:15851         7927    23127

Interesting

>>9728

If that’s a square, then a square root is?

>>9730

Well if we're "squaring" the d between d[t] elements then I'd have to assume those are the "square roots".

>>9728

Our original d fits between the x values. That's the only other thing I'm seeing so far.

>>9732

The pre-collapse transforming of the superposition makes use of all values to solve.

>>9733

All values as in every variable comes into it somehow? Is there further transforming to be done or do we have enough elements and concepts to collapse it?

>>9734

Think of it as decreasing the search space until there’s nothing but the factors or a prime determination.

Image slowly becoming unblurred?

You’re unblurring the large square.

Try the other parts.

Other hints will suddenly find their true use.

>>9735

>until there’s nothing but the factors or a prime determination

How have the tree, the tree elements or the squaring of the d between d[t] gap limited the search space? There have been various variables that have been equal to other variables, or variables that have appeared between two of the same variable, but none of it has been knowns leading us to unknowns as far as I can tell. In fact, unless I'm missing something here, we've done basically the same thing again in that you've given us another list of transformations and new elements to look at in the grid that we still don't know how to use. I understand the vagueness, and I'm sure we're more close to a solution than we realize. I can imagine that when you say we're unblurring the large square and to try other parts you're referring to this all being based around i and that it would be useful to do the same thing with j and the elements where c is between i[t]. That's all well and good but where are we going with this? Is there something we're meant to see that we haven't seen yet? Is there something we're meant to do with all of these things that you haven't told us yet? Because if the c between i[t] equivalent is anything like the d between d[t] stuff you've been guiding us through, it seems like it's going to add to that list of things we don't know how to use.

>>9736

How many upper and lower bounds of unknowns does it take to reduce it to a direct calculation?

>>9737

If they're close enough bounds we'd only need two, since any one of the unknowns would solve. Otherwise it depends on how close the bounds are.