Bitcoin puzzle transaction ~32 BTC prize to who solves it

[brainless]

A solution, sort of a hint.
Have any of you studied G point throughly? It has some interesting characteristics, it was generated by someone we don't know anything about, other than that, N also is interesting and you should research both N and G.

One other thing is the concept of adding and multiplying G by k, which obviously is not what I thought, I always assumed that if G is 5, and k is 20, we'd just multiply 5*20=100 =p. Well that was a misconception from my part.

Now instead of wasting your time doing useless stuff, start doing some research and experiment on elliptic curve.

Worth mentioning that almost 99% of you are unaware that bitcoin elliptic curve is a mirror. Now that you know, you should study the mirror verse to see what cool stuff are lurking there. Good luck and happy hunting.


I just wanted to shock Satoshi for a second. Are you shocked?🤣 .

This is true.


First private key
000000000000000000000000000000000000000000000000000000000000000000000000000001
EC Point
             x:79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
             y:483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
Last private key
115792089237316195423570985008687907852837564279074904382605163141518161494336
EC point
             x:79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
             y:b7c52588d95c3b9aa25b0403f1eef75702e84bb7597aabe663b82f6f04ef2777

You learned this after 15 years....?
These are basics,

[TheMissingNTLDR]

A solution, sort of a hint.
Have any of you studied G point throughly? It has some interesting characteristics, it was generated by someone we don't know anything about, other than that, N also is interesting and you should research both N and G.

One other thing is the concept of adding and multiplying G by k, which obviously is not what I thought, I always assumed that if G is 5, and k is 20, we'd just multiply 5*20=100 =p. Well that was a misconception from my part.

Now instead of wasting your time doing useless stuff, start doing some research and experiment on elliptic curve.

Worth mentioning that almost 99% of you are unaware that bitcoin elliptic curve is a mirror. Now that you know, you should study the mirror verse to see what cool stuff are lurking there. Good luck and happy hunting.


I just wanted to shock Satoshi for a second. Are you shocked?🤣 .

This is true.


First private key
000000000000000000000000000000000000000000000000000000000000000000000000000001
EC Point
             x:79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
             y:483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
Last private key
115792089237316195423570985008687907852837564279074904382605163141518161494336
EC point
             x:79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
             y:b7c52588d95c3b9aa25b0403f1eef75702e84bb7597aabe663b82f6f04ef2777

If you go to Learnmeabitcoin website, Insert the value for x in integer format, type any integer e.g. 111 in for y value, then an error will be displayed and the correct expected 2 values of Y will also be displayed to the user.

[eggsylacer]

A solution, sort of a hint.
Have any of you studied G point throughly? It has some interesting characteristics, it was generated by someone we don't know anything about, other than that, N also is interesting and you should research both N and G.

One other thing is the concept of adding and multiplying G by k, which obviously is not what I thought, I always assumed that if G is 5, and k is 20, we'd just multiply 5*20=100 =p. Well that was a misconception from my part.

Now instead of wasting your time doing useless stuff, start doing some research and experiment on elliptic curve.

Worth mentioning that almost 99% of you are unaware that bitcoin elliptic curve is a mirror. Now that you know, you should study the mirror verse to see what cool stuff are lurking there. Good luck and happy hunting.


I just wanted to shock Satoshi for a second. Are you shocked?🤣 .

This is true.


First private key
000000000000000000000000000000000000000000000000000000000000000000000000000001
EC Point
             x:79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
             y:483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
Last private key
115792089237316195423570985008687907852837564279074904382605163141518161494336
EC point
             x:79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
             y:b7c52588d95c3b9aa25b0403f1eef75702e84bb7597aabe663b82f6f04ef2777

My idea is to create local symmetry within a symmetric elliptical curve.
For example, if we take points S1 = G and S2 = -G, start adding to S1 + G and subtracting from S2 + (-G), and take Y(S1) mod 2, Y(S2) mod 2, and construct sequences from the remainders, we will obtain sequences 1111101100 and 0000010011, which are symmetrical to each other.
Let's assume we can define “symmetry” for small ranges, for example, there is a range 2^10 - 2^11, the center of the range is (2^10+2^11)/2, the center is 0 and 1, let's start counting from the center +G and -G and take Y(P) mod 2 from these points and build a sequence, we will get sequences that are not symmetrical to each other, but they themselves are scalars of points symmetrical relative to the center of the range.
If we can determine from these two sequences which one belongs to the left or right side relative to the center, then we can do the same with a random point in the range. That is, there is a point A = G*k, where k = [2^10, 2^11-1], then point B = G* (2^10+2^11) - A, we construct sequences from Y(A) mod 2 and Y(B) mod 2, and determine which point from A, B lies on the “left” or “right” side.

