Simulation code analyzing how mana bases affect mulligan decisions in Magic: the Gathering

color-aware-mull-strat-comparison.rs

use rand::prelude::*;
use std::collections::HashMap;
use std::fmt::Write;

#[derive(Copy, Clone, PartialEq, Eq)]
enum CardType {
    NonLand,
    Land,
    GoodLand,
}

#[derive(Copy, Clone)]
struct Deck {
    total_cards: u32,
    total_lands: u32,
    good_lands: u32
}

#[derive(Copy, Clone)]
struct OpeningHand {
    lands_in_hand: u32,
    good_lands_in_hand: u32,
}

// A mulligan strategy decides whether or not to keep a hand, and if so, which cards to bottom
type MullStrat = fn(OpeningHand, u32) -> Option<OpeningHand>;

impl Deck {
    fn new(total_cards: u32, total_lands: u32, good_lands: u32) -> Self {
        Deck { total_cards, total_lands, good_lands }
    }

    fn draw_card(&mut self, rng: &mut ThreadRng) -> CardType {
        let int_between_one_and_deck_size = rng.gen_range(0, self.total_cards) + 1;
        let good_land_cutoff = self.good_lands;
        let land_cutoff = self.total_lands;

        if int_between_one_and_deck_size <= good_land_cutoff {
            self.total_cards -= 1;
            self.total_lands -= 1;
            self.good_lands -= 1;

            CardType::GoodLand
        } else if int_between_one_and_deck_size > good_land_cutoff && int_between_one_and_deck_size <= land_cutoff {
            self.total_cards -= 1;
            self.total_lands -= 1;

            CardType::Land
        } else if int_between_one_and_deck_size > land_cutoff {
            self.total_cards -= 1;

            CardType::NonLand
        } else {
            unreachable!()
        }
    }

    fn draw_opening_hand(&mut self, rng: &mut ThreadRng) -> OpeningHand {
        let mut lands_in_hand = 0;
        let mut good_lands_in_hand = 0;

        for _ in 0..7 {
            match self.draw_card(rng) {
                CardType::GoodLand => {
                    lands_in_hand += 1;
                    good_lands_in_hand += 1;
                },
                CardType::Land => {
                    lands_in_hand += 1;
                },
                CardType::NonLand => {}
            }
        }

        OpeningHand {
            lands_in_hand,
            good_lands_in_hand
        }
    }
}

fn run_sim(deck_size: u32, land_count: u32, colored_sources: u32, mull_strategy: MullStrat, max_cmc: u32) {
    assert!(deck_size >= land_count);
    assert!(land_count >= colored_sources);

    const NUM_ITERATIONS: u32 = 10_000_000;
    let mut rng = thread_rng();

    let mut sum_of_all_starting_hand_sizes = 0;
    let mut freq_curve_out = vec![0u32; max_cmc as usize].into_boxed_slice();
    let mut freq_ok_to_cast = HashMap::new();

    for _ in 0..NUM_ITERATIONS {
        let mut deck = Deck::new(deck_size, land_count, colored_sources);

        let mut starting_hand_size = 7;
        let mut free_mulligan = deck_size == 99;

        let OpeningHand { mut lands_in_hand, mut good_lands_in_hand } = loop {
            let opened = deck.draw_opening_hand(&mut rng);

            if let Some(kept_hand) = mull_strategy(opened, starting_hand_size) {
                break kept_hand;
            }

            if free_mulligan {
                free_mulligan = false;
                continue;
            }

            starting_hand_size -= 1;
        };

        sum_of_all_starting_hand_sizes += starting_hand_size;

        for turn_allowed in 1..=max_cmc {
            if turn_allowed > 1 || deck_size == 99 {
                let card_type = deck.draw_card(&mut rng);
                if card_type != CardType::NonLand {
                    lands_in_hand += 1;
                    if card_type == CardType::GoodLand {
                        good_lands_in_hand += 1;
                    }
                }
            }

            if lands_in_hand >= turn_allowed {
                freq_curve_out[turn_allowed as usize - 1] += 1;
                for num_good_lands_needed in 1..=turn_allowed {
                    if good_lands_in_hand >= num_good_lands_needed {
                        *freq_ok_to_cast.entry((num_good_lands_needed, turn_allowed)).or_insert(0u32) += 1;
                    }
                }
            }
        }
    }

    print!("| {:7} | ", colored_sources);
    for turn_allowed in 1..=max_cmc {
        let count_conditional = freq_curve_out[turn_allowed as usize - 1];
        let consistency_cutoff = (90 + turn_allowed) as f64;

        for num_good_lands_needed in 1..=turn_allowed {
            let count_ok = freq_ok_to_cast[&(num_good_lands_needed, turn_allowed)];
            let percentage = count_ok as f64 / count_conditional as f64 * 100.0;

            if percentage >= consistency_cutoff {
                let highlighted = format!("**{:.2}%**", percentage);
                print!("{:11} | ", highlighted);
            } else {
                print!("{:10.2}% | ", percentage);
            }
        }
    }

    let mean_starting_hand_size = sum_of_all_starting_hand_sizes as f64 / NUM_ITERATIONS as f64;
    println!("{:4.3} cards |", mean_starting_hand_size);
}

fn naive_mulligan_strategy(opened: OpeningHand, starting_hand_size: u32) -> Option<OpeningHand> {
    let mut hand = opened;
    for _ in starting_hand_size..7 {
        if hand.lands_in_hand > starting_hand_size / 2 {
            hand.lands_in_hand -= 1;
            if hand.good_lands_in_hand > hand.lands_in_hand {
                hand.good_lands_in_hand -= 1;
            }
        }

        if hand.lands_in_hand < hand.good_lands_in_hand {
            dbg!(starting_hand_size);
            dbg!(hand.lands_in_hand);
            dbg!(hand.good_lands_in_hand);
        }

        assert!(hand.lands_in_hand >= hand.good_lands_in_hand);
    }

    match starting_hand_size {
        7 => {
            if hand.lands_in_hand < 2 || hand.lands_in_hand >= 6 {
                None
            } else {
                Some(hand)
            }
        },
        6 => {
            if hand.lands_in_hand < 2 || hand.lands_in_hand >= 5 {
                None
            } else {
                Some(hand)
            }
        },
        5 => {
            if hand.lands_in_hand == 0 || hand.lands_in_hand == 5 {
                None
            } else {
                Some(hand)
            }
        },
        _ => Some(hand)
    }
}

fn color_aware_mulligan_strategy(opened: OpeningHand, starting_hand_size: u32) -> Option<OpeningHand> {
    naive_mulligan_strategy(opened, starting_hand_size)
        .filter(|hand| starting_hand_size < 6 || hand.good_lands_in_hand >= 1)
}

fn print_table_header(max_cmc: u32) {
    print!("| Sources | ");
    for turn_allowed in 1..=max_cmc {
        for num_good_lands_needed in 1..=turn_allowed {
            let mut mana_cost = String::with_capacity(num_good_lands_needed as usize + 1);
            if turn_allowed > num_good_lands_needed {
                write!(&mut mana_cost, "{}", turn_allowed - num_good_lands_needed).unwrap();
            }
            for _ in 1..=num_good_lands_needed {
                mana_cost.push('C');
            }

            print!("{:11} | ", mana_cost);
        }
    }

    println!("mean hand   |");
    print!("|--------:|");
    for turn_allowed in 1..=max_cmc {
        for _ in 1..=turn_allowed {
            print!("------------:|");
        }
    }
    println!(":-----------|");
}

fn main() {
    println!("## Naive mulligan strategy");
    print_table_header(5);
    for colored_sources in 6..=24 {
        run_sim(60, 24, colored_sources, naive_mulligan_strategy, 5);
    }

    println!();
    println!("## Color-aware mulligan strategy");
    print_table_header(5);
    for colored_sources in 6..=24 {
        run_sim(60, 24, colored_sources, color_aware_mulligan_strategy, 5);
    }
}

colored-sources-mulligan-decisions.rs

const NUM_ITERATIONS: u32 = 5_000_000;

mod mono_color {
    #[derive(Copy, Clone, Eq, PartialEq)]
    enum CardType {
        NonLand,
        ColoredLand,
        ColorlessLand,
    }

    #[derive(Copy, Clone)]
    struct MonoColorDeck {
        total_cards: u32,
        total_lands: u32,
        color_lands: u32,
    }

    impl MonoColorDeck {
        fn new(deck_size: u32, total_lands: u32, colored_sources: u32) -> Self {
            MonoColorDeck {
                total_cards: deck_size,
                total_lands,
                color_lands: colored_sources,
            }
        }

        fn draw_card(&mut self) -> CardType {
            use rand::prelude::*;

            let mut rng = thread_rng();
            let random_int_between_one_and_deck_size = rng.gen_range(0, self.total_cards) + 1;

            if random_int_between_one_and_deck_size <= self.color_lands {
                self.color_lands -= 1;
                self.total_lands -= 1;
                self.total_cards -= 1;

                CardType::ColoredLand
            } else if random_int_between_one_and_deck_size <= self.total_lands {
                self.total_lands -= 1;
                self.total_cards -= 1;

                CardType::ColorlessLand
            } else {
                self.total_cards -= 1;
                CardType::NonLand
            }
        }

        fn draw_seven(&mut self) -> (u32, u32) {
            let mut lands_drawn_total = 0;
            let mut colored_lands_drawn = 0;

            for _ in 0..7 {
                let card_type = self.draw_card();
                if card_type != CardType::NonLand {
                    lands_drawn_total += 1;
                    if card_type == CardType::ColoredLand {
                        colored_lands_drawn += 1;
                    }
                }
            }

            (colored_lands_drawn, lands_drawn_total)
        }
    }

