# Discount Gambling

## Simple Collusion Strategy for Caribbean Stud

Posted in caribbean stud by stephenhow on September 20, 2010

(This post was calculated for 6 players; see updated analysis for +EV collusion with 7 players.)

I’ve always wondered how easy and effective collusion at Caribbean Stud would be. People have looked into the theoretical gains of collusion, and conclude its possible to reduce the house edge to 0.4%, using a computer to analyze all 30 confederate cards and the dealer upcard.

I developed a practical collusion strategy for Caribbean Stud, which reduces the house edge from a practical 5.32% down to 1.32% with 6 players. That’s a significant savings, since often players are grinding away, trying to hit a large progressive, or a high hand bonus overlay. On a \$5 bet, a normal strategy costs (\$5)(.0532) = \$0.266/hand. That’s pretty expensive, close to \$11/hr @ 40 hand/hr. Using the simple collusion strategy detailed below, you’d cut your costs by 75%, down to (\$5)(.0132) = \$0.066/hand, or \$2.64/hr. That’s a big deal, especially if you play a lot, or for long sessions. Normally, Caribbean Stud is an expensive game, long-term.

To collude, you’ll need a cooperative table of 6 players (you and 5 others). You don’t need much info, and the strategy implementation is extremely simple. The key is calling a nominal folding hand, when you have enough info to justify a call, in hopes the dealer doesn’t qualify. Also, there are times when you should fold a normal calling hand, because it’s likely that the dealer holds a better hand.

The easiest way to share the needed info among players is by signaling with colored chips. In designated per-player areas, each confederate should place a red (\$5) chip to indicate each copy of the dealer upcard they posses. Additionally, each player should place a blue (\$1) chip for every Ace or King they hold. With this collusion information, you should modify the simple strategy as follows:

Hand Modified Strategy
Junk Raise if see at least 3 red chips and 3 blue chips.
(3 upcard copies and 3 A/Ks.)
A K J 8 3 Fold if one or less red chips seen.
(1 or less upcard copies.)
One Pair 2’s or 3’s Fold if one or less red chips seen, AND upcard is higher than pair.
(1 or less upcard copies.)
One Pair 4’s thru 8’s Fold if no red chips seen, AND upcard is higher than pair.
(No upcard copies.)
Pair 9’s or higher No change.

### Raising with Junk

The following table shows the simulated average value of raising with a junk hand, given the 6 confederates have all 3 copies of the the dealer upcard (not A/K), broken down by the number of Aces and Kings the confederates hold. For example, say the dealer upcard was a 9c, and the players have all the remaining nines (9d, 9h, 9s). Then, the table below says not to raise junk unless the confederates (i.e., 30 cards seen) hold any combination of at least 3 Aces and/or Kings. So if the confederates hold 2 Aces and 2 Kings, the value of raising a junk hand is -0.66649. This is much better than folding (value -1). Or, if the confederates hold 0 Aces and 4 Kings, the value of a junk hand is -0.67487. On the other hand, if the confederates hold only 1 Ace and 1 King, then it’s better to fold the junk hand (-1) than raise it (-1.05500).

```         0 Kings   1 King  2 Kings  3 Kings  4 Kings
4 Aces  -0.69915 -0.55349 -0.50180 -0.51584 -0.69635
3 Aces  -0.84700 -0.67379 -0.54392 -0.49117 -0.51812
2 Aces  -1.05753 -0.84399 -0.66649 -0.54415 -0.48636
1 Ace   -1.29684 -1.05500 -0.84116 -0.66779 -0.53230
0 Aces  -1.54412 -1.29312 -1.04717 -0.85175 -0.67487
```

Note that the table is symmetrical about the diagonal Aces=Kings, and can be reduced using the index Aces+Kings:

 Known Aces+Kings EV(Raise) 0 1 2 3 4 5 6 7 8 -1.54 -1.30 -1.05 -0.85 -0.67 -0.54 -0.50 -0.52 -0.70

The frequency of 6 confederates (30 cards) holding all 3 the dealer upcard outs is a high 19.5% = C(48,27)/C(51,30). That means in one out of five hands, a few confederates will probably be helped. Remember, that raising a junk hand with a value of -0.70 is better than folding (-1), and for a \$5 Ante, that’s a \$1.50 savings. Any time you can play a slow carnival game for around 2% of the Ante, you’re doing well. Caribbean Stud is a fun, relaxing game, but it’s normally expensive. Reducing its house edge from 5.5% to 1.3% makes it a lot more enjoyable.

## Card Craps Source Code

Posted in card craps by stephenhow on September 5, 2010

The card craps players at Viejas definitely lean towards Don’t Pass now, even when I’m not at the table ðŸ™‚ The astute players understand that the game is unlike dice craps, and the rolls aren’t quite independent of each other. Yesterday a Don’t player I’ve never seen before started to lecture me on this point before I could tell him I agreed. Then a young couple came and started playing DP and laying odds, like they knew what was going on. When the regulars are playing, at least half the table plays Don’t.

Anyways, I decided to clean up and post my Java source code for card craps, including the CSM model, the roll window, etc. You can download my source code, inspect the models, experiment with the parameters, and verify my results (+1.5% of the flat bet @ 10x Dont’ Pass odds using 3-roll count for the current Viejas shuffler; -3.6% for 10x odds Pass Line player!). I’m posting the source code to show how simple the CSM effect is on the craps game. I.e., given a simple but accurate model of the CSM, the Don’t Pass edge follows:

package net.discountgambling.cardcraps;

import java.util.Vector;
import java.util.Random;

/**
*
* @author show
*/

public class CSM {
// params approximate the ShuffleMaster 126 model Constant Shuffle Machine
static final int NUM_SLOTS = 40;
static final int DICE_SETS = 52;
static final int MIN_BUFFER_DEPTH = 4;  // minimum cards in chute
protected Vector[] slot = new Vector[NUM_SLOTS];    // card slots in "wheel"
protected Vector chute = new Vector();  // cards are dealt from chute
protected Random random = new Random();

public CSM() {
for (int i=0; i<NUM_SLOTS; i++) {
slot[i] = new Vector();
}
for (int i=0; i<DICE_SETS; i++) {
for (int d=1; d<=6; d++) {
shuffleCard(d);
}
}
}

// shuffle roll back into CSM
public void shuffleRoll(Roll roll) {
shuffleCard(roll.getDie1());
shuffleCard(roll.getDie2());
}

public Roll dealRoll() {
return new Roll(dealCard(), dealCard());
}

// deal card from chute
protected int dealCard() {
// drop a slot if chute is running out of cards
while (chute.size() < MIN_BUFFER_DEPTH) {
// select a random slot of cards from the "wheel"
Vector randomSlot = slot[random.nextInt(NUM_SLOTS)];
// drop slot of cards into the chute
randomSlot.clear();
}
return (Integer) chute.remove(0);
}

// shuffle card into random position of random slot
protected void shuffleCard(int card) {
Vector randomSlot = slot[random.nextInt(NUM_SLOTS)];
if (randomSlot.isEmpty()) {