What is your strategy?

I suppose I misread. So, what's your "absolute best" strategy?

 

You misread and I misspoke. There is plausibly a better strategy than this one.

 

Ok, here are the top 10 strategies now, with the inclusion of the bet on all black numbers:

Code:

	R16	R14	R	BN	F(R16,R14,R,BN)
	8.1	5.4	48.6	37.8	0.3279876
	8.1	5.4	48.5	37.9	0.3279855
	8.1	5.4	48.7	37.7	0.3279851
	8.2	5.4	48.5	37.8	0.3279832
	8.2	5.4	48.6	37.7	0.3279822
	8.0	5.4	48.7	37.8	0.3279818
	8.1	5.5	48.5	37.8	0.3279818
	8.0	5.4	48.6	37.9	0.3279811
	8.1	5.5	48.6	37.7	0.3279805
	8.1	5.3	48.7	37.8	0.3279805

R16: percent of bankroll to bet on R16
R14: percent of bankroll to bet on R14
R: percent of bankroll to bet on Red
BN: percent of bankroll to bet on all black numbers
F(R16,R14,R,BN): geometric growth rate

Note that for all purposes, Green-0 is just like any black number, if the bet is on the number. So I am bundling Green-0 in the "BN" category.

The top strategy is:
8.1% on R16, 5.4% on R14, 48.6% on Red, and 37.8% on all Black numbers (i.e. 37.8% / 14 = 2.7% on each black number). The total of these bets comes to 100% of the bankroll, rounded to one place after the decimal point.

Who would have thought, eh? Totally non-intuitive, but makes sense with the "arbitrage" explanation.

Below is my code. I hope someone can verify the results in Excel, or with some other means.

Code:

package com.et.portfolio;

import java.text.*;
import java.util.*;

public class PromotionalRoulette {
    private static DecimalFormat df2, df6;

    public static void main(String[] args) {
        df2 = (DecimalFormat) NumberFormat.getNumberInstance();
        df2.setMinimumFractionDigits(1);
        df2.setMaximumFractionDigits(1);

        df6 = (DecimalFormat) NumberFormat.getNumberInstance();
        df6.setMinimumFractionDigits(7);
        df6.setMaximumFractionDigits(7);

        PromotionalRoulette promotionalRoulette = new PromotionalRoulette();
        promotionalRoulette.test();
    }

    class Strategy implements Comparable<Strategy> {
        private final double betR16, betR14, betRed, betBlackNumber;
        private final double result;

        Strategy(double betR16, double betR14, double betRed, double betBlackNumber, double result) {
            this.betR16 = betR16;
            this.betR14 = betR14;
            this.betRed = betRed;
            this.betBlackNumber = betBlackNumber;
            this.result = result;
        }

        @Override
        public int compareTo(Strategy other) {
            return Double.valueOf(other.result).compareTo(result);
        }

        @Override
        public String toString() {
            return "\t" + df2.format(betR16 * 100)
                + "\t\t" + df2.format(betR14 * 100)
                + "\t\t" + df2.format(betRed * 100)
                + "\t\t" + df2.format(betBlackNumber * 100)
                + "\t\t" + df6.format(result);
        }
    }

    private void test() {

        List<Strategy> strategies = new ArrayList<>();
        int numberOfTopStrategies = 10;
        double delta = 0.001;

        double pR16 = 4 / 37d;
        double pR14 = 3 / 37d;
        double pRed = 16 / 37d;
        double pBlackNumber = 14 / 37d;

        for (double r16 = 0; r16 <= 1; r16 += delta) {
            System.out.println(r16);
            for (double r14 = 0; r14 <= 1; r14 += delta) {
                for (double red = 0; red <= 1; red += delta) {
                    for (double blackNumber = 0; blackNumber <= 1; blackNumber += delta) {
                        if (r16 + r14 + red + blackNumber <= 1) {
                            double result = 0;
                            result += pR16 * Math.log1p(35 * r16 - r14 + red - blackNumber);                    // R16 hit
                            result += pR14 * Math.log1p(-r16 + 35 * r14 + red - blackNumber);                   // R14 hit
                            result += pRed * Math.log1p(-r16 - r14 + red - blackNumber);                        // Red hit
                            result += pBlackNumber * Math.log1p(-r16 - r14 - red + 35 * (blackNumber / 14.));   // Black number hit

                            if (result > 0) {
                                Strategy s = new Strategy(r16, r14, red, blackNumber, result);
                                strategies.add(s);
                                if (strategies.size() > numberOfTopStrategies) {
                                    Collections.sort(strategies);
                                    strategies.remove(strategies.size() - 1);
                                }
                            }
                        }
                    }
                }
            }
        }

        String header = "\tR16\t\tR14\t\tR\t\tBN\t\tF(R16,R14,R,BN)";
        System.out.println(header);
        for (Strategy s : strategies) {
            System.out.println(s);
        }
    }
}

 

So if R-12 comes up, you win -8.1-5.4+48.6-37.8 = −2.7%. IOW you lose 2.7% for 16 out of 37 spins. Hard to believe this beats a strategy that never loses, even when borrowing is disallowed.

 

You didn't say anything about not borrowing either. If I'm in a casino with a pure arbitrage in front of me, and I can't borrow against it, then I'm the world's worst salesman.

That said, it's a more interesting question mathematically without borrow.

And the above solution has the right aura about it.

 

I suggested earlier that the winner could easily be a blend of the pure arbitrage and the higher expectation non-arbitrage. That's what we got. Not surprising IMO.

 

Just for clarity, the above solution does not allow borrowing, i.e. it follows the original rules where the total bet can't exceed the current bankroll.

 

Incidentally, I confirm nonlinear5's results via Excel's solver.

And I definitely just fell out of love with the Excel solver. It couldn't optimize a by-hand sum of numbers, but when the same numbers were added via the internal SUM() function it suddenly got its shit together. Also, one of the solver algos got the wrong answer while the other one got it right. Now it feels more like a typical MSFT product

 

The strategy that you proposed multiplies the original bankroll by a factor of 3, after the 10 spins. The strategy that I calculated multiplies the original bankroll by a factor of 91, after the 10 spins. That's the payoff for the risk, which makes the rate of growth reach the max at the settings that I calculated.

 

Not sure that's right. My math says a Log10 increase per spin of 0.142... so 1.42... for 10 spins which is 10^1.42... = 26.63 multiplier.