Lol we are saying the same thing,


in the second ''crate'' is the queue.

shuffler → queue → table that needs a deck

Adding on to the above -
The email says nothing about a crate - it mentions a queue - one queue - the queue of shuffled decks.

So the flow of the deck would be:
1) New deck created
2) Shuffle server shuffles deck (btw this doesn't mean "server" as in physical piece of hardware - it can just be a common shared code component accessed by multiple tables - although in this case it seems like its a stand alone component that ...)
3) Shuffle server puts deck into a delivery queue which has 10,000+ decks in it
4) Queue is first in, first out, so first deck shuffled gets picked first
5) Table comes along and asks queue for a deck and it gets next deck in line

Each table *could* btw have a "shuffle server" - if you look at my code, the shuffler itself is 2 lines long. (Granted they're two rather complicated lines) But since they're using a quantum processor it makes sense that they would isolate the shuffler and have it feed decks out constantly.

Putting the decks in a queue, stored until needed, adds to the security. You can't predict which table will ask for a deck next.

ok good so we agree that once shuffled the deck is frozen in that order and decks go out to tables in the order created.

Good - so stop saying "crate" please. There isn't one. There's a queue. ONE queue. Not two.

Sorry, earlier on in the thread we were using analogies using crates. We represented the queue as a crate full of decks behind the table.


But yes we are agreed.

I am quite excited, looking forward to doing the data analysis.

Just to double check, the second test, you are running 10,000 ''hands'' and each time you pick a random deck top card, the decks are reshuffled before the next random pick?

Thread has take an astonishing turn....

After this test is done, the goalposts are going to be moved.

The tests seem the exact parameters, I can't wait to do the data analysis.

If the test reveals nothing unusual then I think I will have to admit I am wrong.

If it reveals anomalies, I will have to try repeat the experiment because that is vigour.

No. Won't be necessary.

PKDK will eyeball the outputs and declare that in one test there are more repeats and clusters than in the other test(s) and that proves him right:



If he wants to look for "clusters" he really should define "cluster" now (x amount of repeats over y number of sequential cards) and the program could just be made to count the number of clusters. Removes bias, human error and makes the counting much faster.




EDIT:

You could have more than one definition of cluster too I guess. For example, the program could count both the number of 3 repeats over 8 sequential cards and the number of 5 repeats over 18 sequential cards. The more definitions, the more programming and the longer the program would take to get results, but I don't know how much of an effect having a few different definitions of cluster would have.



SECOND EDIT:

Even doing this, I don't know how large the sample size needs to be to be very confident about the results. I don't know if 10,000 is enough. And I'm pretty sure that confidence intervals will not be considered. So, if the sample size is too small and no confidence interval calculations are done, then just by chance there may be more clusters in the one test (or it may turn out that there are more clusters in the other test). Although, to PKDK's credit, he did just say:


So if just by chance there may be more clusters in the one test, he would run it again. Running it a few times would help with this problem.

Is it ostensible tho?

I would want to run the test several times, results have to be repeatable before they have 100% merit.

The preliminary tests, are for consideration of more tests, I would be about 95% sure until several tests have been done.

Then I would have to talk to stars again to triple check information about the queue.

Only then if it all ''adds'' up, it is a fact.

No it would not be, because the test is based on R² real coordinate space and the parameters of the test seem right for the physics involved.

By clusters I mean obvious grouping differences.

My main analysis of the comparison will be the sequences depending on what the outcome results show with the second test.

I will be creating some vector lengths, i.e 52 results of the sequence are a set with a 52 length. Over each length I will calculate how many times say Ad has shown in that length.

The length representing an amount of time.

Even so, for it to be a good unbiased test, you need to define "cluster" now before looking at the outputs. Doing so also gives the added benefit of making it possible to code the program to count the clusters, so that you do not have to.

See:

You need to set the length(s) you will be looking at now before you see the outputs. See the post I made immediately above this one, which is post #665.

And it would probably be easier to code the program to count the number of Ad over such length(s) rather than you having to do it manually.

L = 52 = 1 hr

Cluster equals repeat values within 1 hr. Number values or suit values.


ok?

Spade:Seven...........black
Spade:Eight..............................black
Spade:Four................black
Heart:Three.............................red
Spade:Two.............................black
Spade:Ace.....red
Heart:Three....................................red
Spade:Ten......................................bla ck
Diamond:Seven.................................red
Club:Three........................................ ..black
Heart:Ace...................red
Diamond:Jack...................................... .....red
Spade:King............................black
Spade:Three...................................black
Club:Three...................black
Diamond:Four...................................... ...red
Club:Ten.......................................... ........black
Heart:Six...............................red
Heart:King.....................................red
Club:Two.......................................... ....black
Spade:King........................................ ....black
Diamond:Seven..................red
Diamond:Jack...................................... .red
Club:Queen........................................ black
Club:Four......................................... black
Heart:King........................................ red
Heart:Seven............................red
Club:Jack......................................... ....black
Diamond:Seven........................red
Diamond:Nine.....................................red
Club:Queen........................................ ..black
Heart:Two.....................red
Heart:King........................................ ......red
Heart:Ten..................................red
Spade:Ten............black
Heart:Three....................................... ..red
Diamond:Ace.................................red
Spade:Ace....................................black
Heart:Four........................................ ..........red
Diamond:Jack...................................... .......red
Heart:Nine........................................ ........red
Spade:King........................................ black
Club:Jack...........................black
Club:Queen.............................black
Spade:Queen..................black
Diamond:Queen...............................red
Spade:Eight....................................... .black
Diamond:Queen.................................red
Club:Four......................................... .black
Club:Nine........................................b lack
Spade:Ten......................black
Spade:Three...............................black


In the first set of 52 of the first test, I count 4 aces 4/52 exactly


4/t1 marked in red

clusters marked in blue

repeat numbers in green

It looks like clusters are groups of 2 or 3 in a row on average in this first set.

So:

Look at the first 52 cards and count how many times each value (2-A) and each suit appeared in that set of 52 cards.

Look at the next 52 cards and count how many times each value (2-A) and each suit appeared in that set of 52 cards.

Look at the next 52 cards and count how many times each value (2-A) and each suit appeared in that set of 52 cards.

Etc.


Is that correct?

I don't know if it is better to do it that way or with a rolling count as initially occurred to me (and is how my examples were set up in some above posts). But I think that works. But, 2 things:

1. The number of cards dealt is 10,000. Therefore, there will be 192 sets of 52 cards and then 16 cards remaining

2. Again, I would suggest coding the program to do the counting for you. Manually counting 192 sets of 52 cards for all 13 possible values and 4 possible suits sounds like it would take an extremely long time and would probably be subject to significant human error. I don't have the programming knowledge, but I would think that it wouldn't be too difficult or take too long to add code to the program to make it do this counting.





EDIT:

Actually, a third thing. How are you going to compare the results of the counts of the 192 sets in one test to the results of the counts of the 192 sets in the other test. It was immediately clear to me how to do this comparison when using rolling counts since there would only be one ultimate counted number for each test for each definition of cluster. But in the method you propose, there will be 192 different counts for each test.


SECOND EDIT:

Actually, you will have 3,264 different counts for each test. 192 different counts for each of the 13 different values and 4 different suits. How are you going to compare the tests?

I think it would be easier just to have a rolling count and count how many times there are x number of any value (or suit) over y number of sequential cards. That would yield 1 count per test and those could be compared easily. You could do multiple counts for different values for x and y, but each would yield 1 count per test.

This example isn't the same thing as what you said. You said you would be counting how many times something appeared over a length of 52 cards. In this example you are marking "clusters" as when the same value or same suit appeared back to back. [EDIT: Although you missed the two clubs at the end right before the two spades that you did mark. There is some human error already. Would be better to code the program to do the counting.]

Professional statisticians will tell you that testing "clusters" is fraught with peril for all the obvious reasons

One solution (as intimated above) is to do a bunch of "runs tests" for which there are many fewer pedagogical and definitional pitfalls.

I would consider doing runs tests on suits and ranks.

Although, I have said this above, I edited those posts and they are longer and so I am just putting this in its own post so it doesn't get lost. I think this is the better way to do the testing:


I think it would be easier just to have a rolling count and count how many times there are x number of any value (or suit) over y number of sequential cards. That would yield 1 count per test and those could be compared more easily.

You could do multiple counts for different values for x and y, but each would yield 1 count per test.

The way to test these clusters or other anomalies in a random sequence is already well-defined. You use the die-hard test sequence on the full output. You can download it from NIST or other sources.

It's impossible for you to judge randomness by just observing it, you need a rigorous protocol as mentioned above.

Spade:Jack
Diamond:Six
Spade:Seven
Diamond:Jack
Spade:Ten
Heart:King
Heart:Ace
Club:Nine
Heart:Jack
Spade:King
Diamond:King
Spade:Seven
Heart:Ten
Diamond:Four
Diamond:Four
Spade:Six
Diamond:Five
Club:Five
Spade:Three
Diamond:Three
Diamond:Ace
Diamond:Six
Heart:Jack
Heart:Ten
Spade:Queen
Spade:Five
Spade:Ace
Club:Jack
Diamond:Three
Club:Ace
Diamond:Nine
Club:Five
Spade:Ten
Spade:King
Spade:Seven
Spade:Queen
Spade:Ace
Club:King
Heart:Eight
Spade:Jack
Diamond:Three
Heart:King
Heart:Jack
Diamond:Two
Diamond:Ace
Club:Ten
Diamond:Eight
Club:Jack
Club:Three
Diamond:Seven
Club:Seven
Spade:Three


second set of the first test

aces 6/52

I understand what you are saying, I am not the one running the test though, so I am not sure about that, this way though , we can physically see any anomalies.

I think 2-4 is going be the average.