pons 0.10.0

Rust package for contract bridge
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Constructive-only floor A/B/C: instinct vs SearchFloor vs NeuralFloorSearch.
//!
//! The three learned-vs-deterministic floors normally partition the auction —
//! the neural/search floors own only the contested books, while the constructive
//! book is always floored by the deterministic
//! [`instinct`][pons::bidding::instinct] ladder (see
//! [`american_constructive_floor`][pons::bidding::american::american_constructive_floor]).
//! This harness lifts that partition to ask one question: *if* we let the search
//! floors answer the unbooked constructive nodes, do they bid them better than
//! the milestone heuristics?
//!
//! It isolates the constructive phase by **silencing the opponents** — East and
//! West always pass — so every auction is constructive start to finish (when
//! opener takes its second turn, only responder has bid).  Each board is bid
//! three times, once per floor, over the *same* deal; the deal is solved double
//! dummy once and the three final contracts scored against it.  The pairwise
//! score swings become IMPs: a positive `X vs Y` favors `X`.
//!
//! Because the only difference between arms is the constructive floor and the
//! opponents are passive across all three, no seat swap is needed — the
//! comparison is already duplicate-clean.
//!
//! ```text
//! cargo run --release --features search --example ab-constructive -- --count 200
//! ```
//!
//! The `search` arm runs a double-dummy rollout per non-forced decision, so it
//! dominates the runtime (~seconds per board at the default knobs); shrink
//! `--layouts`/`--shortlist` for a faster, noisier run, and prefer
//! `scripts/idle-run.sh` for a large `--count` on the shared box.

use clap::Parser;
use contract_bridge::deck::full_deal;
use contract_bridge::{AbsoluteVulnerability, FullDeal, Seat};
use ddss::{NonEmptyStrainFlags, Solver};
use pons::bidding::Family;
use pons::bidding::american::american_constructive_floor;
use pons::bidding::neural_floor::NeuralFloorSearch;
use pons::bidding::search_floor::SearchFloor;
use pons::instinct;
use pons::scoring::{final_contract, imps, ns_score_contract};
use rayon::prelude::*;

#[path = "../common/mod.rs"]
#[allow(dead_code)]
mod common;
use common::bid_uncontested;

/// Constructive-only floor A/B/C: instinct vs SearchFloor vs NeuralFloorSearch
#[derive(Parser)]
struct Args {
    /// Number of boards in the match (dealer rotates per board)
    #[arg(short, long, default_value = "200")]
    count: usize,

    /// Vulnerability: none, ns, ew, both
    #[arg(short, long, default_value = "none")]
    vulnerability: AbsoluteVulnerability,

    /// `SearchFloor` layouts sampled and solved per decision
    #[arg(short, long, default_value = "128")]
    layouts: usize,

    /// `SearchFloor` top-k calls actually scored by EV
    #[arg(short, long, default_value = "8")]
    shortlist: usize,
}

#[allow(clippy::cast_precision_loss)]
fn main() {
    let args = Args::parse();
    let mut rng = rand::rng();

    // Three arms, identical but for the constructive floor; opponents silenced,
    // so the contested books they each leave bare are never reached.
    let names = ["instinct", "search", "neural"];
    let stances = [
        american_constructive_floor(instinct()).against(Family::NATURAL),
        american_constructive_floor(SearchFloor {
            layouts: args.layouts,
            shortlist: args.shortlist,
            ..SearchFloor::default()
        })
        .against(Family::NATURAL),
        american_constructive_floor(NeuralFloorSearch).against(Family::NATURAL),
    ];

    // Bid every board with all three arms over the same deal.
    // Deal sequentially (cheap), then bid in parallel — bidding is pure (the
    // books read their thread-locals at construction), so boards are independent
    // and par_iter preserves order. The DD solver stays on the main thread below.
    let deals: Vec<FullDeal> = (0..args.count).map(|_| full_deal(&mut rng)).collect();
    let vul = args.vulnerability;
    let contracts: Vec<[_; 3]> = deals
        .par_iter()
        .enumerate()
        .map(|(index, deal)| {
            let dealer = Seat::ALL[index % 4];
            std::array::from_fn(|arm| {
                let auction = bid_uncontested(&stances[arm], dealer, vul, deal);
                final_contract(&auction, dealer)
            })
        })
        .collect();

    // Only boards whose three arms diverge can swing; solve those once and reuse
    // the table for every pairing.
    let divergent: Vec<usize> = (0..args.count)
        .filter(|&i| {
            let c = &contracts[i];
            c[0] != c[1] || c[1] != c[2]
        })
        .collect();
    let solve_deals: Vec<FullDeal> = divergent.iter().map(|&i| deals[i]).collect();
    let tables = Solver::lock().solve_deals(&solve_deals, NonEmptyStrainFlags::ALL);

    // (first, second) arm indices; a positive swing favors `first`.
    let pairings = [(0, 1), (0, 2), (1, 2)];
    let mut points = [0i64; 3];
    let mut imp_totals = [0i64; 3];
    for (&i, table) in divergent.iter().zip(tables.iter()) {
        let scores: [i64; 3] = std::array::from_fn(|arm| {
            ns_score_contract(contracts[i][arm], table, args.vulnerability)
        });
        for (p, &(x, y)) in pairings.iter().enumerate() {
            let swing = scores[x] - scores[y];
            points[p] += swing;
            imp_totals[p] += imps(swing);
        }
    }

    println!(
        "=== Constructive-only floor A/B/C: {} boards, vulnerability {} ===",
        args.count, args.vulnerability,
    );
    println!("(opponents silenced — every auction is constructive)");
    println!(
        "SearchFloor knobs: layouts={}, shortlist={}",
        args.layouts, args.shortlist,
    );
    println!(
        "Divergent boards: {} of {} ({:.0}%)",
        divergent.len(),
        args.count,
        100.0 * divergent.len() as f64 / args.count.max(1) as f64,
    );
    println!(
        "\n  {:>8} vs {:<8}  points     IMPs   IMPs/board",
        "first", "second"
    );
    for (p, &(x, y)) in pairings.iter().enumerate() {
        println!(
            "  {:>8} vs {:<8}  {:+6}  {:+6}     {:+.3}",
            names[x],
            names[y],
            points[p],
            imp_totals[p],
            imp_totals[p] as f64 / args.count.max(1) as f64,
        );
    }
    println!("\n(a positive row favors the first-named floor)");
}