Doesn't seem like RNG .... but rather predetermined hands.

Honestly, based on what you've written here, you are correct that you should not play online poker. The best move is to close your account and not play.

If we don't care what suits our hand and flop have, then:
let's say QJ was dealt to us on the first table, and the flop is A54. The probability is that QJ=16/1326=0.012 will be dealt on the second table, and the flop will be A54=((4/50)*(4/49)*(4/48))*6=0,00326. That's 0.012*0.00326=0.00003912 or 0.003912% or once in 25510 hands, which should happen to you on average once every two months, considering that you play 400 hands a day.

If we take into account the suits, that is, we take a specific hand and flop, then:
Let's say we were dealt QsJd on the first table, and the flop is Ah5h4h. The probability is that QsJd=1/1326=0.00075 will be dealt on the second table, and the flop will be Ah5h4h=((1/50)*(1/49)*(1/48))*6=0,000051.
In total, 0.00075*0.000051 = 0.00000003825 or 0.000003825% or about once in 26 million hands, that is, in theory, this should not happen to anyone in their career.

Please correct me if I made a mistake.

I think you are right. The original calculation of the probability was off. I made this program and the result happens a lot more often than 1 in 6,900 hands. It says that it would happen 1 in every 86.0188 based on 100000 simulations. I think the original calculation I showed assumed that both hands had to be exactly QJ.

import random

# Function to generate a full deck of cards
def generate_deck():
suits = ['Hearts', 'Diamonds', 'Clubs', 'Spades']
ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
return [(rank, suit) for rank in ranks for suit in suits]

# Function to generate a random poker hand (2 cards) from the deck
def generate_hand(deck):
return random.sample(deck, 2)

# Function to check if both face values of hand1 match any face values in hand2
def has_same_face_values(hand1, hand2):
ranks1 = {card[0] for card in hand1}
ranks2 = {card[0] for card in hand2}
return ranks1 == ranks2

# Simulation function for one trial
def simulate_same_face_hands():
deck = generate_deck()
attempts = 0

while True:
attempts += 1
hand1 = generate_hand(deck)
hand2 = generate_hand(deck)

if has_same_face_values(hand1, hand2):
return attempts

# Main program
if __name__ == "__main__":
simulations = 100000
total_attempts = 0

for _ in range(simulations):
total_attempts += simulate_same_face_hands()

average_attempts = total_attempts / simulations
print(f"After {simulations} simulations, the average number of attempts for the event to occur is {average_attempts:.4f}.")

so this program calculates the probability of it happening if both hands have to have a Q and J and no other cards. The probability is closer to 1 in 6,900. I only did 100 simulations because it takes much longer.

import random

# Function to generate a full deck of cards
def generate_deck():
suits = ['Hearts', 'Diamonds', 'Clubs', 'Spades']
ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
return [(rank, suit) for rank in ranks for suit in suits]

# Function to generate a random poker hand (2 cards) from the deck
def generate_hand(deck):
return random.sample(deck, 2)

# Function to check if both hands contain a Q and a J
def hands_contain_q_and_j(hand1, hand2):
ranks1 = {card[0] for card in hand1}
ranks2 = {card[0] for card in hand2}
return 'Q' in ranks1 and 'J' in ranks1 and 'Q' in ranks2 and 'J' in ranks2

# Simulation function for one trial
def simulate_q_and_j_hands():
deck = generate_deck()
attempts = 0

while True:
attempts += 1
hand1 = generate_hand(deck)
hand2 = generate_hand(deck)

if hands_contain_q_and_j(hand1, hand2):
return attempts

# Main program
if __name__ == "__main__":
simulations = 100
total_attempts = 0

for _ in range(simulations):
total_attempts += simulate_q_and_j_hands()

average_attempts = total_attempts / simulations
print(f"After {simulations} simulations, the average number of attempts for both hands to have a Q and a J is {average_attempts:.4f}.")

so then I checked the flops and it was also about 1 in 358.7490 over 10000 simulations which is much lower than the original post.

import random

# Function to generate a full deck of cards
def generate_deck():
suits = ['Hearts', 'Diamonds', 'Clubs', 'Spades']
ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
return [(rank, suit) for rank in ranks for suit in suits]

# Function to generate a random flop (3 cards) from the deck
def generate_flop(deck):
return random.sample(deck, 3)

# Function to check if two flops have the same three face values
def flops_have_same_face_values(flop1, flop2):
ranks1 = {card[0] for card in flop1}
ranks2 = {card[0] for card in flop2}
return ranks1 == ranks2

# Simulation function for one trial
def simulate_same_flops():
deck = generate_deck()
attempts = 0

while True:
attempts += 1
flop1 = generate_flop(deck)
flop2 = generate_flop(deck)

if flops_have_same_face_values(flop1, flop2):
return attempts

# Main program
if __name__ == "__main__":
simulations = 10000
total_attempts = 0

for _ in range(simulations):
total_attempts += simulate_same_flops()