    fn run_sim(deck_size: u32, total_lands: u32) {
        use super::NUM_ITERATIONS;
        let conditions_on_total_lands = [2..=3, 2..=4, 3..=4];

        let consistency_cutoff = 0.95;
        let mut minima_one_or_more = [total_lands; 3];
        let mut minima_two_or_more = [total_lands; 3];

        for num_colored_sources in (1..total_lands).rev() {
            let mut count_one_or_more_colored_sources = [0, 0, 0];
            let mut count_two_or_more_colored_sources = [0, 0, 0];

            let mut count_conditional = [0, 0, 0];

            for _ in 0..NUM_ITERATIONS {
                let mut deck = MonoColorDeck::new(deck_size, total_lands, num_colored_sources);
                let (colored_lands_drawn, lands_drawn_total) = deck.draw_seven();

                for (i, condition) in conditions_on_total_lands.iter().enumerate() {
                    if condition.contains(&lands_drawn_total) {
                        count_conditional[i] += 1;
                        if colored_lands_drawn >= 1 {
                            count_one_or_more_colored_sources[i] += 1;
                            if colored_lands_drawn >= 2 {
                                count_two_or_more_colored_sources[i] += 1;
                            }
                        }
                    }
                }
            }

            let mut all_freqs_below_cutoff = true;

            for i in 0..3 {
                let count_one_or_more = count_one_or_more_colored_sources[i];
                let count_two_or_more = count_two_or_more_colored_sources[i];

                let freq_one_or_more = count_one_or_more as f64 / count_conditional[i] as f64;
                let freq_two_or_more = count_two_or_more as f64 / count_conditional[i] as f64;

                if freq_one_or_more >= consistency_cutoff {
                    minima_one_or_more[i] = num_colored_sources;
                    all_freqs_below_cutoff = false;
                }

                if freq_two_or_more >= consistency_cutoff {
                    minima_two_or_more[i] = num_colored_sources;
                    all_freqs_below_cutoff = false;
                }
            }

            if all_freqs_below_cutoff {
                break;
            }
        }

        print!("| {:5} | ", total_lands);
        print!("{:4} / {:2} | ", minima_one_or_more[0], minima_two_or_more[0]);
        print!("{:4} / {:2} | ", minima_one_or_more[1], minima_two_or_more[1]);
        print!("{:4} / {:2} |", minima_one_or_more[2], minima_two_or_more[2]);
        println!();
    }

    pub fn run_all_sims() {
        println!("# Mono-colored decks");
        println!("## Limited decks (40 cards)");
        println!("| Lands | 2-3 lands | 2-4 lands | 3-4 lands |");
        println!("|------:|----------:|----------:|----------:|");
        for num_lands in 10..=20 {
            run_sim(40, num_lands);
        }

        println!();
        println!("## Constructed decks (60 cards)");
        println!("| Lands | 2-3 lands | 2-4 lands | 3-4 lands |");
        println!("|------:|----------:|----------:|----------:|");
        for num_lands in 15..=30 {
            run_sim(60, num_lands);
        }

        println!();
        println!("## Yorion decks (80 cards)");
        println!("| Lands | 2-3 lands | 2-4 lands | 3-4 lands |");
        println!("|------:|----------:|----------:|----------:|");
        for num_lands in 20..=40 {
            run_sim(80, num_lands);
        }

        println!();
        println!("## Commander decks (99 cards)");
        println!("| Lands | 2-3 lands | 2-4 lands | 3-4 lands |");
        println!("|------:|----------:|----------:|----------:|");
        for num_lands in 24..=49 {
            run_sim(99, num_lands);
        }
    }
}

mod dual_color {
    use rand::{thread_rng, Rng};

    #[derive(Copy, Clone, Eq, PartialEq)]
    enum CardType {
        NonLand,
        ColorlessLand,
        MonoColorLandA,
        MonoColorLandB,
        DualColorLand,
    }

    #[derive(Copy, Clone)]
    struct Deck {
        total_cards: u32,
        cards_by_card_type: [u32; 5],
    }

    impl Deck {
        fn new(total_cards: u32, colorless_sources: u32, colored_sources_a: u32, colored_sources_b: u32, two_color_sources: u32) -> Self {
            let non_land_cards = total_cards - (colorless_sources + colored_sources_a + colored_sources_b + two_color_sources);

            Deck {
                total_cards,
                cards_by_card_type: [non_land_cards, colorless_sources, colored_sources_a, colored_sources_b, two_color_sources],
            }
        }

        fn draw_card(&mut self) -> CardType {
            let mut rng = thread_rng();
            let mut random_int_between_one_and_deck_size = rng.gen_range(0, self.total_cards) + 1;

            if random_int_between_one_and_deck_size <= self.cards_by_card_type[0] {
                self.total_cards -= 1;
                self.cards_by_card_type[0] -= 1;

                return CardType::NonLand;
            }

            random_int_between_one_and_deck_size -= self.cards_by_card_type[0];
            if random_int_between_one_and_deck_size <= self.cards_by_card_type[1] {
                self.total_cards -= 1;
                self.cards_by_card_type[1] -= 1;

                return CardType::ColorlessLand;
            }

            random_int_between_one_and_deck_size -= self.cards_by_card_type[1];
            if random_int_between_one_and_deck_size <= self.cards_by_card_type[2] {
                self.total_cards -= 1;
                self.cards_by_card_type[2] -= 1;

                return CardType::MonoColorLandA;
            }

            random_int_between_one_and_deck_size -= self.cards_by_card_type[2];
            if random_int_between_one_and_deck_size <= self.cards_by_card_type[3] {
                self.total_cards -= 1;
                self.cards_by_card_type[3] -= 1;

                return CardType::MonoColorLandB;
            }

            random_int_between_one_and_deck_size -= self.cards_by_card_type[3];
            if random_int_between_one_and_deck_size <= self.cards_by_card_type[4] {
                self.total_cards -= 1;
                self.cards_by_card_type[4] -= 1;

                return CardType::DualColorLand;
            }

            unreachable!()
        }
    }

    fn run_sim(deck_size: u32, land_count: u32, max_off_color_land_count: u32, off_color_land_count_step: usize) {
        use super::NUM_ITERATIONS;
        let conditions_on_total_lands = [2..=3, 2..=4, 3..=4];

        print!("| {:5} |", land_count);
        for num_off_color_lands in (0..=max_off_color_land_count).into_iter().step_by(off_color_land_count_step) {
            let num_on_color_lands = land_count - num_off_color_lands;

            let mut num_duals_minima = [u32::max_value(); 3];

            for num_dual_lands in (0..=num_on_color_lands).rev() {
                let other_lands = num_on_color_lands - num_dual_lands;
                let num_mono_color_lands_b = other_lands / 2;
                let num_mono_color_lands_a = other_lands - num_mono_color_lands_b;

                let mut count_conditional = [0; 3];
                let mut count_ok = [0; 3];

                for _ in 0..NUM_ITERATIONS {
                    let mut deck = Deck::new(
                        deck_size,
                        num_off_color_lands,
                        num_mono_color_lands_a,
                        num_mono_color_lands_b,
                        num_dual_lands);

                    let mut total_lands_drawn = 0;
                    let mut sources_drawn_a = 0;
                    let mut sources_drawn_b = 0;

                    for _ in 0..7 {
                        let card_type = deck.draw_card();

                        if card_type != CardType::NonLand {
                            total_lands_drawn += 1;
                            if card_type == CardType::MonoColorLandA || card_type == CardType::DualColorLand {
                                sources_drawn_a += 1;
                            }
                            if card_type == CardType::MonoColorLandB || card_type == CardType::DualColorLand {
                                sources_drawn_b += 1;
                            }
                        }
                    }

                    for (i, condition) in conditions_on_total_lands.iter().enumerate() {
                        if condition.contains(&total_lands_drawn) {
                            count_conditional[i] += 1;
                            if sources_drawn_a > 0 && sources_drawn_b > 0 {
                                count_ok[i] += 1;
                            }
                        }
                    }
                }

                let mut all_failed = true;
                for (i, (count_ok, count_conditional)) in count_ok.iter().zip(count_conditional.iter()).enumerate() {
                    let freq_ok = *count_ok as f64 / *count_conditional as f64;
                    if freq_ok > 0.95 {
                        num_duals_minima[i] = num_dual_lands;
                        all_failed = false;
                    }
                }

                if all_failed { break; }
            }

            print!(" {:2} / {:2} / {:2} |", num_duals_minima[0], num_duals_minima[1], num_duals_minima[2]);
        }

        println!();
    }

    pub fn run_all_sims() {
        println!("# Two-color Manabases");
        println!("## Limited decks (40 cards):");
        println!("| Lands | 0 off-color  | 1 off-color  | 2 off-color  | 3 off-color  |");
        println!("|------:|-------------:|-------------:|-------------:|-------------:|");
        for land_count in 10..=20 {
            run_sim(40, land_count, 3, 1);
        }

        println!();
        println!("## Constructed decks (60 cards):");
        println!("| Lands | 0 off-color  | 1 off-color  | 2 off-color  | 3 off-color  | 4 off-color  |");
        println!("|------:|-------------:|-------------:|-------------:|-------------:|-------------:|");
        for land_count in 15..=30 {
            run_sim(60, land_count, 4, 1);
        }

        println!();
        println!("## Yorion decks (80 cards):");
        println!("| Lands | 0 off-color  | 1 off-color  | 2 off-color  | 3 off-color  | 4 off-color  |");
        println!("|------:|-------------:|-------------:|-------------:|-------------:|-------------:|");
        for land_count in 20..=40 {
            run_sim(80, land_count, 4, 1);
        }

        println!();
        println!("## Commander decks (99 cards):");
        println!("| Lands | 0 off-color  | 2 off-color  | 4 off-color  | 6 off-color  | 8 off-color  |");
        println!("|------:|-------------:|-------------:|-------------:|-------------:|-------------:|");
        for land_count in 24..=49 {
            run_sim(99, land_count, 8, 2);
        }
    }
}

