Australian Powerball number generator

Your text is cleaned up (lower-case, single spaces), labelled with the lottery and optional draw date, and hashed with SHA-256. The hash is stretched into a stream of 32-bit numbers, which are turned into balls with rejection sampling and a Fisher–Yates shuffle, exactly like drawing from a drum.

1. Clean up the text. Letters are lower-cased, surrounding spaces trimmed and runs of spaces collapsed, so John Smith and john smith count as the same input. Accents and punctuation are kept.
2. Label it. The text is combined with the algorithm version, the lottery and (optionally) the draw date: atypicalquant-lotto-v1|powerball-australia||john smith. Labelling with the lottery means the same name gives unrelated tickets for Australian Powerball and for every other game.
3. Hash it with SHA-256. SHA-256 is the hash function behind Bitcoin and HTTPS certificates. It turns the message into a 256-bit "fingerprint" (the seed) that looks like 32 random bytes. Change a single character and roughly half of the bits flip.
4. Stretch the seed. One fingerprint isn't always enough, so it is extended into a stream: SHA-256(seed ‖ 0), SHA-256(seed ‖ 1), … Each block is cut into eight 32-bit numbers between 0 and 4,294,967,295.
5. Turn numbers into balls fairly. To pick one of 35 balls the obvious move is "number mod 35", but 2³² isn't a multiple of 35: it leaves a remainder of 11, so the lowest 11 positions would get one extra chance each. The fix is rejection sampling: the top 11 values are thrown away and the next number is used instead. That happens about once in 390,451,572 draws, and it makes the pick exactly uniform.
6. Draw without replacement. The balls are drawn with a Fisher–Yates shuffle, the computer version of a drum: choose a random ball among the 35 remaining, set it aside, choose among the 34 left, and so on until the ticket is full. Bonus balls (Powerball, Lucky Stars, Joker…) come from their own drum, using the same stream.

Yes. The numbers are computed from your text with SHA-256, so the same text and the same lottery always give the same ticket, on any device. Capital letters and extra spaces are ignored; accents and punctuation are not.

SHA-256 output behaves like perfectly random numbers, rejection sampling makes each ball pick exactly uniform, and the Fisher–Yates shuffle turns uniform picks into uniform tickets. Together, every one of the 134,490,400 possible Australian Powerball tickets is equally likely.

• SHA-256 output is indistinguishable from random. No one has ever found a way to predict any part of its output, or to find two inputs with the same hash. For a lottery ticket that means the seeds of different names behave like independent, perfectly random 256-bit numbers.
• Rejection sampling is exact. After discarding the leftover values, each of the 35 positions corresponds to exactly the same number of 32-bit values, so each is chosen with probability exactly 1/35. There is no rounding, not even a tiny bias.
• Fisher–Yates is exact. With exactly uniform choices at every step, each ordered sequence of balls has probability 1/(35·34·…), so every unordered ticket of the 134,490,400 possible ones is equally likely.

Put together: over all the names people type, tickets are spread perfectly evenly across the whole 7/35 + 1/20 space, exactly like a real lottery drum.

Yes. The test below generates tickets for 20,000 made-up names ("test-1", "test-2", …) and counts how often each ball comes up. With a fair method every bar sits close to the dashed "expected" line, and a chi-square test confirms it.

Letter sums and birthday numbers cluster: birthdays only cover 1–31, and summing letters gives some totals far more often than others. SHA-256 spreads every input evenly over its 2²⁵⁶ outputs, and a tiny change to the text produces a completely different ticket.

Most "lucky number from your name" tools use numerology: give each letter a value (a = 1, b = 2, …), add them up and reduce. It feels personal, but the numbers it produces are far from even:

• Letter sums cluster. A sum of many letters piles up around a typical value (the central limit theorem at work), so a name-length of letters produces a narrow range of totals. Wrapping that "mod 49" doesn't fix it: some balls come up several times more often than others, and long or short names can never reach parts of the range.
• Birthdays only cover 1–31. On a 6/49 ticket, birthday numbers can never include 32–49, which is over a third of the drum. Millions of players pick dates, so if a "birthday" combination wins, the prize gets split many ways.
• Prime-modulus hashes have structure. A classic hash like Σ code(cᵢ)·31ⁱ mod p with a prime p is great for hash tables, but similar names give related values ("Ana" and "Anb" differ by exactly one step). SHA-256 has no such structure: the two names give unrelated tickets.

No. In a fair lottery every combination has exactly the same chance; for Australian Powerball it is 1 in 134,490,400. What a uniform generator does help with is avoiding popular picks like birthdays or 1-2-3-4-5-6, so if you do win you are less likely to share the prize.

Tick "New numbers for each draw date" and pick the date. The date is mixed into the hash, so each draw gets its own ticket, and the same name plus the same date still always gives the same numbers.

No. The hash and the draw are computed by JavaScript inside this page. Nothing you type is uploaded or stored by this tool. If you use "Copy link", the text goes after the # in the link, a part of the address that browsers don't send to the server when the link is opened.

Yes. Open "Show the math" under a ticket to see every intermediate value, or run the short Python script on this page. It produces exactly the same numbers.

The whole method fits in 30 lines of Python. Run it and you get exactly the numbers this page shows for John Smith:

import hashlib, re, struct, unicodedata

def lotto(text, game="powerball-australia", pools=((7, 1, 35), (1, 1, 20),), draw_date=""):
    norm = re.sub(r"\s+", " ", unicodedata.normalize("NFKC", text).strip()).lower()
    seed = hashlib.sha256(f"atypicalquant-lotto-v1|{game}|{draw_date}|{norm}".encode()).digest()

    def words():                      # SHA-256(seed || counter) -> 32-bit words
        i = 0
        while True:
            yield from struct.unpack(">8I", hashlib.sha256(seed + struct.pack(">I", i)).digest())
            i += 1
    w = words()

    def uniform(n):                   # rejection sampling: no modulo bias
        limit = 2**32 - 2**32 % n
        while (x := next(w)) >= limit:
            pass
        return x % n

    tickets = []
    for k, lo, hi in pools:           # partial Fisher-Yates per drum
        deck = list(range(lo, hi + 1))
        for j in range(k):
            r = j + uniform(len(deck) - j)
            deck[j], deck[r] = deck[r], deck[j]
        tickets.append(sorted(deck[:k]))
    return tickets

print(lotto("John Smith"))   # [[4, 9, 14, 17, 18, 23, 24], [19]]