Bitcoin puzzle transaction ~32 BTC prize to who solves it

[Feron]

66 was solved quickly, no one complains that they were stolen, so it looks like the person who solved 66 took his rightful reward and the bot didn't get anything

[albert0bsd]

66 was solved quickly, no one complains that they were stolen, so it looks like the person who solved 66 took his rightful reward and the bot didn't get anything

I don't think so, nobody will accept that public shame

[kTimesG]

any reason why solver make same transaction amount as creator of puzzle deposited and same two transaction

0.59400000 BTC= -5.94000000BTC , 0.06600000 BTC=-0.66126013 BTC
why same way just little difference due to fee?   SOLVER=CREATER ?

If I give you a 10 $ bill and you go to the store will you pay by giving out the bill, or do you magically transform that paper into 1 cent coins and pay using those? Doesn't sound like you know how BTC works fundamentally. Unspent outputs have a fixed amount attached, consuming same amount is by design...

[COBRAS]

any idea for puzzel 67

Yes.

Wait until someone solves it and then steal the coins with a bot.


Funny, but throw.

[opciga]

The person who created the puzzle is making fun of us

[COBRAS]

with the way the data is stored it does not require a complex decompression system (it is not a compression algorithm) it is a system designed exclusively for searching for public keys, therefore it is handled by the search script as if you put 10 public keys in a text file to give a basic example, as for how many public keys could it store until being affected by the size of the db, well, it will depend on the reading capacity in large files, however in a 1gb file you would have approximately 2,621,400,000,000 pubkeys, you need more gb without losing reading speed, we could adapt a bloom filter .. but this is only an initial version of an idea that can be improved over time.

Any form of processing that uses less input bits than the output bits (or viceversa) is a (de)compression algorithm. I can claim that we can use a single bit to cover 2**256 public keys. 1 = all keys tried, 0 = not all keys tried, but it's not really a public key database. So when you say you can store 100 M public keys using just 655360 bits (80 kB), maybe there's some fine print over that statement, since not even the most optimal possible data structure (some optimal tree of sorts that uses every bit as a node value, and you walk along the tree to read or return some string of bits) can't store 25.6 billion bits of information using only 700k bits. At least not without critical trade-offs like very lossy/wrong results, or extremely slow operations. What's the use-case?

What happens is that you take the idea to your own needs, and you get confused because you are looking for a use to something that you do not know how it is used, in the context of my scripts is that I give the data, now that the same DB does not work For Kangaroo or Bsgs maybe if not, but that does not destroy the main idea.

I think you need take official registered a USA or EU patent to you DB. This will be protect your Idea from stealing and maybe give some money. Then you have a patent, can try sell your method to google, microsft etc.

[madogss]

I think you need take official registered a USA or EU patent to you DB. This will be protect your Idea from stealing and maybe give some money. Then you have a patent, can try sell your method to google, microsft etc.

Agreed this DB will be especially useful for space and medicine with how far AI has come we could use mcdouglasx's db to store a detailed brain scan or a 3d map of a galaxy and train AI on the db so it could piece together the data and we could ask it questions about the data like does this scan have a blood clot or a misfiring neuron or map the most efficient trajectory to this planet and it could answer but instead of taking up petabytes or even exabytes of storage it would take a fraction of that. Of course right now your db is specifically for public keys but its the idea that matters if you could apply it to different areas that would be game changing.

[saeedxxx]

I don't think so, nobody will accept that public shame

It's strange that the real finder doesn't show up or send any post too!

[AlanJohnson]

I told you it was a one big waste of time ...

You have one ilfe and wasting it in such a stupid way...

[nomachine]

Where is that guy who claimed that the puzzle 66 is 100% between 61000000000000000000 and 70000000000000000000 ?

Well, my friend, puzzle 66 is at 46346217550346335726 

[random3425]

if we know two x axis but don't know their private keys but know that difference between their private keys is private key of desired address  can we take any advantage to reduce range? we also know the range of private key , i am new please help

[kTimesG]

I think you need take official registered a USA or EU patent to you DB. This will be protect your Idea from stealing and maybe give some money. Then you have a patent, can try sell your method to google, microsft etc.