mod three_colors {
    use rand::Rng;

    #[repr(usize)]
    #[derive(Copy, Clone, Eq, PartialEq)]
    enum CardType {
        NonLand = 0,
        FabledPassage = 1,
        BasicLandA = 2,
        BasicLandB = 3,
        BasicLandC = 4,
        DualLandAB = 5,
        DualLandAC = 6,
        DualLandBC = 7,
        TriLand = 8,
    }

    #[derive(Copy, Clone)]
    struct Deck {
        total_cards: u32,
        num_cards_by_type: [u32; 9]
    }

    impl Deck {
        fn with_balanced_duals(deck_size: u32, land_count: u32, num_tri_lands: u32) -> Deck {
            let non_land_cards = deck_size - land_count;
            let other_lands = land_count - num_tri_lands;

            let dual_lands_ab = other_lands / 3 + if other_lands % 3 > 0 { 1 } else { 0 };
            let dual_lands_ac = other_lands / 3 + if other_lands % 3 > 1 { 1 } else { 0 };
            let dual_lands_bc = other_lands / 3;

            assert_eq!(land_count, dual_lands_ab + dual_lands_ac + dual_lands_bc + num_tri_lands);

            Deck {
                total_cards: deck_size,
                num_cards_by_type: [non_land_cards, 0, 0, 0, 0, dual_lands_ab, dual_lands_ac, dual_lands_bc, num_tri_lands],
            }
        }

        fn with_skewed_duals(deck_size: u32, land_count: u32, num_tri_lands: u32) -> Deck {
            let non_land_cards = deck_size - land_count;
            let other_lands = land_count - num_tri_lands;

            let dual_lands_ab = other_lands / 2;
            let dual_lands_ac = other_lands - dual_lands_ab;

            assert_eq!(land_count, num_tri_lands + dual_lands_ab + dual_lands_ac);

            Deck {
                total_cards: deck_size,
                num_cards_by_type: [non_land_cards, 0, 0, 0, 0, dual_lands_ab, dual_lands_ac, 0, num_tri_lands],
            }
        }

        fn with_basics_and_fabled_passage(deck_size: u32, land_count: u32, num_tri_lands: u32) -> Deck {
            let non_land_cards = deck_size - land_count;
            let other_lands = land_count - (num_tri_lands + 10); // account for Fabled Passage + fetchable basics

            let dual_lands_ab = other_lands / 3 + if other_lands % 3 > 0 { 1 } else { 0 };
            let dual_lands_ac = other_lands / 3 + if other_lands % 3 > 1 { 1 } else { 0 };
            let dual_lands_bc = other_lands / 3;

            assert_eq!(land_count, num_tri_lands + dual_lands_ab + dual_lands_ac + dual_lands_bc + 10);

            Deck {
                total_cards: deck_size,
                num_cards_by_type: [non_land_cards, 4, 2, 2, 2, dual_lands_ab, dual_lands_ac, dual_lands_bc, num_tri_lands],
            }
        }

        fn with_basics_and_fetch_lands(deck_size: u32, land_count: u32, num_basics: u32) -> Deck {
            // For simplicity, we'll count proper fetches as tri-lands,
            // since they're just as good at fixing opening hands as long as there's no colorless lands

            let non_land_cards = deck_size - land_count;

            let other_lands = land_count - (8 + num_basics);
            let dual_lands_ab = other_lands / 3 + if other_lands % 3 > 0 { 1 } else { 0 };
            let dual_lands_ac = other_lands / 3 + if other_lands % 3 > 1 { 1 } else { 0 };
            let dual_lands_bc = other_lands / 3;

            let basics = if num_basics == 5 {
                (3, 1, 1)
            } else if num_basics == 6 {
                (2, 2, 2)
            } else {
                unreachable!()
            };

            assert_eq!(land_count, 8 + num_basics + dual_lands_ab + dual_lands_ac + dual_lands_bc);

            Deck {
                total_cards: deck_size,
                num_cards_by_type: [non_land_cards, 0, basics.0, basics.1, basics.2, dual_lands_ab, dual_lands_ac, dual_lands_bc, 8],
            }
        }

        fn draw_card(&mut self) -> CardType {
            let mut random_int_between_one_and_deck_size = rand::thread_rng().gen_range(0, self.total_cards) + 1;

            for (idx, count) in self.num_cards_by_type.iter_mut().enumerate() {
                if random_int_between_one_and_deck_size <= *count {
                    self.total_cards -= 1;
                    *count -= 1;

                    return unsafe { std::mem::transmute(idx) };
                }

                random_int_between_one_and_deck_size -= *count;
            }

            unreachable!()
        }

        fn draw_seven(&mut self) -> (u32, bool) {
            let mut total_lands_drawn = 0;
            let mut sources_drawn_a = 0;
            let mut sources_drawn_b = 0;
            let mut sources_drawn_c = 0;
            let mut passages_drawn = 0;

            for _ in 0..7 {
                use CardType::*;

                let card_type = self.draw_card();
                if card_type == NonLand { continue; }
                total_lands_drawn += 1;

                if card_type == FabledPassage {
                    passages_drawn += 1;
                }

                if card_type == BasicLandA || card_type == DualLandAB || card_type == DualLandAC || card_type == TriLand {
                    sources_drawn_a += 1;
                }

                if card_type == BasicLandB || card_type == DualLandAB || card_type == DualLandBC || card_type == TriLand {
                    sources_drawn_b += 1;
                }

                if card_type == BasicLandC || card_type == DualLandAC || card_type == DualLandBC || card_type == TriLand {
                    sources_drawn_c += 1;
                }
            }

            while passages_drawn > 0 {
                passages_drawn -= 1;

                if sources_drawn_a == 0 {
                    sources_drawn_a += 1;
                } else if sources_drawn_b == 0 {
                    sources_drawn_b += 1;
                } else {
                    sources_drawn_c += 1;
                }
            }

            let has_all_colors = sources_drawn_a > 0 && sources_drawn_b > 0 && sources_drawn_c > 0;
            (total_lands_drawn, has_all_colors)
        }
    }

    fn run_sim(deck_size: u32, land_count: u32, num_tri_lands_to_compare_to_zero: u32) {
        let decks_to_test = [
            Deck::with_balanced_duals(deck_size, land_count, 0),
            Deck::with_balanced_duals(deck_size, land_count, num_tri_lands_to_compare_to_zero),
            Deck::with_skewed_duals(deck_size, land_count, 0),
            Deck::with_skewed_duals(deck_size, land_count, num_tri_lands_to_compare_to_zero),
            Deck::with_basics_and_fabled_passage(deck_size, land_count, 0),
            Deck::with_basics_and_fabled_passage(deck_size, land_count, 4),
            Deck::with_basics_and_fetch_lands(deck_size, land_count, 5),
            Deck::with_basics_and_fetch_lands(deck_size, land_count, 6),
        ];

        let conditions_on_lands_in_hand = [2..=3, 2..=4, 3..=4];

        print!("| {:5} |", land_count);
        for deck_to_test in &decks_to_test {
            let mut count_conditional = [0; 3];
            let mut count_ok = [0; 3];

            for _ in 0..super::NUM_ITERATIONS {
                let mut deck = *deck_to_test;
                assert_eq!(deck.total_cards, deck_size);

                let (total_lands_drawn, has_all_colors) = deck.draw_seven();

                for (i, condition) in conditions_on_lands_in_hand.iter().enumerate() {
                    if condition.contains(&total_lands_drawn) {
                        count_conditional[i] += 1;
                        if has_all_colors {
                            count_ok[i] += 1;
                        }
                    }
                }
            }

            let freq_ok = count_ok[0] as f64 / count_conditional[0] as f64 * 100.0;
            print!(" {:5.1}% / ", freq_ok);

            let freq_ok = count_ok[1] as f64 / count_conditional[1] as f64 * 100.0;
            print!("{:5.1}% / ", freq_ok);

            let freq_ok = count_ok[2] as f64 / count_conditional[2] as f64 * 100.0;
            print!("{:5.1}% |", freq_ok)
        }

        println!();
    }

    pub fn run_all_sims() {
        println!("# Tri-color Manabases");
        println!("## Constructed decks (60 cards):");
        println!("| Lands | even duals, no triomes   | even duals, 4 triomes    | skewed duals, no triomes | skewed duals, 4 triomes  | Passage, no triomes      | Passage, 4 triomes       | 8 Fetches, 5 Basics      | 8 Fetches, 6 Basics      |");
        println!("|------:|-------------------------:|-------------------------:|-------------------------:|-------------------------:|-------------------------:|--------------------------|-------------------------:|-------------------------:|");
        for land_count in 20..=30 {
            run_sim(60, land_count, 4);
        }
    }
}

fn main() {
    mono_color::run_all_sims();
    dual_color::run_all_sims();
    three_colors::run_all_sims();
}

mull-baseline.rs

extern crate rand;
use rand::prelude::*;
use std::ops::RangeInclusive;

struct Deck {
    total_cards: u32,
    land_cards: u32,
}

#[derive(Copy, Clone, PartialEq, Eq)]
enum CardType {
    Land,
    Spell
}

impl Deck {
    fn new(deck_size: u32, land_count: u32) -> Self {
        Deck {
            total_cards: deck_size,
            land_cards: land_count,
        }
    }

