All {a}x = 1/52

All {a}y = ?/52


y52
.
.
.
................x52


In a 52*52 array where all x rows are randomly shuffled to make the columns y.


P {a}/y = var (1/52)x


That is the maths for the physics of the notion, does anyone want to debate this math is not correct?


Any of you understand vector mapping?

ƒ: x→y = var (x)

So first of all - your problem is with stars, apparently, and not all of online poker, is that right?

Secondly - ok - fine - what is the distribution process Stars uses?

As with the "how many A are in the stack picked from 1 card from many decks", the question you ask here is not one that can be answered as written.

You are seeking an ABSOLUTE answer to a question that has no absolute answer.

The best you can ask here is "how far must he travel before he has an x% chance of encountering the open door?" - and then supply a value for X.

For instance, if you want a 100% chance of encountering the open door he must travel 52m. If you want a 50% chance of encountering the open door he must travel 26m.

Any online poker that uses a queuing system of decks I have problem with. Stars is the only one I can personally confirm uses this system.
The system they use I have already posted in this thread.

This thread is 629 posts long. You have 447 posts and I dare say most of them are in this thread.

So would you be so good as to repost the parameters? Or at least give me a clue as to when you posted them previously?

Thank you for your email.

While we obviously don't use real (physical) decks, technically, every hand a new deck is used. We have a dedicated shuffle server that does nothing except shuffle millions of decks every day.

Once a new deck has been shuffled the shuffle server does not know which table any of the shuffled decks are going. It just sits there shuffling tens of thousands of decks every minute. These decks are then put in a queue to send to the next table that needs one. The server does not know how many players will be at the table that requests the next deck, it does not know what poker game the cards will be used for, and it does not know the identities of the players. It just shuffles cards.

PokerStars' shuffle software is truly random, and produces a deck which is completely fair and unpredictable.

To do so, it takes two completely and truly random sources of information:

1) Player input (e.g. mouse movements, key strokes, clicks, etc.)

2) A physical random number generator exploiting an elementary quantum optics process

These are combined to create a completely random number. This is then used to shuffle the cards - you can read about exactly how this is done here:

http://www.pokerstars.com/poker/room/features/security/

Details on the Quantis device which we use can be seen at:

http://www.idquantique.com/random-nu...-overview.html

Because nobody can predict either of the two sources of information, the number generated by our Random Number Generator (RNG), and consequently the order of the cards, is completely random in a mathematical sense. The data taken from Player input is not used to shuffle the next hand at the table its is actually used by the shuffle server for shuffling a new deck of cards with an unknown destination.

Please let us know if you have any further questions.


Regards,

Tino
Stars Support


Problem highlighted in red. no other problem except this. x+x = xy or you can even do x,x, but using xy is easier to explain.
x,y
Deck 1
Deck 2


x,x, deck 1, deck 2,

Ok so the first link you sent me says, in essence, we shuffle a deck before a hand starts. it's guaranteed to be random and unpredictable. And the order can't change after it's shuffled.

The second link is a link to a quantum processor who's job is to generate random numbers.

That first bit of your post - is that an email from stars?

Yes from yesterday or the day before, I also have a similar email from several years ago that just says the same thing really.

Ok so going back to my proposed test.

What parameters are not met?
If your argument is that creating the decks in advance and storing them, and then doling them out at random over time causes the distribution of the cards to be wrong, and you can check this by looking at the first card from every deck over time, then my proposed model of 2 tests - one instant vs one queued - it seems pretty close.

I think if we add a random picking of which deck to check next to the one where we pre-shuffle it'll satisfy the need.

OR - how about this : I pre-shuffle a million decks to start, and then pick the first but then instead of the second I randomly jump forward between 0 and 1000 decks to pick the next one.

Every time I do this, I shuffle that many new decks and add them to the queue.

So there we have the "jumping ahead" piece - and then we record the first card from each "jumped ahead" deck 1 million times compared to the first card from the on demand 1 million shuffles.

Would that satisfy the parameters?

If not - PLEASE help me understand what parameters I'm missing?

One thing though - I won't use a quantum generator for this. The reason you need that on a poker site is to ensure that no predictable outcome of the random generator is possible. For purposes of just testing pre-shuffled decks messing up distributions when picked randomly from a range, how the decks are shuffled won't matter. The standard RNG on a computer will give you a random set - its just one that you CAN predict given the inclination

That sounds reasonable, but what result are you looking for?

You also need to add some sort of time factor, the result which would prove me correct is a result based on time.

If it is not difficult to run that experiment , please do it. You also need to record the entire sequence of both tests. The sequences over time being the comparison.


To clarify, you are going to shuffle 1 million decks, then randomly choose any deck and write down the top card value?


In the second experiment you are going to shuffle 1 million decks , deliver them in order, writing down the top card value?

Yes I can run such an experiment.

What are we looking for - well that's up to you to decide but as I see it we're looking for any abnormal distribution of the cards.

If we generate 1 million "first cards" using each method and capture the total count each of each card then we can look to see if the distribution appears at all unbalanced.

As for time - well - how much time would you like me to introduce? It will take some time to generate 1 million results regardless but if I introduce a deliberate delay? I mean 1 second alone will take 277 hours to complete.

How about 3 tests.

100,000 shuffled on demand.
100,000 shuffled ahead of time and picked with skipping with no delay
100,000 shuffled ahead of time picked with skipping with a delay of 1 second per pick