Agreed this DB will be especially useful for space and medicine with how far AI has come we could use mcdouglasx's db to store a detailed brain scan or a 3d map of a galaxy and train AI on the db so it could piece together the data and we could ask it questions about the data like does this scan have a blood clot or a misfiring neuron or map the most efficient trajectory to this planet and it could answer but instead of taking up petabytes or even exabytes of storage it would take a fraction of that. Of course right now your db is specifically for public keys but its the idea that matters if you could apply it to different areas that would be game changing.

I don't believe a brain blood cloth is willing to wait some exponential time for a "binary" DB to be "scanned". The current state of practical technology uses bytes, words, 64-bit addressing and registers, because these are the actual smallest units of data that are being read or operated within a single clock cycle, by a CPU, controller, or whatever. Especially memory, the higher the bus width, the more data can be transferred per cycle.

Using 0 and 1s is already the basis of everything we use every day, and lots of things in CS make heavy use of them for memory-trips efficiency already, flags, algorithms, etc. but they DO NOT do this because it uses less data, they do it because IT IS FASTER. As a few already said before, "scanning" speed of said DB is sub-optimal to say the least, but hey, I'm no one to judge people's ideas. However, I must say it does not sound like something that any non-graduate CS student hasn't already "seen this, done that" as there are dozens of algorithms that do a much better job. This is why I asked about complexities or insert/update/query operations on said DB, otherwise it's not a DB but mangled packed bits, e.g. some compression output.

[Andzhig]

Well, it fell into an empty slot.

Imagine that we have a game cube with 64 sides and 160 throws, more throws means repetitions will occur. Next, for each of 64 we divide by 128, that is, we take a cube with 8192 sides so that there are no repetitions.