    fn draw_card(&mut self, rng: &mut ThreadRng) -> CardType {
        let random_int_between_one_and_total_cards = rng.gen_range(0, self.total_cards) + 1;

        if random_int_between_one_and_total_cards <= self.land_cards {
            self.total_cards -= 1;
            self.land_cards -= 1;

            CardType::Land
        } else {
            self.total_cards -= 1;

            CardType::Spell
        }
    }
}

fn run_sim(deck_size: u32, land_count: u32, turns_allowed: u32, mull_strategy: &[RangeInclusive<u32>]) {
    const NUM_ITERATIONS: u32 = 10_000_000;

    assert!(turns_allowed <= 7);

    let mut land_drops_hit = [vec![0; turns_allowed as usize].into_boxed_slice(), vec![0; turns_allowed as usize].into_boxed_slice()];
    let mut count_mana_flooded = 0;
    let mut sum_of_all_starting_hand_sizes = 0;

    let mut rng = rand::thread_rng();

    let first_turn_to_draw_max = if deck_size == 99 { 1 } else { 2 };
    for first_turn_to_draw in 1..=first_turn_to_draw_max {
        for _ in 0..NUM_ITERATIONS {
            let mut deck = Deck::new(deck_size, land_count);

            let mut starting_hand_size = 7;
            let mut lands_in_hand = 0;
            let mut lands_in_play = 0;

            let mut free_mulligan = deck_size == 99;
            loop {
                for _ in 0..7 {
                    let card_type = deck.draw_card(&mut rng);
                    if card_type == CardType::Land {
                        lands_in_hand += 1;
                    }
                }

                for _ in starting_hand_size..7 {
                    if lands_in_hand > starting_hand_size / 2 {
                        lands_in_hand -= 1;
                    }
                }

                if starting_hand_size == 4 || mull_strategy[7 - starting_hand_size as usize].contains(&lands_in_hand) {
                    break;
                }

                if free_mulligan {
                    free_mulligan = false;
                    continue;
                }

                starting_hand_size -= 1;
            }

            assert!(starting_hand_size >= 4);
            sum_of_all_starting_hand_sizes += starting_hand_size;

            for turn in 1..=7 {
                if turn >= first_turn_to_draw {
                    let card_type = deck.draw_card(&mut rng);
                    if card_type == CardType::Land {
                        lands_in_hand += 1;
                    }
                }

                if lands_in_hand > 0 {
                    lands_in_hand -= 1;
                    lands_in_play += 1;
                }

                if lands_in_play == turn && lands_in_play <= turns_allowed {
                    land_drops_hit[first_turn_to_draw as usize - 1][turn as usize - 1] += 1;
                }
            }

            if first_turn_to_draw == 1 && lands_in_play + lands_in_hand >= 8 {
                count_mana_flooded += 1;
            }
        }
    }

    print!("| {:5} | ", land_count);
    for i in 2..turns_allowed as usize {
        if deck_size == 99 {
            let freq = land_drops_hit[0][i] as f64 / NUM_ITERATIONS as f64 * 100.0;
            print!("{:15.2}% | ", freq);
        } else {
            let freq_on_the_play = land_drops_hit[0][i] as f64 / NUM_ITERATIONS as f64 * 100.0;
            let freq_on_the_draw = land_drops_hit[1][i] as f64 / NUM_ITERATIONS as f64 * 100.0;
            print!(" {:6.2}% / {:6.2}% | ", freq_on_the_play, freq_on_the_draw);
        }
    }

    let total_sims_run = if deck_size == 99 { NUM_ITERATIONS } else { 2 * NUM_ITERATIONS };
    let avg_starting_hand_size = sum_of_all_starting_hand_sizes as f64 / total_sims_run as f64;
    let freq_mana_flooded_on_the_draw = count_mana_flooded as f64 / NUM_ITERATIONS as f64 * 100.0;

    println!("{:.3} cards |            {:5.1}% |", avg_starting_hand_size, freq_mana_flooded_on_the_draw);
}

fn main() {
    let mull_strategy = &[2..=5, 2..=4, 1..=4, 0..=4];

    println!("## Limited decks (40 cards):");
    println!("| Lands |  P(3 lands on T3)  |  P(4 lands on T4)  |  P(5 lands on T5)  | mean hand   | P(8+ lands on T7) |");
    println!("|------:|-------------------:|-------------------:|-------------------:|:------------|------------------:|");
    for land_count in 10..=20 {
        run_sim(40, land_count, 5, mull_strategy);
    }

    println!();
    println!("## Constructed decks (60 cards):");
    println!("| Lands |  P(3 lands on T3)  |  P(4 lands on T4)  |  P(5 lands on T5)  | mean hand   | P(8+ lands on T7) |");
    println!("|------:|-------------------:|-------------------:|-------------------:|:------------|------------------:|");
    for land_count in 15..=30 {
        run_sim(60, land_count, 5, mull_strategy);
    }

    println!();
    println!("## Yorion decks (80 cards):");
    println!("| Lands |  P(3 lands on T3)  |  P(4 lands on T4)  |  P(5 lands on T5)  | mean hand   | P(8+ lands on T7) |");
    println!("|------:|-------------------:|-------------------:|-------------------:|:------------|------------------:|");
    for land_count in 20..=40 {
        run_sim(80, land_count, 5, mull_strategy);
    }

    println!();
    println!("## Commander decks (99 cards):");
    println!("| Lands | P(3 lands on T3) | P(4 lands on T4) | P(5 lands on T5) | P(6 lands on T6) | mean hand   | P(8+ lands on T7) |");
    println!("|------:|-----------------:|-----------------:|-----------------:|-----------------:|:------------|------------------:|");
    for land_count in 24..=49 {
        run_sim(99, land_count, 6, mull_strategy);
    }
}

mull-strat-comparison-landcount.rs

use rand::prelude::*;

#[derive(Copy, Clone, PartialEq, Eq)]
enum CardType {
    NonLand,
    Land,
}

#[derive(Copy, Clone)]
struct Deck {
    total_cards: u32,
    total_lands: u32,
}

#[derive(Copy, Clone)]
struct OpeningHand {
    lands_in_hand: u32,
}

// A mulligan strategy decides whether or not to keep a hand, and if so, which cards to bottom
type MullStrat = fn(OpeningHand, u32) -> Option<OpeningHand>;

impl Deck {
    fn new(total_cards: u32, total_lands: u32) -> Self {
        Deck { total_cards, total_lands }
    }

    fn draw_card(&mut self, rng: &mut ThreadRng) -> CardType {
        let int_between_one_and_deck_size = rng.gen_range(0, self.total_cards) + 1;
        let land_cutoff = self.total_lands;

        if int_between_one_and_deck_size <= land_cutoff {
            self.total_cards -= 1;
            self.total_lands -= 1;

            CardType::Land
        } else if int_between_one_and_deck_size > land_cutoff {
            self.total_cards -= 1;

            CardType::NonLand
        } else {
            unreachable!()
        }
    }

    fn draw_opening_hand(&mut self, rng: &mut ThreadRng) -> OpeningHand {
        let mut lands_in_hand = 0;

        for _ in 0..7 {
            match self.draw_card(rng) {
                CardType::Land => {
                    lands_in_hand += 1;
                },
                CardType::NonLand => {}
            }
        }

        OpeningHand {
            lands_in_hand,
        }
    }
}

fn run_sim(deck_size: u32, land_count: u32, mull_strategy: MullStrat, lands_needed_to_function: u32) {
    assert!(deck_size >= land_count);

    const NUM_ITERATIONS: u32 = 5_000_000;
    let mut rng = thread_rng();

    let mut sum_of_all_starting_hand_sizes = 0;
    let mut count_cards_kept = [0, 0, 0, 0];

    // we want to get some measure of flooding;
    // getting one more land on curve than we _need_ to function is nice,
    // getting another two in close proximity is our definition of flood
    let max_cmc = lands_needed_to_function + 3;

    let mut freq_curve_out = [
        vec![0u32; max_cmc as usize].into_boxed_slice(),
        vec![0u32; max_cmc as usize].into_boxed_slice()
    ];
    let mut freq_flooded = 0;

    let first_turn_to_draw_max = if deck_size == 99 { 1 } else { 2 };
    for first_turn_to_draw in 1..=first_turn_to_draw_max {
        for _ in 0..NUM_ITERATIONS {
            let mut deck = Deck::new(deck_size, land_count);

            let mut starting_hand_size = 7;
            let mut free_mulligan = deck_size == 99;

            let OpeningHand { mut lands_in_hand } = loop {
                let opened = deck.draw_opening_hand(&mut rng);

                if let Some(kept_hand) = mull_strategy(opened, starting_hand_size) {
                    break kept_hand;
                }

                if free_mulligan {
                    free_mulligan = false;
                    continue;
                }

                starting_hand_size -= 1;
            };

            sum_of_all_starting_hand_sizes += starting_hand_size;
            count_cards_kept[7 - starting_hand_size as usize] += 1;

            let mut lands_in_play = 0;

            for turn in 1..=max_cmc {
                if turn >= first_turn_to_draw {
                    if deck.draw_card(&mut rng) == CardType::Land {
                        lands_in_hand += 1;
                    }
                }

                if lands_in_hand >= 1 {
                    lands_in_play += 1;
                    lands_in_hand -= 1;

                    assert!(lands_in_play <= turn)
                }

                if lands_in_play == turn {
                    freq_curve_out[first_turn_to_draw as usize - 1][turn as usize - 1] += 1;
                }
            }

            if first_turn_to_draw == 1 && lands_in_play + lands_in_hand > max_cmc {
                freq_flooded += 1;
            }
        }
    }

    let total_iterations = if deck_size == 99 { NUM_ITERATIONS } else { 2 * NUM_ITERATIONS };

    print!("| {:5} | ", land_count);

    for count in &count_cards_kept {
        let percentage = *count as f64 / total_iterations as f64 * 100.0;
        print!("{:7.2}% | ", percentage);
    }

    for turn in lands_needed_to_function..=(lands_needed_to_function + 1) {
        let count_curved_out_on_the_draw = freq_curve_out[0][turn as usize - 1];
        let count_curved_out_on_the_play = freq_curve_out[1][turn as usize - 1];

        let percentage_on_the_draw = count_curved_out_on_the_draw as f64 / NUM_ITERATIONS as f64 * 100.0;
        let percentage_on_the_play = count_curved_out_on_the_play as f64 / NUM_ITERATIONS as f64 * 100.0;

        if deck_size == 99 {
            print!("          {:6.2}% | ", percentage_on_the_draw);
        } else {
            print!("{:6.2}% / {:6.2}% | ", percentage_on_the_draw, percentage_on_the_play);
        }
    }

    let mean_starting_hand_size = sum_of_all_starting_hand_sizes as f64 / total_iterations as f64;
    let percentage_mana_flooded = freq_flooded as f64 / NUM_ITERATIONS as f64 * 100.0;
    println!("{:4.3} cards | {:16.2}% |", mean_starting_hand_size, percentage_mana_flooded);
}