[farou9]

My idea is to create local symmetry within a symmetric elliptical curve.
For example, if we take points S1 = G and S2 = -G, start adding to S1 + G and subtracting from S2 + (-G), and take Y(S1) mod 2, Y(S2) mod 2, and construct sequences from the remainders, we will obtain sequences 1111101100 and 0000010011, which are symmetrical to each other.
Let's assume we can define “symmetry” for small ranges, for example, there is a range 2^10 - 2^11, the center of the range is (2^10+2^11)/2, the center is 0 and 1, let's start counting from the center +G and -G and take Y(P) mod 2 from these points and build a sequence, we will get sequences that are not symmetrical to each other, but they themselves are scalars of points symmetrical relative to the center of the range.
If we can determine from these two sequences which one belongs to the left or right side relative to the center, then we can do the same with a random point in the range. That is, there is a point A = G*k, where k = [2^10, 2^11-1], then point B = G* (2^10+2^11) - A, we construct sequences from Y(A) mod 2 and Y(B) mod 2, and determine which point from A, B lies on the “left” or “right” side.

where did you bring those binary sequences , and what are relying on that y somehow gives you a symmetry relation if you make it mod a number

[Xal0lex]

-snip-

where did you bring those binary sequences , and what are relying on that y somehow gives you a symmetry relation if you make it mod a number

This account has been inactive for almost a year. Plus, it's been banned. So it won't be able to respond to you. Before commenting on such old posts, I recommend checking the account profile for activity.

[kTimesG]

If we can determine from these two sequences which one belongs to the left or right side relative to the center

All the points are a center of some range

All the points can be used as generators relative to one another.

There's no "left" and "right" or "center", just the distinct set of unique points that create a cycle once you pick one of them as a generator.

So, the only thing you'll get is statistical uniformity. Unless of course, the curve's broken.

[farou9]

-snip-

where did you bring those binary sequences , and what are relying on that y somehow gives you a symmetry relation if you make it mod a number

This account has been inactive for almost a year. Plus, it's been banned. So it won't be able to respond to you. Before commenting on such old posts, I recommend checking the account profile for activity.

i mistakenly deleted the wrong post owner in the quote section when i was writing my response the post i replied to is from
eggsylacer

[eggsylacer]

My idea is to create local symmetry within a symmetric elliptical curve.
For example, if we take points S1 = G and S2 = -G, start adding to S1 + G and subtracting from S2 + (-G), and take Y(S1) mod 2, Y(S2) mod 2, and construct sequences from the remainders, we will obtain sequences 1111101100 and 0000010011, which are symmetrical to each other.
Let's assume we can define “symmetry” for small ranges, for example, there is a range 2^10 - 2^11, the center of the range is (2^10+2^11)/2, the center is 0 and 1, let's start counting from the center +G and -G and take Y(P) mod 2 from these points and build a sequence, we will get sequences that are not symmetrical to each other, but they themselves are scalars of points symmetrical relative to the center of the range.
If we can determine from these two sequences which one belongs to the left or right side relative to the center, then we can do the same with a random point in the range. That is, there is a point A = G*k, where k = [2^10, 2^11-1], then point B = G* (2^10+2^11) - A, we construct sequences from Y(A) mod 2 and Y(B) mod 2, and determine which point from A, B lies on the “left” or “right” side.

where did you bring those binary sequences , and what are relying on that y somehow gives you a symmetry relation if you make it mod a number

G - generator point.
The first sequence is constructed based on adding point to point G:

Code:

A = G
ABitSeq = ''
for i in range(10):
    ABitSeq += str(A.y % 2)
    A += G
ABitSeq -> 0000010011

The second sequence is constructed in exactly the same way, but starts from point -G and adds point -G instead of G:

Code:

_G = -G # (G.x, -G.y % P)
B = _G
BBitSeq = ''
for i in range(10):
    BBitSeq += str(B.y % 2)
    B += _G
BBitSeq -> 1111101100