average_attempts = total_attempts / simulations
print(f"After {simulations} simulations, the average number of attempts for two flops to have the same three face values is {average_attempts:.4f}.")

But if I change the program to check for exactly an A a 4 and a 5 the probability is 1 in 115380.2200.

import random

# Function to generate a full deck of cards
def generate_deck():
suits = ['Hearts', 'Diamonds', 'Clubs', 'Spades']
ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
return [(rank, suit) for rank in ranks for suit in suits]

# Function to generate a random flop (3 cards) from the deck
def generate_flop(deck):
return random.sample(deck, 3)

# Function to check if both flops have exactly an A, a 5, and a 4
def flops_have_a5a4(flop1, flop2):
required_ranks = {'A', '5', '4'}
ranks1 = {card[0] for card in flop1}
ranks2 = {card[0] for card in flop2}
return ranks1 == required_ranks and ranks2 == required_ranks

# Simulation function for one trial
def simulate_a5a4_flops():
deck = generate_deck()
attempts = 0

while True:
attempts += 1
flop1 = generate_flop(deck)
flop2 = generate_flop(deck)

if flops_have_a5a4(flop1, flop2):
return attempts

# Main program
if __name__ == "__main__":
simulations = 100
total_attempts = 0

for _ in range(simulations):
total_attempts += simulate_a5a4_flops()

average_attempts = total_attempts / simulations
print(f"After {simulations} simulations, the average number of attempts for both flops to have exactly an A, a 5, and a 4 is {average_attempts:.4f}.")

Then for the hands and flop being equal it came out to about 1 in 32296.4000 over 100 simulations which is around what you said.

import random

# Function to generate a full deck of cards
def generate_deck():
suits = ['Hearts', 'Diamonds', 'Clubs', 'Spades']
ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
return [(rank, suit) for rank in ranks for suit in suits]

# Function to generate a random hand (2 cards) from the deck
def generate_hand(deck):
return random.sample(deck, 2)

# Function to generate a random flop (3 cards) from the deck
def generate_flop(deck):
return random.sample(deck, 3)

# Function to check if both hands and flops have the same ranks regardless of order
def hands_and_flops_match(hand1, hand2, flop1, flop2):
hand1_ranks = {card[0] for card in hand1}
hand2_ranks = {card[0] for card in hand2}
flop1_ranks = {card[0] for card in flop1}
flop2_ranks = {card[0] for card in flop2}

hands_match = hand1_ranks == hand2_ranks
flops_match = flop1_ranks == flop2_ranks

return hands_match and flops_match

# Simulation function for one trial
def simulate_hands_and_flops():
deck = generate_deck()
attempts = 0

while True:
attempts += 1
hand1 = generate_hand(deck)
hand2 = generate_hand(deck)
flop1 = generate_flop(deck)
flop2 = generate_flop(deck)

if hands_and_flops_match(hand1, hand2, flop1, flop2):
return attempts

# Main program
if __name__ == "__main__":
simulations = 100
total_attempts = 0

for _ in range(simulations):
total_attempts += simulate_hands_and_flops()

average_attempts = total_attempts / simulations
print(f"After {simulations} simulations, the average number of attempts for both hands and both flops to have the same ranks (regardless of order) is {average_attempts:.4f}.")

The last one isn't worth calculating because the computer I have doesn't have the processing power.

Sorry I am just on tilt. It seemed odd and wanted some constructive input.

now check what the probability is to get dealed K8 of clubs on one table and Q spades 10 of hearts on the other with a a74 flop on the first hand and k q 5 on the other.

The probabilities of receiving AsAh 5 times in a row is the same of AsAh followed by Qd3c followed by Js4h followed by 5h8s followed by Qh2s. For your point to be reasonable you hold neither set of cards more suspicious. Do even you believe that?

I see you too try to find out the probability of niche spots.

I've seen pocket pairs - 3 hands in a row on 4 separate occasions.

I've gotten set over set back to back (2 hands in a row)

The above occurred over 30k hands played cash games; and probably 30-60k hands of tournament play. Now here is something I can't figure out. ChatGPT is relatively good at keeping perspective on variance. When chatGPT starts writing disclaimers like the following; there may be an issue on the alleged site.

At no point did I ask chatGPT if the site was fair; I asked if this event was within variance, then double checked it. To be clear; ChatGPT's default prior to giving any examples for it to calculate odds on is 'variance'. Which means, by default, chatGPT will tell you you're within variance and then it will suggest ways to improve. When you provide the incredible hands, it suddenly swaps to warning you about site fairness (even when you only asked for odds).

Here is a post by a cheater on a cheating forum stating 'the cards don't drop right' on the website I play on. (IDK if any of these bots work - I don't cheat, I just keep my ear to the ground)

Cool...
Well, wave effect in the process of dealing hands in PS, PP, iPoker rooms is countable with a help of computer modeling, and i managed to do that (not too easy though...). The results are crazy. But this is not what we need to stop this fooling of million people all over the world by converting their deposites into a room's commission (by equalizing of different level players).