10000000000000000000000000000000 00000000000000000000000000000000 1   pz 2  
00000000000000000000000000000000 00000000000010000000000000000000 45  pz 3  
00000000000000000000000000000000 00000000000000000000001000000000 55  pz 4  
10000000000000000000000000000000 00000000000000000000000000000000 1   pz 5  
00000000000000000000000000000000 00100000000000000000000000000000 35  pz 6  
00000000000000000000000000000000 00000000000001000000000000000000 46  pz 7  
00000000000000000000000000100000 00000000000000000000000000000000 27  pz 8  
00000000000000000000000000000000 00000000000000000000001000000000 55  pz 9  
00000000000000000000000000000000 00000000000000000000000001000000 58  pz 10
00100000000000000000000000000000 00000000000000000000000000000000 3   pz 11
00000000000000000000010000000000 00000000000000000000000000000000 22  pz 12
00000000000000000000000000000000 00100000000000000000000000000000 35  pz 13
00000000000000000000000000000000 10000000000000000000000000000000 33  pz 14
00000000000000000000000000000000 01000000000000000000000000000000 34  pz 15
00000000000000000000000000000000 00000000000000000010000000000000 51  pz 16
00000000000000000000000000000000 00000000000000010000000000000000 48  pz 17
00000000000000000000000000000000 00000000001000000000000000000000 43  pz 18
00000000000000000000000000000000 00000000000010000000000000000000 45  pz 19
00000000000000000000000000000000 00000100000000000000000000000000 38  pz 20
00000000000000000000000000000000 00000000000000000010000000000000 51  pz 21
00000000000000000000000000000000 00000000000000000000010000000000 54  pz 22
00000000000000000000000000000000 00000000010000000000000000000000 42  pz 23
00000000000000000000000000000000 00000000000000000000010000000000 54  pz 24
00000000000000000000000000000000 00000000000000000000000000000010 63  pz 25
00000000000000000000000000000000 00000000000000000100000000000000 50  pz 26
00000000000000000000000000000000 00000000000000000001000000000000 52  pz 27
00000000000000000000000000000000 00000000000000000000100000000000 53  pz 28
00000000000000000000000000000000 00000000000100000000000000000000 44  pz 29
00000000000000000000000000000000 00000000000000000000000000001000 61  pz 30
00000000000000000000000000000000 00000000000000000000000000000100 62  pz 31
00000000000000000000000000000000 00000000010000000000000000000000 42  pz 32
00000000000000000000000000000000 00000000000000000001000000000000 52  pz 33
00000000000000000000000000000000 00000000000000000010000000000000 51  pz 34
00000000000000000000000001000000 00000000000000000000000000000000 26  pz 35
00000000000000000000000000000100 00000000000000000000000000000000 30  pz 36
00000000000000000000000000000000 00000000001000000000000000000000 43  pz 37
00000000000000010000000000000000 00000000000000000000000000000000 16  pz 38
00000000000000000000000001000000 00000000000000000000000000000000 26  pz 39
00000000000000000000000000000000 00000000000000000000000001000000 58  pz 40
00000000000000000000000000000000 00010000000000000000000000000000 36  pz 41
00000000000000000000000000000000 00010000000000000000000000000000 36  pz 42
00000000000000000000000000000000 00000000000000000001000000000000 52  pz 43
00000000000000000000000000000000 00000000000000000000001000000000 55  pz 44
00000000000000000000001000000000 00000000000000000000000000000000 23  pz 45
00000000000000000000000000000000 00000000001000000000000000000000 43  pz 46
00000000000000000000000000000000 00000000000000000000100000000000 53  pz 47
00000000000000000000000000000000 00000100000000000000000000000000 38  pz 48
00000000000000000000000000000000 00000000001000000000000000000000 43  pz 49
00000000000000000100000000000000 00000000000000000000000000000000 18  pz 50
00000000000000000000000000000000 00000000000000000000000001000000 58  pz 51
00000000000000000000000000000000 00000000000000000000000000100000 59  pz 52
00000000000000000000000000000000 00000000000010000000000000000000 45  pz 53
00000000000000000001000000000000 00000000000000000000000000000000 20  pz 54
00000000000000000000000000000000 00000000000000000001000000000000 52  pz 55
00000000000000000000000000000100 00000000000000000000000000000000 30  pz 56
00000000000000000000000000000000 00000000000000000000000000001000 61  pz 57
00000000000000000000000000000000 00000010000000000000000000000000 39  pz 58
00000000000000000000000000000000 00000000000000000000000001000000 58  pz 59
00000000000000000000000000000000 00000000000000000000000000000100 62  pz 60
00000000000000000000000000000010 00000000000000000000000000000000 31  pz 61
00000000000000000000000000000000 00000000000000000000100000000000 53  pz 62
00000000000000000000000000000000 00000000000000000000000000000100 62  pz 63
00000000000000000000000000000000 00000000000000000000000000001000 61  pz 64
00000000000000000000000000000000 00000000000000000010000000000000 51  pz 65
00000000000000000000000000000001 00000000000000000000000000000000 32  pz 66

...............x.x.x.xx..x...xxx xxxx.xx..xxxx..xxxxxxxx.xxx.xxx.                               pz 67

00000000000000000000000000000000 00000100000000000000000000000000 38  pz 70
00000000000000000000000000000000 00000000000000000000000010000000 57  pz 75
00000000000000000000000001000000 00000000000000000000000000000000 26  pz 80
00000000000000000000000000000000 00000000000000000000000000001000 61  pz 85
00000000000000000000000000000000 00000000000000001000000000000000 49  pz 90
00000000000000000000000000000000 00000000000000000000100000000000 53  pz 95
00000000000000000000000000000000 00000000000000000100000000000000 50  pz 100
00000000000000000000000000000000 00000000000000010000000000000000 48  pz 105
00000000000000000000000000000000 00010000000000000000000000000000 36  pz 110
00000000000000000000000000000000 00000000000100000000000000000000 44  pz 115
                                                                                                              pz 120
                                                                                                             pz 125

not yet dropped free sides from 1 to 15, 17 19 21 24 25 27 28 29 37 40 41 46 47 56 60 64

for example, 43, 51, 52, 53, 58, 61 have already fallen out 4 times.

sides not yet rolled in a 64-sided die (128 each for 8192)

***