The sequences will be symmetric because operations on Y values are performed modulo P, which means that "-Y mod P" and "Y mod P" are symmetric with respect to each other and their center.

I assume that this symmetry will be preserved in smaller ranges, but I apply it to scalar of points. And since we perform this operation in small ranges relative to the range N, the symmetry itself will not resemble the symmetry that is usually discussed. Most likely, it will be a symmetry with its own conditions.

[farou9]

My idea is to create local symmetry within a symmetric elliptical curve.
For example, if we take points S1 = G and S2 = -G, start adding to S1 + G and subtracting from S2 + (-G), and take Y(S1) mod 2, Y(S2) mod 2, and construct sequences from the remainders, we will obtain sequences 1111101100 and 0000010011, which are symmetrical to each other.
Let's assume we can define “symmetry” for small ranges, for example, there is a range 2^10 - 2^11, the center of the range is (2^10+2^11)/2, the center is 0 and 1, let's start counting from the center +G and -G and take Y(P) mod 2 from these points and build a sequence, we will get sequences that are not symmetrical to each other, but they themselves are scalars of points symmetrical relative to the center of the range.
If we can determine from these two sequences which one belongs to the left or right side relative to the center, then we can do the same with a random point in the range. That is, there is a point A = G*k, where k = [2^10, 2^11-1], then point B = G* (2^10+2^11) - A, we construct sequences from Y(A) mod 2 and Y(B) mod 2, and determine which point from A, B lies on the “left” or “right” side.

where did you bring those binary sequences , and what are relying on that y somehow gives you a symmetry relation if you make it mod a number

G - generator point.
The first sequence is constructed based on adding point to point G:

Code:

A = G
ABitSeq = ''
for i in range(10):
    ABitSeq += str(A.y % 2)
    A += G
ABitSeq -> 0000010011

The second sequence is constructed in exactly the same way, but starts from point -G and adds point -G instead of G:

Code:

_G = -G # (G.x, -G.y % P)
B = _G
BBitSeq = ''
for i in range(10):
    BBitSeq += str(B.y % 2)
    B += _G
BBitSeq -> 1111101100

The sequences will be symmetric because operations on Y values are performed modulo P, which means that "-Y mod P" and "Y mod P" are symmetric with respect to each other and their center.

I assume that this symmetry will be preserved in smaller ranges, but I apply it to scalar of points. And since we perform this operation in small ranges relative to the range N, the symmetry itself will not resemble the symmetry that is usually discussed. Most likely, it will be a symmetry with its own conditions.

the only thing that is symmetric is the x values not the y values , the connection between the y values are not symetric its just that they are two partsof the same number p where when you subtract one of y or -y from p you get the other , what is the symety of y you are talking about

[eggsylacer]

If we can determine from these two sequences which one belongs to the left or right side relative to the center

All the points are a center of some range

All the points can be used as generators relative to one another.

There's no "left" and "right" or "center", just the distinct set of unique points that create a cycle once you pick one of them as a generator.

So, the only thing you'll get is statistical uniformity. Unless of course, the curve's broken.

I rely not on the mathematics of elliptic curves, but on the general theory/rules/laws of numbers.
For example:

Code:

M1 = 2**10
M2 = 2**11
x = random.randint(M1+1, M2-1) # random number from M1+1 to M2-1
y = (M2+M1)-x # Y symmetrical with respect to X

Now we know with 100% probability that one number from x and y lies in the range from M1 to (M1+M2)/2, and the second number lies in the range from (M1+M2)/2 to M2.

Now let's apply this property to curves.

Code:

M1 = 2**10
M2 = 2**11
x = random.randint(M1+1, M2-1) # random number from M1+1 to M2-1
A = G*x # Suppose that point A lies in the range from M1 to M2.
B = G*(M1+M2) - A

Now, from the code above, we know with 100% probability that the scalars(in binary form) of points A and B are symmetric with respect to each other, symmetric with respect to their center((M1+M2)/2), and symmetric with respect to field M2+M1 (since G*(M1+M2) - A = B, and G*(M1+M2) - B = A)

