How many perfect pandora seeds exist?

I've been looking at Gamerpuppy's Pandora's Box seeds. This user generated, using a program that quickly tries the output of Java's random number generator with a given 64-bit seed, and tries to find one that has the most repetitions of a given number (modulo the number of cards) in the output, as well as an initial roll of pandora's box for Neow `(1/22)`.

In slay the spire, the characters start with the following number of strikes and defends, and have this number of cards available:

``````ironclad:   9    72
silent:    10    71
defect:     8    71
watcher:    8    71
``````

I'm interested in what the probability would be of there existing a 'perfect' pandora seed: one where every generated card is the same. Knowing exactly would mean brute-forcing the whole space, which seems computationally unfeasible without a collaborative effort. So instead, to simplify; you may assume the generation is perfectly random instead of only a PRNG.

Result

For the Ironclad, Defect, and Watcher one very likely exists for every card. (In fact, I believe the algorithm has already found most of the Defect and Watcher seeds, and has found a few of the Ironclad ones). The cause is the fact that adding one more card to the starting deck makes it 71 or 72 times less likely for a seed to succeed.

For the Silent, there's about a `22.7%` chance any specific card has a perfect seed.

The following table details the chance there is at least one seed, the expected amount of them that exist, and the number of seeds you would have to try to find one by pure chance:

``````+-----------+-----------------+-----------------+----------------------+
| Character | Perfect chance  | Number of seeds |        Trials        |
+-----------+-----------------+-----------------+----------------------+
| Ironclad  | 0.9999999007... |       1144.8878 |  1143971351913037824 |
| Silent    | 0.2270808586... |         18.5458 | 71615358122217386422 |
| Defect    | 0.999999999999+ |      92191.0159 |    14206577687406742 |
| Watcher   | 0.999999999999+ |      92191.0159 |    14206577687406742 |
+-----------+-----------------+-----------------+----------------------+
``````

That means the seed searching program must have searched a substantial fraction (1% or so) of the total seed space to find all the perfect seeds it found, showing the power of a GPU (and why 64 or even 80 bit keys are now insecure in crypto)

Reasoning

Let's break it down into two parts;

1. Figure out what the probability is that all cards are the same and the relic is pandora, denoted `P(same)`.
2. Get the total number of seeds `N`.

Then, combine the two steps with the following proof:

The probability that all cards are not the same is `1 - P(same)` by applying the Inverse Rule. For this to happen N times, multiply itself by N by applying the Multiplication Rule N times.

Thus the probability that no seed exists is `(1 - P(same))^N`. Apply the inverse rule again to find the probability that at least one seed exists:

``````P(one seed) = 1 - (1 - P(same)))^N
``````

Corollary 1: The inverse `1 / P(same)` is the amount of seeds you would have to try to find at least one success on average (expectation of geometric variable).

Corollary 2: By multiplying the probability `P(same)` with the number of seeds `N` and the number of cards `C` (each card is independent), you get the expected total number of perfect seeds.

1. P(same)

All cards need to be the exact same specific card. Let C be the number of cards available, and D be the starting deck size, then the answer is (applying multiplication rule):

``````P(same) = 1/22 * (1/C)^(D)
``````

This yields the following result:

``````Ironclad:  1/1143971351913037824
Silent:   1/71615358122217386422
Defect:      1/14206577687406742
Watcher:     1/14206577687406742
``````

2. Getting N

This is simply the number of unsigned integers 2^64 = 18446744073709551616, since each seed is a 64-bit integer.