fn low_curve_mulligan_strategy(opened: OpeningHand, starting_hand_size: u32) -> Option<OpeningHand> {
    let lands_opened = opened.lands_in_hand;
    match starting_hand_size {
        7 => {
            if lands_opened < 2 || lands_opened > 3 {
                None
            } else {
                Some(opened)
            }
        },
        6 => {
            if lands_opened < 2 || lands_opened > 4 {
                None
            } else if lands_opened < 4 {
                Some(opened) // bottom a spell
            } else if lands_opened == 4 {
                Some(OpeningHand { lands_in_hand: 3 }) // bottom a land
            } else {
                unreachable!()
            }
        },
        5 => {
            if lands_opened == 0 || lands_opened > 5 {
                None
            } else if lands_opened == 5 {
                Some(OpeningHand { lands_in_hand: 3 })
            } else if lands_opened >= 3 { // opened 3, 4 or 5 lands, keep 2
                Some(OpeningHand { lands_in_hand: 2 })
            } else { // opened 1 or 2 lands, bottom spells
                Some(OpeningHand { lands_in_hand: lands_opened })
            }
        },
        4 => {
            if lands_opened >= 5 {
                Some(OpeningHand { lands_in_hand: lands_opened - 3 })
            } else if lands_opened >= 2 {
                Some(OpeningHand { lands_in_hand: 2 })
            } else {
                Some(opened)
            }
        },
        _ => unreachable!()
    }
}

fn midrange_mulligan_strategy(opened: OpeningHand, starting_hand_size: u32) -> Option<OpeningHand> {
    let lands_opened = opened.lands_in_hand;
    match starting_hand_size {
        7 => {
            if lands_opened < 2 || lands_opened > 4 {
                None
            } else {
                Some(opened)
            }
        },
        6 => {
            if lands_opened < 2 || lands_opened > 5 {
                None
            } else if lands_opened < 4 {
                Some(opened) // bottom a spell
            } else if lands_opened <= 5 {
                Some(OpeningHand { lands_in_hand: lands_opened - 1 }) // bottom a land
            } else {
                unreachable!()
            }
        },
        5 => {
            if lands_opened == 0 || lands_opened > 6 {
                None
            } else if lands_opened <= 3 {
                Some(opened)
            } else if lands_opened == 4 {
                Some(OpeningHand { lands_in_hand: 3 })
            } else { // opened 5 or 6 lands, bottom 2 of them
                Some(OpeningHand { lands_in_hand: 4 })
            }
        },
        4 => {
            if lands_opened >= 5 {
                Some(OpeningHand { lands_in_hand: lands_opened - 3 })
            } else if lands_opened <= 2 {
                Some(opened) // bottom spells
            } else { // opened 3 or 4 lands, go down to 2
                Some(OpeningHand { lands_in_hand: 2 })
            }
        },
        _ => unreachable!()
    }
}

fn high_curve_mulligan_strategy(opened: OpeningHand, starting_hand_size: u32) -> Option<OpeningHand> {
    let lands_opened = opened.lands_in_hand;
    match starting_hand_size {
        7 => {
            if lands_opened < 3 || lands_opened > 4 {
                None
            } else {
                Some(opened)
            }
        },
        6 => {
            if lands_opened < 2 || lands_opened > 5 {
                None
            } else if lands_opened <= 4 {
                Some(opened) // bottom a spell
            } else {
                Some(OpeningHand { lands_in_hand: lands_opened - 1 })
            }
        },
        5 => {
            if lands_opened <= 1 || lands_opened == 7 {
                None
            } else if lands_opened < 4 {
                Some(OpeningHand { lands_in_hand: lands_opened })
            } else {
                Some(OpeningHand { lands_in_hand: 4 })
            }
        },
        4 => {
            if lands_opened >= 6 {
                Some(OpeningHand { lands_in_hand: lands_opened - 3 })
            } else if lands_opened >= 3 {
                Some(OpeningHand { lands_in_hand: 2 })
            } else {
                Some(opened)
            }
        },
        _ => unreachable!()
    }
}

fn print_table_header(lands_needed_to_function: u32) {
    print!("| Lands | ");
    print!("P(S = 7) | ");
    print!("P(S = 6) | ");
    print!("P(S = 5) | ");
    print!("P(S = 4) | ");
    print!("P({0} lands on T{0})  | ", lands_needed_to_function);
    print!("P({0} lands on T{0})  | ", lands_needed_to_function + 1);
    print!("mean hand   | ");
    println!("P({}+ lands on T{}) |", lands_needed_to_function + 4, lands_needed_to_function + 3);

    print!("|------:|");
    print!("---------:|");
    print!("---------:|");
    print!("---------:|");
    print!("---------:|");
    print!("------------------:|");
    print!("------------------:|");
    print!(":------------|");
    println!("------------------:|");
}

fn main() {
    println!("## Low-curve mulligan strategy");
    println!("### Limited decks (40 cards):");
    print_table_header(2);
    for land_count in 10..=20 {
        run_sim(40, land_count, low_curve_mulligan_strategy, 2);
    }
    println!("### Constructed decks (60 cards):");
    print_table_header(2);
    for land_count in 15..=30 {
        run_sim(60, land_count, low_curve_mulligan_strategy, 2);
    }
    println!("### Constructed decks (80 cards):");
    print_table_header(2);
    for land_count in 20..=40 {
        run_sim(80, land_count, low_curve_mulligan_strategy, 2);
    }
    println!("### Commander decks (99 cards):");
    print_table_header(2);
    for land_count in 24..=49 {
        run_sim(99, land_count, low_curve_mulligan_strategy, 2);
    }

    println!();
    println!("## Midrange mulligan strategy");
    println!("### Limited decks (40 cards):");
    print_table_header(3);
    for land_count in 10..=20 {
        run_sim(40, land_count, midrange_mulligan_strategy, 3);
    }
    println!("### Constructed decks (60 cards):");
    print_table_header(3);
    for land_count in 15..=30 {
        run_sim(60, land_count, midrange_mulligan_strategy, 3);
    }
    println!("### Yorion decks (80 cards):");
    print_table_header(3);
    for land_count in 20..=40 {
        run_sim(80, land_count, midrange_mulligan_strategy, 3);
    }
    println!("### Commander decks (99 cards):");
    print_table_header(3);
    for land_count in 24..=49 {
        run_sim(99, land_count, midrange_mulligan_strategy, 3);
    }

    println!();
    println!("## High-curve mulligan strategy");
    println!("### Limited decks (40 cards):");
    print_table_header(4);
    for land_count in 13..=24 {
        run_sim(40, land_count, high_curve_mulligan_strategy, 4);
    }
    println!("### Constructed decks (60 cards):");
    print_table_header(4);
    for land_count in 20..=36 {
        run_sim(60, land_count, high_curve_mulligan_strategy, 4);
    }
    println!("### Yorion decks (80 cards):");
    print_table_header(4);
    for land_count in 25..=48 {
        run_sim(80, land_count, high_curve_mulligan_strategy, 4);
    }
    println!("### Commander decks (99 cards):");
    print_table_header(4);
    for land_count in 33..=50 {
        run_sim(99, land_count, high_curve_mulligan_strategy, 4);
    }
}

mull-strat-comparison-landcounts.md

Low-curve mulligan strategy