My idea is to create local symmetry within a symmetric elliptical curve.
For example, if we take points S1 = G and S2 = -G, start adding to S1 + G and subtracting from S2 + (-G), and take Y(S1) mod 2, Y(S2) mod 2, and construct sequences from the remainders, we will obtain sequences 1111101100 and 0000010011, which are symmetrical to each other.
Let's assume we can define “symmetry” for small ranges, for example, there is a range 2^10 - 2^11, the center of the range is (2^10+2^11)/2, the center is 0 and 1, let's start counting from the center +G and -G and take Y(P) mod 2 from these points and build a sequence, we will get sequences that are not symmetrical to each other, but they themselves are scalars of points symmetrical relative to the center of the range.
If we can determine from these two sequences which one belongs to the left or right side relative to the center, then we can do the same with a random point in the range. That is, there is a point A = G*k, where k = [2^10, 2^11-1], then point B = G* (2^10+2^11) - A, we construct sequences from Y(A) mod 2 and Y(B) mod 2, and determine which point from A, B lies on the “left” or “right” side.

where did you bring those binary sequences , and what are relying on that y somehow gives you a symmetry relation if you make it mod a number

G - generator point.
The first sequence is constructed based on adding point to point G:

Code:

A = G
ABitSeq = ''
for i in range(10):
    ABitSeq += str(A.y % 2)
    A += G
ABitSeq -> 0000010011

The second sequence is constructed in exactly the same way, but starts from point -G and adds point -G instead of G:

Code:

_G = -G # (G.x, -G.y % P)
B = _G
BBitSeq = ''
for i in range(10):
    BBitSeq += str(B.y % 2)
    B += _G
BBitSeq -> 1111101100

The sequences will be symmetric because operations on Y values are performed modulo P, which means that "-Y mod P" and "Y mod P" are symmetric with respect to each other and their center.

I assume that this symmetry will be preserved in smaller ranges, but I apply it to scalar of points. And since we perform this operation in small ranges relative to the range N, the symmetry itself will not resemble the symmetry that is usually discussed. Most likely, it will be a symmetry with its own conditions.

the only thing that is symmetric is the x values not the y values , the connection between the y values are not symetric its just that they are two partsof the same number p where when you subtract one of y or -y from p you get the other , what is the symety of y you are talking about

I didn't just give an example of constructing a binary sequence for no reason. Take a closer look at these two sequences (they are symmetrical to each other).

If we follow your logic, then the values of x are not symmetrical; they are literally identical.

[SRG02289]

1PWo3JeB9SyEuPyjoqKm2Ur6xUNJigqkmF

1PWo3JeB9d5CYrv5dzc4P8cr59ibFRMZMf

1PWo3JeB9sYfCE3gqL4LADHDLuhtr3kFH3

1PWo3JeB9Xa4x6UjH5tqGTkb8WE6H9MJuv

1PWo3JeB9UnXe1CR3K7rEt9te92E6SBH5p

1PWo3JeB9HvP415UbBEyMW9VEkUj619KGD

1PWo3JeB9NmXAKPPnPLNnuEo5pLCKASzs9

1PWo3JeB9JykV7ixxyAr8QfTQWFRN7THDJ

1PWo3JeB9tWXkfLAyxnnq6ykiBXAv4g5nc

still nothing guys

1PWo3JeB9jakyr87nZvq34SGhWNMvDbay4

1PWo3JeB9jFakrTGTTdpsB24cxtmyf6Nu6   02E5B40D7EC2177AF5F182EC29D66123B028F8DACAE9620083562600056501A5CC

[Mafioso246]

1PWo3JeB9SyEuPyjoqKm2Ur6xUNJigqkmF

1PWo3JeB9d5CYrv5dzc4P8cr59ibFRMZMf

1PWo3JeB9sYfCE3gqL4LADHDLuhtr3kFH3

1PWo3JeB9Xa4x6UjH5tqGTkb8WE6H9MJuv

1PWo3JeB9UnXe1CR3K7rEt9te92E6SBH5p

1PWo3JeB9HvP415UbBEyMW9VEkUj619KGD

1PWo3JeB9NmXAKPPnPLNnuEo5pLCKASzs9

1PWo3JeB9JykV7ixxyAr8QfTQWFRN7THDJ

1PWo3JeB9tWXkfLAyxnnq6ykiBXAv4g5nc

still nothing guys

1PWo3JeB9jakyr87nZvq34SGhWNMvDbay4

1PWo3JeB9jFakrTGTTdpsB24cxtmyf6Nu6   02E5B40D7EC2177AF5F182EC29D66123B028F8DACAE9620083562600056501A5CC

Between 40x and 477x, there are two addresses with the prefix 1PWo3JeB9jr. If you fully scanned that range, I’m curious could you tell me one of them?