pz 64
8192, 64/2 32 8192/2 4096, 8192/64 128,
7899
(√(2^63)/8192×7899)^2+2^63; 7899/128  hex(F7051F27B09112D4
[17798765725016391680  61,7109375 dec(17799667357578236628]

pz 65
8192, 64/2 32 8192/2 4096, 8192/64 128,
6640
(√(2^64)/8192×6640)^2+2^64; 6640/128;  hex(1A838B13505B26867
[30566001039707734016  51,875  dec(30568377312064202855]

pz 66
4146  
(√(2^65)/8192×4146)^2+2^65 46343414555177123840
                                            46346217550346335726
(√(2^65)/8192×4147)^2+2^65 46347973680141697024


(√(2^65)/8192×4146)^2+2^65; 4146/128
46343414555177123840 32,390625 46346217550346335726


***

free missing sides and possible space for pz 67

1-15
(√(2^66)/8192×129)^2+2^66;  8192/128 73805273267836026880
(√(2^66)/8192×1921)^2+2^66; 8192/128 77844439183633940480

17
(√(2^66)/8192×2177)^2+2^66; 8192/128 78997923638194208768
(√(2^66)/8192×2305)^2+2^66; 8192/128 79628709061002788864

19
(√(2^66)/8192×2433)^2+2^66; 8192/128 80295523280830332928
(√(2^66)/8192×2561)^2+2^66; 8192/128 80998366297676840960

21
(√(2^66)/8192×2689)^2+2^66; 8192/128 81737238111542312960
(√(2^66)/8192×2817)^2+2^66; 8192/128 82512138722426748928

24
(√(2^66)/8192×3073)^2+2^66; 8192/128 84170026335252512768
(√(2^66)/8192×3201)^2+2^66; 8192/128 85053013337193840640

25
(√(2^66)/8192×3201)^2+2^66; 8192/128 85053013337193840640
(√(2^66)/8192×3329)^2+2^66; 8192/128 85972029136154132480

27
(√(2^66)/8192×3457)^2+2^66; 8192/128 86927073732133388288
(√(2^66)/8192×3585)^2+2^66; 8192/128 87918147125131608064

28
(√(2^66)/8192×3585)^2+2^66; 8192/128 87918147125131608064
(√(2^66)/8192×3713)^2+2^66; 8192/128 88945249315148791808

29
(√(2^66)/8192×3713)^2+2^66; 8192/128 88945249315148791808
(√(2^66)/8192×3841)^2+2^66; 8192/128 90008380302184939520

37
(√(2^66)/8192×4736)^2+2^66; 8192/128 98448687854319042560
(√(2^66)/8192×4864)^2+2^66; 8192/128 99799767742530191360  

40
(√(2^66)/8192×5120)^2+2^66; 8192/128 102610013910009380864
(√(2^66)/8192×5248)^2+2^66; 8192/128 104069180189277421568

41
(√(2^66)/8192×5248)^2+2^66; 8192/128 104069180189277421568
(√(2^66)/8192×5376)^2+2^66; 8192/128 105564375265564426240

46
(√(2^66)/8192×5888)^2+2^66; 8192/128 111905443540902084608
(√(2^66)/8192×6016)^2+2^66; 8192/128 113580782602283909120

47
(√(2^66)/8192×6016)^2+2^66; 8192/128 113580782602283909120
(√(2^66)/8192×6144)^2+2^66; 8192/128 115292150460684697600

56
(√(2^66)/8192×7168)^2+2^66; 8192/128 130280130020573708288
(√(2^66)/8192×7296)^2+2^66; 8192/128 132315757052145172480

60
(√(2^66)/8192×7680)^2+2^66; 8192/128 138638810928973348864
(√(2^66)/8192×7808)^2+2^66; 8192/128 140818553148620668928

from the standpoint of probability, this doesn’t seem to mean anything, but you can try to look where else, according to this view

[Alienkenny]

Does anyone know the key for the puzzles from 161 to 256?
Someone on the forum claimed that there are known.

[nomachine]

from the standpoint of probability, this doesn’t seem to mean anything

Here is my prediction script. I have +- 0-40% deviations
With correction factor for puzzle 66
alpha = 2.7931615407112251695923857484645003617613050861

more decimals in correction factor more precise result

Code:

import numpy as np
from mpmath import mp
import argparse

# Set higher decimal precision for mpmath
mp.dps = 60  # Adjust precision as needed

# Target numbers (ordinal, value) 
target_numbers = [
    (1, 1), (2, 3), (3, 7), (4, 8), (5, 21), (6, 49), (7, 76), (8, 224), (9, 467), (10, 514),
    (11, 1155), (12, 2683), (13, 5216), (14, 10544), (15, 26867), (16, 51510),
    (17, 95823), (18, 198669), (19, 357535), (20, 863317), (21, 1811764),
    (22, 3007503), (23, 5598802), (24, 14428676), (25, 33185509),
    (26, 54538862), (27, 111949941), (28, 227634408), (29, 400708894),
    (30, 1033162084), (31, 2102388551), (32, 3093472814), (33, 7137437912),
    (34, 14133072157), (35, 20112871792), (36, 42387769980), (37, 100251560595),
    (38, 146971536592), (39, 323724968937), (40, 1003651412950),
    (41, 1458252205147), (42, 2895374552463), (43, 7409811047825),
    (44, 15404761757071), (45, 19996463086597), (46, 51408670348612),
    (47, 119666659114170), (48, 191206974700443), (49, 409118905032525),
    (50, 611140496167764), (51, 2058769515153876), (52, 4216495639600700),
    (53, 6763683971478124), (54, 9974455244496707), (55, 30045390491869460),
    (56, 44218742292676575), (57, 138245758910846492), (58, 199976667976342049),
    (59, 525070384258266191), (60, 1135041350219496382), (61, 1425787542618654982),
    (62, 3908372542507822062), (63, 8993229949524469768),
    (64, 17799667357578236628), (65, 30568377312064202855), 
    (66, 46346217550346335726)
]

def main(puzzle_number):
    # Extracting the ordinal (x) and values (y) up to the puzzle before the target puzzle
    if puzzle_number in [x[0] for x in target_numbers]:
        ordinals = np.array([x[0] for x in target_numbers if x[0] < puzzle_number], dtype=float)
        values = np.array([x[1] for x in target_numbers if x[0] < puzzle_number], dtype=float)
    else:
        # Use all available data for prediction if puzzle_number is not in the list
        ordinals = np.array([x[0] for x in target_numbers], dtype=float)
        values = np.array([x[1] for x in target_numbers], dtype=float)

    # Compute log of the values using mpmath for high precision
    log_values = np.array([float(mp.log(val)) for val in values], dtype=float)

    # Introduce weights to give more importance to recent values
    weights = np.linspace(0.5, 1, len(ordinals))  # Linear weighting

    # Perform linear regression on log(values) to fit the exponential model, using weights
    coefficients = np.polyfit(ordinals, log_values, 1, w=weights)

    # Extracting the coefficients
    log_a = coefficients[1]
    log_b = coefficients[0]

    # Convert coefficients back to the exponential form
    a = mp.exp(log_a)
    b = mp.exp(log_b)

    # Correction factor
    alpha = 2.7931615407112251695923857484645003617613050861

    # Predict the value for the given puzzle using the exponential model
    predicted_value = (a * mp.power(b, puzzle_number)) - ((((2 ** puzzle_number) - 1) - (2 ** (puzzle_number - 1))) / alpha)

    # Check if the real value is available
    real_value = None
    if puzzle_number in [x[0] for x in target_numbers]:
        real_value = [x[1] for x in target_numbers if x[0] == puzzle_number][0]

    # Function to format mpmath values to avoid scientific notation
    def format_mp(value, decimals=None):
        if decimals is not None:
            # Use string formatting to keep decimal places without thousands separators
            return f"{float(value):,.{decimals}f}".replace(',', '')
        return mp.nstr(value, mp.dps)

    # Compare the corrected value with the real value for the given puzzle
    if real_value is not None:
        print(f"Puzzle {puzzle_number} Real Value: {format_mp(real_value)}")
    print(f"Puzzle {puzzle_number} Predicted Value: {format_mp(predicted_value, 2)}")

    # Calculate the percentage error in the corrected prediction if real value is available
    if real_value is not None:
        error_percentage = abs((predicted_value - real_value) / real_value) * 100
        print(f"Percentage error in the corrected prediction for Puzzle {puzzle_number}: {format_mp(error_percentage, 2)}%")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Predict puzzle values based on an exponential model.")
    parser.add_argument("puzzle_number", type=int, help="Puzzle number to predict")
    args = parser.parse_args()
    main(args.puzzle_number)

python3 predict.py 20
Puzzle 20 Real Value: 863317
Puzzle 20 Predicted Value: 580555.48
Percentage error in the corrected prediction for Puzzle 20: 32.75%

python3 predict.py 27
Puzzle 27 Real Value: 111949941
Puzzle 27 Predicted Value: 88704196.49
Percentage error in the corrected prediction for Puzzle 27: 20.76%

python3 predict.py 45
Puzzle 45 Real Value: 19996463086597
Puzzle 45 Predicted Value: 20580213444471.79
Percentage error in the corrected prediction for Puzzle 45: 2.92%

python3 predict.py 50
Puzzle 50 Real Value: 611140496167764
Puzzle 50 Predicted Value: 635143323281525.25
Percentage error in the corrected prediction for Puzzle 50: 3.93%

python3 predict.py 63
Puzzle 63 Real Value: 8993229949524469768
Puzzle 63 Predicted Value: 5468647699742324736.00
Percentage error in the corrected prediction for Puzzle 63: 39.19%

python3 predict.py 66
Puzzle 66 Real Value: 46346217550346335726
Puzzle 66 Predicted Value: 46346217550346338304.00
Percentage error in the corrected prediction for Puzzle 66: 0.00%

python3 predict.py 67
Puzzle 67 Predicted Value: 90626458014188470272.00

This is like looking into a crystal ball. It doesn't mean anything.  

[COBRAS]

from the standpoint of probability, this doesn’t seem to mean anything

Here is my prediction script. I have +- 0-40% deviations
With correction factor for puzzle 66
alpha = 2.7931615407112251695923857484645003617613050861

more decimals in correction factor more precise result

Code:

import numpy as np
from mpmath import mp
import argparse

# Set higher decimal precision for mpmath
mp.dps = 60  # Adjust precision as needed

# Target numbers (ordinal, value) 
target_numbers = [
    (1, 1), (2, 3), (3, 7), (4, 8), (5, 21), (6, 49), (7, 76), (8, 224), (9, 467), (10, 514),
    (11, 1155), (12, 2683), (13, 5216), (14, 10544), (15, 26867), (16, 51510),
    (17, 95823), (18, 198669), (19, 357535), (20, 863317), (21, 1811764),
    (22, 3007503), (23, 5598802), (24, 14428676), (25, 33185509),
    (26, 54538862), (27, 111949941), (28, 227634408), (29, 400708894),
    (30, 1033162084), (31, 2102388551), (32, 3093472814), (33, 7137437912),
    (34, 14133072157), (35, 20112871792), (36, 42387769980), (37, 100251560595),
    (38, 146971536592), (39, 323724968937), (40, 1003651412950),
    (41, 1458252205147), (42, 2895374552463), (43, 7409811047825),
    (44, 15404761757071), (45, 19996463086597), (46, 51408670348612),
    (47, 119666659114170), (48, 191206974700443), (49, 409118905032525),
    (50, 611140496167764), (51, 2058769515153876), (52, 4216495639600700),
    (53, 6763683971478124), (54, 9974455244496707), (55, 30045390491869460),
    (56, 44218742292676575), (57, 138245758910846492), (58, 199976667976342049),
    (59, 525070384258266191), (60, 1135041350219496382), (61, 1425787542618654982),
    (62, 3908372542507822062), (63, 8993229949524469768),
    (64, 17799667357578236628), (65, 30568377312064202855), 
    (66, 46346217550346335726)
]

def main(puzzle_number):
    # Extracting the ordinal (x) and values (y) up to the puzzle before the target puzzle
    if puzzle_number in [x[0] for x in target_numbers]:
        ordinals = np.array([x[0] for x in target_numbers if x[0] < puzzle_number], dtype=float)
        values = np.array([x[1] for x in target_numbers if x[0] < puzzle_number], dtype=float)
    else:
        # Use all available data for prediction if puzzle_number is not in the list
        ordinals = np.array([x[0] for x in target_numbers], dtype=float)
        values = np.array([x[1] for x in target_numbers], dtype=float)

    # Compute log of the values using mpmath for high precision
    log_values = np.array([float(mp.log(val)) for val in values], dtype=float)

    # Introduce weights to give more importance to recent values
    weights = np.linspace(0.5, 1, len(ordinals))  # Linear weighting

    # Perform linear regression on log(values) to fit the exponential model, using weights
    coefficients = np.polyfit(ordinals, log_values, 1, w=weights)

    # Extracting the coefficients
    log_a = coefficients[1]
    log_b = coefficients[0]

    # Convert coefficients back to the exponential form
    a = mp.exp(log_a)
    b = mp.exp(log_b)

    # Correction factor
    alpha = 2.7931615407112251695923857484645003617613050861

    # Predict the value for the given puzzle using the exponential model
    predicted_value = (a * mp.power(b, puzzle_number)) - ((((2 ** puzzle_number) - 1) - (2 ** (puzzle_number - 1))) / alpha)

    # Check if the real value is available
    real_value = None
    if puzzle_number in [x[0] for x in target_numbers]:
        real_value = [x[1] for x in target_numbers if x[0] == puzzle_number][0]

    # Function to format mpmath values to avoid scientific notation
    def format_mp(value, decimals=None):
        if decimals is not None:
            # Use string formatting to keep decimal places without thousands separators
            return f"{float(value):,.{decimals}f}".replace(',', '')
        return mp.nstr(value, mp.dps)

    # Compare the corrected value with the real value for the given puzzle
    if real_value is not None:
        print(f"Puzzle {puzzle_number} Real Value: {format_mp(real_value)}")
    print(f"Puzzle {puzzle_number} Predicted Value: {format_mp(predicted_value, 2)}")

    # Calculate the percentage error in the corrected prediction if real value is available
    if real_value is not None:
        error_percentage = abs((predicted_value - real_value) / real_value) * 100
        print(f"Percentage error in the corrected prediction for Puzzle {puzzle_number}: {format_mp(error_percentage, 2)}%")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Predict puzzle values based on an exponential model.")
    parser.add_argument("puzzle_number", type=int, help="Puzzle number to predict")
    args = parser.parse_args()
    main(args.puzzle_number)

python3 predict.py 20
Puzzle 20 Real Value: 863317
Puzzle 20 Predicted Value: 580555.48
Percentage error in the corrected prediction for Puzzle 20: 32.75%

python3 predict.py 27
Puzzle 27 Real Value: 111949941
Puzzle 27 Predicted Value: 88704196.49
Percentage error in the corrected prediction for Puzzle 27: 20.76%

python3 predict.py 45
Puzzle 45 Real Value: 19996463086597
Puzzle 45 Predicted Value: 20580213444471.79
Percentage error in the corrected prediction for Puzzle 45: 2.92%

python3 predict.py 50
Puzzle 50 Real Value: 611140496167764
Puzzle 50 Predicted Value: 635143323281525.25
Percentage error in the corrected prediction for Puzzle 50: 3.93%

python3 predict.py 63
Puzzle 63 Real Value: 8993229949524469768
Puzzle 63 Predicted Value: 5468647699742324736.00
Percentage error in the corrected prediction for Puzzle 63: 39.19%

python3 predict.py 66
Puzzle 66 Real Value: 46346217550346335726
Puzzle 66 Predicted Value: 46346217550346338304.00
Percentage error in the corrected prediction for Puzzle 66: 0.00%

python3 predict.py 67
Puzzle 67 Predicted Value: 90626458014188470272.00

This is like looking into a crystal ball. It doesn't mean anything.  

try predict all upper known privkeys,what errors will be ?

[mcdouglasx]

I think you need take official registered a USA or EU patent to you DB. This will be protect your Idea from stealing and maybe give some money. Then you have a patent, can try sell your method to google, microsft etc.

Agreed this DB will be especially useful for space and medicine with how far AI has come we could use mcdouglasx's db to store a detailed brain scan or a 3d map of a galaxy and train AI on the db so it could piece together the data and we could ask it questions about the data like does this scan have a blood clot or a misfiring neuron or map the most efficient trajectory to this planet and it could answer but instead of taking up petabytes or even exabytes of storage it would take a fraction of that. Of course right now your db is specifically for public keys but its the idea that matters if you could apply it to different areas that would be game changing.

This is what it is, trying to achieve a significant improvement in the search for puzzles, nothing more, it has no general context.

[COBRAS]

I think you need take official registered a USA or EU patent to you DB. This will be protect your Idea from stealing and maybe give some money. Then you have a patent, can try sell your method to google, microsft etc.

Agreed this DB will be especially useful for space and medicine with how far AI has come we could use mcdouglasx's db to store a detailed brain scan or a 3d map of a galaxy and train AI on the db so it could piece together the data and we could ask it questions about the data like does this scan have a blood clot or a misfiring neuron or map the most efficient trajectory to this planet and it could answer but instead of taking up petabytes or even exabytes of storage it would take a fraction of that. Of course right now your db is specifically for public keys but its the idea that matters if you could apply it to different areas that would be game changing.

This is what it is, trying to achieve a significant improvement in the search for puzzles, nothing more, it has no general context.

Bro, Hi.


it is possible to put to DB not pubkey data , sach data for ex:


00000000000000000000
10000000000000000000
01000000000000000000
11000000000000000000
00100000000000000000
10100000000000000000
01100000000000000000
11100000000000000000
00010000000000000000
10010000000000000000
01010000000000000000
11010000000000000000
00110000000000000000
10110000000000000000
01110000000000000000
11110000000000000000
00001000000000000000
10001000000000000000
01001000000000000000
11001000000000000000
00101000000000000000
10101000000000000000


and this:


000000000000000000000010111000000000000011011100101010000000
000000000000000000000010111000000000000011010010001111000000
000000000000000000000010111000000000000011011010110001100000
000000000000000000000010111000000000000011010110010100010000
000000000000000000001010111000000000000001010111101001000000
000000000000000000001010111000000000000001011111001100100000
?

[nomachine]

try predict all upper known privkeys,what errors will be ?

python3 predict.py 70
Puzzle 70 Real Value: 970436974005023690481
Puzzle 70 Predicted Value: 730587102306582265856.00
Percentage error in the corrected prediction for Puzzle 70: 24.72%

python3 predict.py 105
Puzzle 105 Real Value: 29083230144918045706788529192435
Puzzle 105 Predicted Value: 27596983500174317470201354911744.00
Percentage error in the corrected prediction for Puzzle 105: 5.11%

python3 predict.py 115
Puzzle 115 Real Value: 31464123230573852164273674364426950
Puzzle 115 Predicted Value: 27143119219824810742015504299327488.00
Percentage error in the corrected prediction for Puzzle 115: 13.73%

I need all possible PVK in decimal...from 161 to 256

[COBRAS]

try predict all upper known privkeys,what errors will be ?

python3 predict.py 70
Puzzle 70 Real Value: 970436974005023690481
Puzzle 70 Predicted Value: 730587102306582265856.00
Percentage error in the corrected prediction for Puzzle 70: 24.72%

python3 predict.py 105
Puzzle 105 Real Value: 29083230144918045706788529192435
Puzzle 105 Predicted Value: 27596983500174317470201354911744.00
Percentage error in the corrected prediction for Puzzle 105: 5.11%

python3 predict.py 115
Puzzle 115 Real Value: 31464123230573852164273674364426950
Puzzle 115 Predicted Value: 27143119219824810742015504299327488.00
Percentage error in the corrected prediction for Puzzle 115: 13.73%

I need all possible PVK in decimal...from 161 to 256

maybe on allprivatekeys and similar www has privkeys data