Limited decks (40 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(2 lands on T2)	P(3 lands on T3)	mean hand	P(6+ lands on T5)
10	52.08%	29.37%	17.27%	1.28%	97.83% / 96.75%	70.85% / 60.56%	6.323 cards	2.45%
11	56.07%	28.97%	14.08%	0.88%	98.52% / 97.73%	75.87% / 66.03%	6.402 cards	4.07%
12	58.97%	28.47%	11.90%	0.65%	98.94% / 98.35%	79.92% / 70.56%	6.458 cards	6.18%
13	60.68%	28.34%	10.50%	0.49%	99.24% / 98.75%	83.27% / 74.38%	6.492 cards	8.72%
14	61.30%	28.69%	9.62%	0.40%	99.43% / 99.04%	86.11% / 77.86%	6.509 cards	11.62%
15	60.78%	29.77%	9.11%	0.34%	99.56% / 99.23%	88.52% / 80.86%	6.510 cards	14.95%
16	59.29%	31.52%	8.87%	0.33%	99.64% / 99.36%	90.60% / 83.55%	6.498 cards	18.69%
17	56.82%	33.91%	8.94%	0.34%	99.68% / 99.44%	92.36% / 85.97%	6.472 cards	22.91%
18	53.62%	36.63%	9.38%	0.37%	99.71% / 99.47%	93.73% / 87.99%	6.435 cards	27.49%
19	49.76%	39.49%	10.32%	0.44%	99.74% / 99.49%	94.82% / 89.66%	6.386 cards	32.43%
20	45.42%	42.15%	11.89%	0.53%	99.76% / 99.51%	95.68% / 91.01%	6.325 cards	37.48%

Constructed decks (60 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(2 lands on T2)	P(3 lands on T3)	mean hand	P(6+ lands on T5)
15	50.75%	28.81%	18.64%	1.81%	96.98% / 95.70%	69.22% / 59.21%	6.285 cards	3.01%
16	53.42%	28.86%	16.36%	1.36%	97.74% / 96.70%	72.92% / 63.04%	6.343 cards	4.09%
17	55.59%	28.85%	14.52%	1.03%	98.29% / 97.44%	76.05% / 66.48%	6.390 cards	5.34%
18	57.35%	28.81%	13.03%	0.81%	98.66% / 97.96%	78.86% / 69.54%	6.427 cards	6.78%
19	58.59%	28.92%	11.83%	0.66%	98.95% / 98.35%	81.33% / 72.33%	6.454 cards	8.43%
20	59.36%	29.17%	10.92%	0.55%	99.16% / 98.65%	83.46% / 74.85%	6.473 cards	10.26%
21	59.61%	29.64%	10.27%	0.48%	99.31% / 98.88%	85.40% / 77.17%	6.484 cards	12.28%
22	59.46%	30.33%	9.79%	0.42%	99.44% / 99.04%	87.12% / 79.29%	6.488 cards	14.46%
23	58.81%	31.27%	9.52%	0.39%	99.51% / 99.17%	88.68% / 81.25%	6.485 cards	16.83%
24	57.81%	32.40%	9.41%	0.38%	99.58% / 99.26%	90.03% / 83.01%	6.476 cards	19.37%
25	56.40%	33.74%	9.48%	0.38%	99.63% / 99.34%	91.26% / 84.64%	6.462 cards	22.11%
26	54.65%	35.21%	9.75%	0.39%	99.67% / 99.40%	92.32% / 86.10%	6.441 cards	24.99%
27	52.55%	36.80%	10.23%	0.42%	99.70% / 99.44%	93.27% / 87.44%	6.415 cards	27.97%
28	50.23%	38.36%	10.93%	0.47%	99.73% / 99.47%	94.06% / 88.60%	6.383 cards	31.07%
29	47.65%	39.92%	11.89%	0.55%	99.75% / 99.50%	94.78% / 89.64%	6.347 cards	34.25%
30	44.87%	41.34%	13.14%	0.66%	99.77% / 99.53%	95.38% / 90.55%	6.304 cards	37.55%

Constructed decks (80 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(2 lands on T2)	P(3 lands on T3)	mean hand	P(6+ lands on T5)
20	50.16%	28.55%	19.16%	2.13%	96.49% / 95.11%	68.47% / 58.59%	6.267 cards	3.28%
21	52.14%	28.70%	17.47%	1.70%	97.18% / 95.99%	71.32% / 61.45%	6.313 cards	4.07%
22	53.89%	28.78%	15.94%	1.38%	97.72% / 96.72%	73.90% / 64.23%	6.352 cards	4.98%
23	55.39%	28.86%	14.63%	1.13%	98.14% / 97.27%	76.20% / 66.72%	6.385 cards	5.98%
24	56.58%	28.96%	13.53%	0.94%	98.48% / 97.72%	78.30% / 69.09%	6.412 cards	7.09%
25	57.54%	29.11%	12.57%	0.78%	98.74% / 98.06%	80.22% / 71.20%	6.434 cards	8.32%
26	58.25%	29.30%	11.78%	0.67%	98.94% / 98.35%	81.95% / 73.19%	6.451 cards	9.62%
27	58.66%	29.61%	11.14%	0.59%	99.11% / 98.58%	83.58% / 75.08%	6.463 cards	11.05%
28	58.85%	30.01%	10.62%	0.52%	99.24% / 98.77%	85.02% / 76.84%	6.472 cards	12.61%
29	58.75%	30.52%	10.26%	0.47%	99.34% / 98.92%	86.39% / 78.45%	6.476 cards	14.22%
30	58.44%	31.14%	9.98%	0.44%	99.42% / 99.05%	87.62% / 79.98%	6.476 cards	15.93%
31	57.88%	31.87%	9.83%	0.41%	99.49% / 99.14%	88.72% / 81.42%	6.472 cards	17.78%
32	57.10%	32.74%	9.75%	0.41%	99.55% / 99.22%	89.77% / 82.73%	6.465 cards	19.69%
33	56.12%	33.65%	9.82%	0.41%	99.60% / 99.29%	90.70% / 83.94%	6.455 cards	21.68%
34	54.96%	34.64%	9.98%	0.41%	99.63% / 99.34%	91.53% / 85.09%	6.442 cards	23.76%
35	53.56%	35.73%	10.28%	0.43%	99.66% / 99.39%	92.31% / 86.17%	6.424 cards	25.95%
36	52.08%	36.78%	10.68%	0.47%	99.70% / 99.42%	93.03% / 87.16%	6.405 cards	28.16%
37	50.36%	37.92%	11.22%	0.51%	99.71% / 99.46%	93.67% / 88.06%	6.381 cards	30.46%
38	48.53%	39.01%	11.90%	0.57%	99.73% / 99.48%	94.24% / 88.88%	6.355 cards	32.76%
39	46.62%	40.02%	12.71%	0.65%	99.75% / 99.51%	94.74% / 89.66%	6.326 cards	35.18%
40	44.58%	40.98%	13.69%	0.76%	99.77% / 99.53%	95.22% / 90.33%	6.294 cards	37.52%

Commander decks (99 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(2 lands on T2)	P(3 lands on T3)	mean hand	P(6+ lands on T5)
24	74.09%	14.61%	10.08%	1.22%	98.00%	69.49%	6.616 cards	3.34%
25	75.73%	14.21%	9.07%	0.99%	98.38%	71.57%	6.647 cards	3.96%
26	77.17%	13.82%	8.19%	0.82%	98.65%	73.52%	6.673 cards	4.64%
27	78.41%	13.47%	7.45%	0.67%	98.89%	75.32%	6.696 cards	5.36%
28	79.46%	13.18%	6.79%	0.56%	99.08%	76.97%	6.715 cards	6.14%
29	80.37%	12.90%	6.25%	0.47%	99.22%	78.52%	6.732 cards	7.02%
30	81.07%	12.72%	5.80%	0.41%	99.34%	79.98%	6.744 cards	7.91%
31	81.66%	12.57%	5.43%	0.35%	99.44%	81.33%	6.755 cards	8.92%
32	82.11%	12.48%	5.11%	0.31%	99.52%	82.59%	6.764 cards	9.96%
33	82.43%	12.45%	4.84%	0.28%	99.58%	83.77%	6.770 cards	11.09%
34	82.60%	12.50%	4.65%	0.25%	99.63%	84.90%	6.775 cards	12.30%
35	82.64%	12.64%	4.49%	0.23%	99.67%	85.92%	6.777 cards	13.50%
36	82.57%	12.83%	4.39%	0.21%	99.70%	86.93%	6.778 cards	14.80%
37	82.34%	13.13%	4.33%	0.20%	99.73%	87.81%	6.776 cards	16.17%
38	82.09%	13.41%	4.30%	0.19%	99.76%	88.67%	6.774 cards	17.59%
39	81.67%	13.83%	4.30%	0.19%	99.78%	89.50%	6.770 cards	19.11%
40	81.09%	14.35%	4.37%	0.19%	99.79%	90.24%	6.763 cards	20.63%
41	80.47%	14.88%	4.47%	0.19%	99.81%	90.96%	6.756 cards	22.24%
42	79.65%	15.55%	4.61%	0.20%	99.82%	91.63%	6.746 cards	23.90%
43	78.77%	16.23%	4.79%	0.21%	99.83%	92.27%	6.736 cards	25.64%
44	77.74%	17.02%	5.02%	0.22%	99.83%	92.85%	6.723 cards	27.40%
45	76.58%	17.87%	5.32%	0.24%	99.84%	93.37%	6.708 cards	29.22%
46	75.30%	18.77%	5.66%	0.26%	99.85%	93.90%	6.691 cards	31.07%
47	73.85%	19.77%	6.09%	0.29%	99.85%	94.33%	6.672 cards	32.95%
48	72.31%	20.81%	6.55%	0.33%	99.86%	94.79%	6.651 cards	34.79%
49	70.69%	21.82%	7.11%	0.38%	99.86%	95.18%	6.628 cards	36.79%

Midrange mulligan strategy

Limited decks (40 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(3 lands on T3)	P(4 lands on T4)	mean hand	P(7+ lands on T6)
10	56.60%	28.11%	14.57%	0.72%	76.04% / 67.11%	44.99% / 34.26%	6.406 cards	0.96%
11	62.55%	26.55%	10.53%	0.38%	80.85% / 72.56%	52.68% / 41.34%	6.513 cards	1.99%
12	67.65%	24.55%	7.58%	0.22%	84.62% / 76.98%	59.63% / 47.95%	6.596 cards	3.58%
13	71.93%	22.37%	5.56%	0.15%	87.63% / 80.66%	65.69% / 54.10%	6.661 cards	5.81%
14	75.26%	20.37%	4.27%	0.10%	90.09% / 83.80%	71.19% / 59.77%	6.708 cards	8.72%
15	77.63%	18.80%	3.49%	0.07%	92.16% / 86.56%	75.98% / 65.08%	6.740 cards	12.29%
16	79.06%	17.85%	3.05%	0.05%	93.86% / 88.91%	80.28% / 69.93%	6.759 cards	16.53%
17	79.44%	17.73%	2.80%	0.04%	95.26% / 90.95%	84.00% / 74.39%	6.766 cards	21.33%
18	78.92%	18.40%	2.65%	0.03%	96.39% / 92.73%	87.20% / 78.39%	6.762 cards	26.69%
19	77.42%	19.98%	2.57%	0.03%	97.32% / 94.23%	89.95% / 82.00%	6.748 cards	32.45%
20	75.06%	22.37%	2.55%	0.03%	98.02% / 95.50%	92.20% / 85.21%	6.725 cards	38.50%

Constructed decks (60 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(3 lands on T3)	P(4 lands on T4)	mean hand	P(7+ lands on T6)
15	55.76%	27.05%	15.90%	1.30%	74.18% / 65.51%	44.19% / 34.01%	6.373 cards	1.50%
16	59.63%	26.34%	13.17%	0.87%	77.80% / 69.39%	49.30% / 38.60%	6.447 cards	2.26%
17	63.22%	25.39%	10.81%	0.58%	80.86% / 72.80%	54.08% / 43.03%	6.513 cards	3.23%
18	66.44%	24.31%	8.86%	0.39%	83.44% / 75.88%	58.55% / 47.36%	6.568 cards	4.46%
19	69.30%	23.12%	7.31%	0.27%	85.71% / 78.54%	62.72% / 51.47%	6.614 cards	5.94%
20	71.73%	22.02%	6.06%	0.19%	87.71% / 80.95%	66.61% / 55.41%	6.653 cards	7.70%
21	73.78%	20.98%	5.10%	0.14%	89.39% / 83.13%	70.21% / 59.17%	6.684 cards	9.73%
22	75.43%	20.09%	4.37%	0.11%	90.86% / 85.05%	73.50% / 62.70%	6.708 cards	12.05%
23	76.64%	19.45%	3.82%	0.08%	92.21% / 86.77%	76.60% / 66.05%	6.727 cards	14.61%
24	77.49%	19.03%	3.41%	0.07%	93.35% / 88.37%	79.41% / 69.24%	6.739 cards	17.48%
25	77.83%	18.99%	3.13%	0.06%	94.37% / 89.79%	81.98% / 72.22%	6.746 cards	20.58%
26	77.78%	19.24%	2.94%	0.05%	95.24% / 91.11%	84.29% / 75.04%	6.747 cards	23.87%
27	77.39%	19.76%	2.81%	0.04%	96.01% / 92.29%	86.39% / 77.67%	6.745 cards	27.39%
28	76.53%	20.69%	2.74%	0.04%	96.67% / 93.32%	88.31% / 80.14%	6.737 cards	31.05%
29	75.29%	21.94%	2.74%	0.03%	97.25% / 94.28%	90.01% / 82.44%	6.725 cards	34.89%
30	73.69%	23.47%	2.80%	0.04%	97.75% / 95.13%	91.55% / 84.54%	6.708 cards	38.82%

Yorion decks (80 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(3 lands on T3)	P(4 lands on T4)	mean hand	P(7+ lands on T6)
20	55.40%	26.53%	16.44%	1.63%	73.36% / 64.80%	43.90% / 33.92%	6.357 cards	1.79%
21	58.29%	26.11%	14.38%	1.22%	76.16% / 67.80%	47.61% / 37.33%	6.415 cards	2.36%
22	61.01%	25.56%	12.51%	0.91%	78.62% / 70.52%	51.27% / 40.64%	6.467 cards	3.07%
23	63.54%	24.89%	10.90%	0.68%	80.85% / 73.03%	54.73% / 43.88%	6.513 cards	3.90%
24	65.86%	24.20%	9.43%	0.51%	82.91% / 75.31%	58.10% / 47.10%	6.554 cards	4.87%
25	67.98%	23.42%	8.21%	0.39%	84.67% / 77.38%	61.21% / 50.16%	6.590 cards	5.99%
26	69.91%	22.64%	7.16%	0.29%	86.27% / 79.35%	64.20% / 53.15%	6.622 cards	7.24%
27	71.60%	21.92%	6.25%	0.23%	87.70% / 81.12%	67.02% / 56.05%	6.649 cards	8.68%
28	73.09%	21.23%	5.50%	0.18%	88.99% / 82.75%	69.73% / 58.83%	6.672 cards	10.19%
29	74.35%	20.62%	4.89%	0.14%	90.20% / 84.23%	72.26% / 61.52%	6.692 cards	11.95%
30	75.37%	20.15%	4.37%	0.11%	91.25% / 85.63%	74.60% / 64.05%	6.708 cards	13.74%
31	76.15%	19.79%	3.97%	0.09%	92.19% / 86.88%	76.86% / 66.53%	6.720 cards	15.78%
32	76.69%	19.59%	3.65%	0.08%	93.08% / 88.10%	78.96% / 68.95%	6.729 cards	17.91%
33	77.03%	19.52%	3.39%	0.07%	93.87% / 89.19%	80.89% / 71.16%	6.735 cards	20.15%
34	77.12%	19.63%	3.19%	0.06%	94.59% / 90.23%	82.72% / 73.33%	6.738 cards	22.54%
35	76.96%	19.94%	3.04%	0.05%	95.23% / 91.17%	84.43% / 75.38%	6.738 cards	25.07%
36	76.60%	20.42%	2.94%	0.04%	95.81% / 92.05%	86.00% / 77.33%	6.736 cards	27.71%
37	76.02%	21.06%	2.88%	0.04%	96.34% / 92.86%	87.49% / 79.24%	6.731 cards	30.42%
38	75.23%	21.87%	2.86%	0.04%	96.81% / 93.62%	88.80% / 80.99%	6.723 cards	33.18%
39	74.22%	22.85%	2.89%	0.04%	97.22% / 94.31%	90.07% / 82.64%	6.713 cards	36.08%
40	73.01%	24.00%	2.96%	0.04%	97.60% / 94.95%	91.20% / 84.23%	6.700 cards	39.00%

Commander decks (99 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(3 lands on T3)	P(4 lands on T4)	mean hand	P(7+ lands on T6)
24	79.34%	12.27%	7.60%	0.80%	73.68%	44.01%	6.701 cards	1.94%
25	81.44%	11.49%	6.46%	0.61%	75.75%	46.90%	6.738 cards	2.42%
26	83.34%	10.71%	5.50%	0.45%	77.65%	49.68%	6.769 cards	2.97%
27	85.08%	9.95%	4.63%	0.34%	79.41%	52.44%	6.798 cards	3.60%
28	86.55%	9.27%	3.92%	0.25%	81.00%	55.03%	6.821 cards	4.31%
29	87.93%	8.55%	3.33%	0.19%	82.51%	57.58%	6.842 cards	5.09%
30	89.12%	7.91%	2.83%	0.15%	83.86%	60.00%	6.860 cards	5.95%
31	90.13%	7.33%	2.42%	0.11%	85.12%	62.32%	6.875 cards	6.92%
32	91.01%	6.82%	2.08%	0.09%	86.31%	64.62%	6.887 cards	7.99%
33	91.77%	6.35%	1.80%	0.07%	87.41%	66.79%	6.898 cards	9.13%
34	92.44%	5.92%	1.58%	0.06%	88.47%	68.93%	6.907 cards	10.37%
35	92.97%	5.60%	1.38%	0.05%	89.38%	70.89%	6.915 cards	11.70%
36	93.41%	5.32%	1.23%	0.04%	90.28%	72.81%	6.921 cards	13.11%
37	93.73%	5.12%	1.11%	0.03%	91.10%	74.67%	6.926 cards	14.65%
38	94.01%	4.95%	1.01%	0.03%	91.86%	76.42%	6.929 cards	16.22%
39	94.22%	4.82%	0.94%	0.02%	92.57%	78.11%	6.932 cards	17.95%
40	94.37%	4.74%	0.87%	0.02%	93.23%	79.72%	6.935 cards	19.72%
41	94.46%	4.70%	0.83%	0.02%	93.85%	81.23%	6.936 cards	21.59%
42	94.49%	4.71%	0.79%	0.02%	94.43%	82.68%	6.937 cards	23.55%
43	94.46%	4.78%	0.76%	0.01%	94.94%	84.03%	6.937 cards	25.55%
44	94.37%	4.88%	0.74%	0.01%	95.42%	85.31%	6.936 cards	27.64%
45	94.24%	5.02%	0.74%	0.01%	95.86%	86.53%	6.935 cards	29.83%
46	94.01%	5.24%	0.74%	0.01%	96.29%	87.65%	6.933 cards	32.01%
47	93.74%	5.49%	0.76%	0.01%	96.66%	88.72%	6.930 cards	34.32%
48	93.39%	5.82%	0.77%	0.01%	96.99%	89.72%	6.926 cards	36.64%
49	92.98%	6.21%	0.80%	0.01%	97.30%	90.66%	6.922 cards	38.98%

High-curve mulligan strategy

Limited decks (40 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(4 lands on T4)	P(5 lands on T5)	mean hand	P(8+ lands on T7)
13	38.13%	48.24%	11.70%	1.94%	76.83% / 67.18%	53.10% / 41.15%	6.226 cards	3.22%
14	43.17%	46.54%	9.08%	1.20%	81.93% / 73.13%	60.76% / 48.47%	6.317 cards	5.50%
15	47.72%	44.39%	7.10%	0.80%	85.97% / 78.04%	67.51% / 55.28%	6.390 cards	8.51%
16	51.69%	42.09%	5.65%	0.57%	89.13% / 82.12%	73.28% / 61.49%	6.449 cards	12.28%
17	54.88%	39.94%	4.74%	0.43%	91.53% / 85.43%	78.21% / 67.01%	6.493 cards	16.70%
18	57.29%	38.19%	4.18%	0.34%	93.46% / 88.14%	82.40% / 71.95%	6.524 cards	21.71%
19	58.76%	37.05%	3.91%	0.28%	94.92% / 90.33%	85.89% / 76.34%	6.543 cards	27.27%
20	59.25%	36.67%	3.83%	0.25%	96.09% / 92.17%	88.79% / 80.20%	6.549 cards	33.21%
21	58.77%	37.04%	3.96%	0.23%	97.02% / 93.69%	91.26% / 83.63%	6.543 cards	39.50%
22	57.29%	38.18%	4.30%	0.23%	97.79% / 94.97%	93.35% / 86.67%	6.525 cards	46.07%
23	54.89%	39.94%	4.93%	0.24%	98.40% / 96.10%	95.07% / 89.38%	6.495 cards	52.81%
24	51.68%	42.08%	5.98%	0.26%	98.90% / 97.06%	96.50% / 91.79%	6.452 cards	59.66%
25	47.73%	44.38%	7.62%	0.27%	99.28% / 97.88%	97.63% / 93.86%	6.396 cards	66.47%
26	43.14%	46.55%	9.99%	0.31%	99.54% / 98.53%	98.47% / 95.61%	6.325 cards	73.05%

Constructed decks (60 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(4 lands on T4)	P(5 lands on T5)	mean hand	P(8+ lands on T7)
20	39.38%	46.68%	11.46%	2.48%	76.88% / 67.69%	54.57% / 43.07%	6.230 cards	4.96%
21	42.47%	45.79%	9.91%	1.82%	80.26% / 71.60%	59.40% / 47.73%	6.289 cards	6.61%
22	45.40%	44.71%	8.55%	1.34%	83.22% / 75.03%	63.95% / 52.21%	6.342 cards	8.54%
23	48.11%	43.50%	7.39%	1.01%	85.74% / 78.17%	68.10% / 56.46%	6.387 cards	10.79%
24	50.54%	42.25%	6.44%	0.78%	87.93% / 80.92%	71.89% / 60.50%	6.425 cards	13.36%
25	52.61%	41.09%	5.70%	0.61%	89.79% / 83.29%	75.36% / 64.23%	6.457 cards	16.16%
26	54.40%	40.00%	5.10%	0.49%	91.38% / 85.40%	78.51% / 67.73%	6.483 cards	19.28%
27	55.78%	39.13%	4.69%	0.40%	92.72% / 87.28%	81.27% / 71.00%	6.503 cards	22.57%
28	56.79%	38.46%	4.41%	0.35%	93.85% / 88.95%	83.77% / 74.08%	6.517 cards	26.12%
29	57.43%	38.01%	4.25%	0.31%	94.85% / 90.36%	86.03% / 76.86%	6.526 cards	29.89%
30	57.61%	37.89%	4.22%	0.28%	95.67% / 91.63%	88.01% / 79.46%	6.528 cards	33.78%
31	57.40%	38.02%	4.31%	0.26%	96.37% / 92.76%	89.75% / 81.86%	6.526 cards	37.85%
32	56.79%	38.46%	4.50%	0.25%	97.00% / 93.76%	91.35% / 84.05%	6.518 cards	42.03%
33	55.76%	39.14%	4.86%	0.25%	97.54% / 94.66%	92.74% / 86.10%	6.504 cards	46.30%
34	54.38%	40.02%	5.35%	0.25%	97.99% / 95.44%	93.98% / 87.94%	6.485 cards	50.71%
35	52.61%	41.09%	6.04%	0.26%	98.37% / 96.18%	95.07% / 89.68%	6.460 cards	55.13%
36	50.52%	42.28%	6.92%	0.28%	98.71% / 96.82%	96.02% / 91.26%	6.430 cards	59.53%

Yorion decks (80 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(4 lands on T4)	P(5 lands on T5)	mean hand	P(8+ lands on T7)
25	35.14%	46.77%	13.79%	4.31%	71.00% / 61.58%	47.70% / 37.07%	6.127 cards	3.71%
26	37.57%	46.47%	12.52%	3.44%	74.13% / 64.90%	51.57% / 40.59%	6.182 cards	4.69%
27	39.92%	46.02%	11.33%	2.72%	76.96% / 68.02%	55.30% / 44.07%	6.231 cards	5.82%
28	42.14%	45.46%	10.22%	2.17%	79.47% / 70.89%	58.86% / 47.45%	6.276 cards	7.12%
29	44.31%	44.76%	9.20%	1.73%	81.79% / 73.55%	62.27% / 50.75%	6.317 cards	8.56%
30	46.35%	43.97%	8.29%	1.39%	83.88% / 76.00%	65.49% / 53.98%	6.353 cards	10.17%
31	48.22%	43.17%	7.49%	1.12%	85.68% / 78.23%	68.46% / 57.04%	6.385 cards	11.92%
32	49.98%	42.33%	6.78%	0.91%	87.36% / 80.30%	71.32% / 60.02%	6.414 cards	13.85%
33	51.50%	41.56%	6.19%	0.75%	88.83% / 82.18%	73.95% / 62.88%	6.438 cards	15.90%
34	52.91%	40.78%	5.68%	0.63%	90.13% / 83.89%	76.34% / 65.58%	6.460 cards	18.14%
35	54.08%	40.10%	5.28%	0.53%	91.30% / 85.46%	78.62% / 68.20%	6.477 cards	20.49%
36	55.07%	39.53%	4.95%	0.46%	92.35% / 86.85%	80.74% / 70.58%	6.492 cards	22.97%
37	55.86%	39.03%	4.71%	0.40%	93.26% / 88.14%	82.66% / 72.89%	6.504 cards	25.57%
38	56.43%	38.67%	4.55%	0.36%	94.09% / 89.29%	84.47% / 75.05%	6.512 cards	28.30%
39	56.75%	38.46%	4.46%	0.33%	94.78% / 90.36%	86.07% / 77.11%	6.516 cards	31.15%
40	56.86%	38.38%	4.45%	0.30%	95.45% / 91.35%	87.55% / 79.07%	6.518 cards	34.06%
41	56.74%	38.47%	4.51%	0.28%	96.01% / 92.24%	88.96% / 80.91%	6.517 cards	37.06%
42	56.42%	38.67%	4.63%	0.27%	96.53% / 93.05%	90.22% / 82.61%	6.512 cards	40.16%
43	55.84%	39.04%	4.85%	0.27%	96.98% / 93.79%	91.36% / 84.25%	6.505 cards	43.26%
44	55.07%	39.51%	5.16%	0.27%	97.40% / 94.47%	92.46% / 85.76%	6.494 cards	46.50%
45	54.10%	40.09%	5.54%	0.26%	97.75% / 95.08%	93.39% / 87.19%	6.480 cards	49.70%
46	52.94%	40.75%	6.03%	0.27%	98.06% / 95.67%	94.26% / 88.55%	6.464 cards	52.96%
47	51.52%	41.53%	6.67%	0.28%	98.36% / 96.19%	95.07% / 89.83%	6.443 cards	56.20%
48	49.94%	42.36%	7.40%	0.30%	98.62% / 96.68%	95.76% / 90.96%	6.419 cards	59.45%

Commander decks (99 cards):

Lands	P(S = 7)	P(S = 6)	P(S = 5)	P(S = 4)	P(4 lands on T4)	P(5 lands on T5)	mean hand	P(8+ lands on T7)
33	63.56%	27.90%	6.82%	1.72%	80.76%	58.79%	6.533 cards	6.54%
34	65.69%	26.79%	6.12%	1.41%	82.57%	61.51%	6.568 cards	7.60%
35	67.68%	25.71%	5.48%	1.14%	84.22%	64.12%	6.599 cards	8.74%
36	69.58%	24.59%	4.91%	0.93%	85.74%	66.61%	6.628 cards	9.99%
37	71.31%	23.55%	4.39%	0.75%	87.11%	68.95%	6.654 cards	11.35%
38	72.86%	22.55%	3.96%	0.63%	88.33%	71.10%	6.676 cards	12.78%
39	74.23%	21.68%	3.57%	0.52%	89.43%	73.18%	6.696 cards	14.33%
40	75.51%	20.83%	3.23%	0.44%	90.43%	75.14%	6.714 cards	15.90%
41	76.62%	20.05%	2.96%	0.36%	91.37%	77.02%	6.729 cards	17.60%
42	77.63%	19.34%	2.73%	0.30%	92.18%	78.71%	6.743 cards	19.36%
43	78.44%	18.75%	2.53%	0.27%	92.91%	80.34%	6.754 cards	21.24%
44	79.16%	18.23%	2.38%	0.23%	93.59%	81.85%	6.763 cards	23.17%
45	79.76%	17.78%	2.25%	0.21%	94.22%	83.30%	6.771 cards	25.23%
46	80.23%	17.43%	2.15%	0.19%	94.79%	84.67%	6.777 cards	27.32%
47	80.58%	17.16%	2.09%	0.17%	95.27%	85.87%	6.781 cards	29.42%
48	80.80%	17.00%	2.04%	0.15%	95.75%	87.07%	6.785 cards	31.69%
49	80.95%	16.89%	2.02%	0.14%	96.17%	88.19%	6.786 cards	33.97%
50	80.92%	16.92%	2.02%	0.14%	96.55%	89.21%	6.786 cards	36.26%