[kTimesG]

All the points are a center of some range

I rely not on the mathematics of elliptic curves, but on the general theory/rules/laws of numbers.

Yeah those rules won't help much at all, they're pretty much, by themselves, the basis of why they do the exact opposite of helping. Have you heard of the Discrete Logarithm Problem?

Here, let's simply find the symmetric point of some arbitrary point P which is in some known range:

Q = P - (minKey + rangeSize/2) * G      // move center from range middle to 0 / point at infinity
Q' = {Q.x, p - Q.y}       // math magic because of symmetry!

So now Q and Q' are both in a symmetric range of the exact size as the original.

No need to mess around with weird binary sequences, all the points are now symmetrical (everything on the left side is symmetric to everything on the right side).

Now, your question is simple: let's see where Q stands relative to the center (e.g. relative to [-G, G]): left or right? If it's left, then Q' is on he right. If it's right, then Q' is on the left.

Good luck solving that problem. It's been asked for around 50 years or so.

[eggsylacer]

All the points are a center of some range

I rely not on the mathematics of elliptic curves, but on the general theory/rules/laws of numbers.

Yeah those rules won't help much at all, they're pretty much, by themselves, the basis of why they do the exact opposite of helping. Have you heard of the Discrete Logarithm Problem?

Here, let's simply find the symmetric point of some arbitrary point P which is in some known range:

Q = P - (minKey + rangeSize/2) * G      // move center from range middle to 0 / point at infinity
Q' = {Q.x, p - Q.y}       // math magic because of symmetry!

So now Q and Q' are both in a symmetric range of the exact size as the original.

No need to mess around with weird binary sequences, all the points are now symmetrical (everything on the left side is symmetric to everything on the right side).

Now, your question is simple: let's see where Q stands relative to the center (e.g. relative to [-G, G]): left or right? If it's left, then Q' is on he right. If it's right, then Q' is on the left.

Good luck solving that problem. It's been asked for around 50 years or so.

Yeah, this will give us a point whose scalar is the distance from the center of the range to the point. After performing the operation module -Y mod P on this point, we obtain a symmetric point relative to a group of points of size N. But I am talking about symmetry relative to the scalar of the point in the specified range, not the entire range from 1 to N. In any case, if we are looking for a solution, we need to look outside the system of elliptical curves.

Also, I have another idea. Example:

Code:

StartP = G
referenceBitSeq = bitarray()

for _ in range(2**15):
    referenceBitSeq.append(StartP.y % 2)
    StartP += G

Thus, we obtain a bit sequence where 1 bit of memory is assigned to each point.
Now, if we take a random scalar point from the range 1 to 2^15 and construct a bit sequence in the same way and compare it with the reference sequence (whether this sequence is in the reference), we can determine whether this random point is in the given range.

Code:

randScalar = random.randint(1, 2**15)
findP = randScalar*G

findBitSeq = bitarray()
for i in range(40): # The more bits (the longer the bit sequence), the more accurate the verification will be
    findBitSeq.append(findP.y % 2)
    findP += G

state = next(referenceBitSeq.search(findBitSeq), None) is not None
print(state)

As far as I understand, the complexity will be O(M*N). M - reference sequence length; N - length of the sequence being checked.
Of course, we must be sure that the scalar of the point is between 1+N and 2^15-N.
In essence, this can be improved by implementing a more efficient mechanism for searching for a bit string in a string. However, the issue remains in generating a massive reference bit string, which will take up a significant amount of memory, and the search will take considerably longer.

[kTimesG]

Yeah, this will give us a point whose scalar is the distance from the center of the range to the point. After performing the operation module -Y mod P on this point, we obtain a symmetric point relative to a group of points of size N. But I am talking about symmetry relative to the scalar of the point in the specified range, not the entire range from 1 to N.