100k is not as good as a million but can be done in a more reasonable time frame.

You could use only a 10,000 decks and it should show us the result.


10,000 decks shuffled, put in a queue then random pick any top card , write down the value, put the deck for a re-shuffle then back at the end of the queue.


10,000 decks shuffled , put in a queue , top card selected in queue order. write down the value, put the deck for a re-shuffle then back at the end of the queue.


This would give us the 2 sequences we need to look at. We just need the right questions to ask now, what we are looking for exactly in the term of anomalies.

Would you be able to put both results in wave format , both waves on the same graph in different colours to see the wave frequencies?


I will have a think about the exact anomaly we are looking for and get back to you this, at first thought the main thing is something like

Ad/t1

and repeats / t1


I predict one test will have more repeat values and more clusters.


One sequence will be more red, black, red, black , rather than black, black, black, black,


diamonds /t

clubs/t

hearts/t

spades/t


aces/t


I think this might answer it.

Maybe put t1 = 1hr, then run it several times over several hours giving us several set of comparisons . Each measure over an hour of time.


example - Ad * 2 in 1 hr .

clubs * 20 in 1 hr.

What I can give you:
For each test case, a list of all 52 card values with the number of occurrences of each.

I'll also share the source code with you so you can check it.

Any further processing is on you dude.

I see a problem with your #1

In order to accurately represent what the shuffler server would be doing, we need to shuffle 10k decks, pick 1 at random, but all the decks in front of the one we pick also need to be returned to the queue.

Because when you have 10k decks the stars shuffler only returns the FIRST deck each time it gets asked. So if we say "I want deck 300" then decks 1-299 need to be reshuffled as well. And they need to be returned to the shuffler in a random order.

Also you're proposing that I create a deck variable for each deck and KEEP it - reusing it over and over, as opposed to just creating decks and throwing them away when done, is that right?

I see you editing your last post. If you want the output of all the picked cards, fine - but I'm not doing any testing for clusters and sequencing.

That's a great start and thanks.

Thanks, the cluster should be observable of the results by eye. Like a red or black cluster in roulette.

Do you understand and agree with what I'm saying about when we pick a random deck from the queue, we need to reshuffle all the decks in front of it?

If you did that, you would fix the problem, it would not be a queue anymore it would be back to 1/52 because you destroyed the array.


added- second thought , maybe not, I will have to think about that one.

added- in a shuffle x is in motion, when we randomly pick from y , y is stationary.

added- ok tea time , speak later

The email you shared said that the shuffle server hands the next deck in the queue to the next table that asks.

That means that when we play hand 1, we get deck 1 from the shuffler, then other tables come along and pick up decks, which go away.

Then we come along and get deck 2 for OUR TABLE which is deck 72 from the shuffler.

Decks 2-71, which we did not use, are still out there, either actively in play, or already sent back to the shuffler.

(Although in reality that isn't how its gonna work at stars. The shuffler server is gonna make a queue of decks and then once those decks are used they won't go back to the queue, they'll be removed from memory completely. No point in recycling the variable that held the deck.)

Also dude nobody but you has a freaking clue what you mean by x,x and y,y. Use english.

Making sure this link works before I explain it all:
https://drive.google.com/drive/folde...Ix?usp=sharing

OK - I've finished test 1. This is the easy test - the control test.

I created a queue of 10,000 decks. I iterated through each deck one by one, and captured the top card, counting the instance of the cards as I went.

In the link above the output can be found in the two text files.

The source code for the test is in the "Code" folder. I will be adding to it as I build out test 2.

The output is in two formats: CardList is the 10,000 line list of individually drawn cards, as they were drawn.

CardCount is the total for each suit/value combo - how many of each.

I am not good enough at excel or statistics to properly determine what variation we should see across 10,000 draws - I can tell you that the least frequently occurring card showed up 156 times and the most frequent 218 where we would expect 192 as the average.

I'm putting this here now to ensure you can see the output and the code, and determine if the formats will work for your testing.

Oh yes, a note on the shuffler
IEnumerable<int> cards = Enumerable.Range(0, 52).OrderBy(a => Guid.NewGuid());
return new Deck(cards.Select(c => new Card(c)));

After a very minimal amount of research I settled on the above method for randomizing the deck. What it does is for each item in the array of ints, it creates a GUID (globally unique identifier) - this is a pretty random damn value if you don't know about them - so taking the range of 0-51 and then sorting each number by an associated randomly assigned guid gives us a pretty solidly random sample.

These 52 values (0-51) are converted into individual cards by dividing by 13 for the suit (0-3) and modding by 13 for the value (0-12). The values are converted to enumerations (Suit/Value files) for readability.

That is not what it says,

That says the decks are in a 'crate' being shuffled, they are then transferred to another crate waiting for distribution. I have had this confirmed in conversation with stars, they admitted they would have to have a server on every table otherwise.

Thanks, you know your ''stuff' , the link works.

No you're reading that wrong.

The shuffle server creates a deck - shuffling it once - and then that deck is set in stone.

It then puts the deck in a queue and moves on to shuffling the next deck.
It creates 10's of thousands of decks a minute (they say but that seems excessive - they would need to be dealing 10,000 hands a minute site wide to need that kind of queue)
The individual deck, once created, is put in the queue to await delivery. Queues are, by definition, FIRST IN, FIRST OUT.

So the 732nd deck shuffled would go to the 732nd table to ask for a deck.