The range has the same size in both cases. However, the only ever symmetric-ensuring range center you will ever find is for inexistent scalar 0 (which is, the neutral element, which doesn't exist on the curve).

In essence, this can be improved by implementing a more efficient mechanism for searching for a bit string in a string. However, the issue remains in generating a massive reference bit string, which will take up a significant amount of memory, and the search will take considerably longer.

The computational complexity skyrockets when "storing" a single point using a single bit, and trying to do those matches requires multiplying the total number of group operations by a factor, which invalidates any computational savings whatsoever. This has been discussed already.

[coinableS]

I’ve been testing some of the older/easier puzzles using three different rigs with a VanitySearch mod one fast, one medium, and one painfully slow. What’s interesting is how big the luck component is once you’re searching large spaces. What I mean is the fast machine doesn't always solve the puzzle the fastest or even at a predictable lead or gap ahead than the others. Luck, for lack of a better word, seems to matter more then pure guesses once you get up to the larger spaces.

You’d think raw speed would always dominate, but past a certain point it's almost like a lottery. The slow rig can get lucky and land something early, while the fast one goes dry for a while.

Makes me think the winner of Puzzle 71 might just be whoever the randomness smiles on that day.

[zLuoManhwas]

I’ve been testing some of the older/easier puzzles using three different rigs with a VanitySearch mod one fast, one medium, and one painfully slow. What’s interesting is how big the luck component is once you’re searching large spaces. What I mean is the fast machine doesn't always solve the puzzle the fastest or even at a predictable lead or gap ahead than the others. Luck, for lack of a better word, seems to matter more then pure guesses once you get up to the larger spaces.

You’d think raw speed would always dominate, but past a certain point it's almost like a lottery. The slow rig can get lucky and land something early, while the fast one goes dry for a while.

Makes me think the winner of Puzzle 71 might just be whoever the randomness smiles on that day.

I completely agree, the space where the key is located is gigantic. I wonder who solved 69 and how they did it.
I've been looking at this forum for months and trying different methods. I took the last 36 keys and extracted patterns that haven't been seen in the keys. According to my calculations, there are approximately 500 million left. I don't know if anyone has an idea to improve the one I'm presenting. And don't gamble 100% on the lottery with puzzle 71

[Bitcoin71]

The inventor of this puzzles name is In this hash 41932e0d52a2b1e171d28f6b442981137790bcbf1d72201bea441f36fd7ba67b I just want to say, Hi, ⁤⁣⁤‍⁡‍‍⁣‍⁡‌⁢‍⁤⁡⁢⁡‍⁡‍⁢⁣‍‌‍⁢‍⁤⁡⁢⁡⁢⁡‍‌‌⁡‍‌‍⁢‍⁡‌⁡‌⁡⁤‍⁤⁡⁤⁣‌⁢‌⁡‍‍‌⁢‍⁤⁡⁢‍⁢⁡‍‌‌⁡‌⁡‌⁢‍⁤⁡⁢‍⁡⁢‍⁤⁡⁢⁡⁢⁡‍‍⁣‍⁡⁤‍⁤⁡⁢‍⁣‌⁡⁤‍‌‍Hello

[sxiclub]

I’ve been testing some of the older/easier puzzles using three different rigs with a VanitySearch mod one fast, one medium, and one painfully slow. What’s interesting is how big the luck component is once you’re searching large spaces. What I mean is the fast machine doesn't always solve the puzzle the fastest or even at a predictable lead or gap ahead than the others. Luck, for lack of a better word, seems to matter more then pure guesses once you get up to the larger spaces.

You’d think raw speed would always dominate, but past a certain point it's almost like a lottery. The slow rig can get lucky and land something early, while the fast one goes dry for a while.

Makes me think the winner of Puzzle 71 might just be whoever the randomness smiles on that day.

I completely agree, the space where the key is located is gigantic. I wonder who solved 69 and how they did it.

Puzzle 69 was solved quickly because the answer was only 0.72% from the start of the range; in this case, it was simply solved by the first person among all those who started a sequential search from beginning to end.

[kTimesG]

I’ve been testing some of the older/easier puzzles using three different rigs with a VanitySearch mod one fast, one medium, and one painfully slow. What’s interesting is how big the luck component is once you’re searching large spaces. What I mean is the fast machine doesn't always solve the puzzle the fastest or even at a predictable lead or gap ahead than the others. Luck, for lack of a better word, seems to matter more then pure guesses once you get up to the larger spaces.

I highly disagree. If you run those puzzles over long runs (thousands of tries) you will find the solution sooner or later every single time, but, on average, it is very clear that what emerges is the expected average solve time (relative to a rig's speed of course) which is right at 50% of maximum work needed. And that expected average solve time will naturally double up for every incremental puzzle, it is not jumping all over the place, as you suggest. Thus, the "luck factor" as you call it, also halves every time the search space doubles.