automatic

type AnalysisResult struct {
	GamesPlayed   int
	Player1       PlayerStats
	Player2       PlayerStats
	P1Wins        float64
	P1First       float64
	WentFirstWins float64
	WinPValue     float64 // two-sided binomial z-test, H0: win rate = 0.5
	ScorePValue   float64 // two-sided paired z-test on per-game score diff
	ScoreDiff     *stats.Statistic

	// Paired is filled in for a -gamepairs run, where the two games of a pair
	// share a bag and cannot be treated as independent.
	Paired *PairedResult
}

type AutomaticRunnerPlayer struct {
	LeaveFile            string
	PEGFile              string
	BotCode              pb.BotRequest_BotCode
	MinSimPlies          int
	SimThreads           int
	StochasticStaticEval bool
	// InferenceTau pins the softmax temperature for P(play | leave). Leave it
	// zero for the engine default (SoftmaxTemperature); a value here applies to
	// the whole game.
	InferenceTau                 float64
	InferenceTimeSecs            int
	InferenceSimIters            int
	InferenceMaxEnumeratedLeaves int
	InferenceBudget              int
	OracleInference              bool
}

type CorpusFilter struct {
	// LeaveLen, when non-zero, keeps only inferences of that many tiles. Six
	// is the one-tile-play bucket, where the read goes wrong.
	LeaveLen int
	// MaxBag and MinBag bound the phase; MaxBag 0 means no upper bound.
	MinBag, MaxBag int
	// WorseThan keeps only inferences the run scored below this many bits.
	// Leave at zero and pass AllLifts to take everything.
	WorseThan float64
	AllLifts  bool
	// Limit caps how many positions are returned, 0 for all.
	Limit int
}

type CorpusPosition struct {
	// GameID and Half say which game and which seating it came from; Turn is
	// the play the inference was reading, 1-based as the log numbers them.
	GameID string
	Half   int
	Turn   int

	// Game is replayed up to and including the opponent's play, so the
	// position is exactly what the inferring bot faced -- including the
	// inferring player's own rack, which decides the unseen pool and so the
	// prior every inference is graded against.
	Game *game.Game

	// MyRack is the inferring player's rack at this position, taken from the
	// row where they play next. Replaying alone cannot recover it: the tiles
	// they drew came off a bag this replay never had in the same order.
	MyRack string

	// TrueLeave is what the opponent actually kept -- the answer. OppRack and
	// OppPlay are what produced it.
	TrueLeave string
	OppRack   string
	OppPlay   string
	OppScore  int

	// TilesRemaining is the bag count after the play, and LeaveLen the number
	// of tiles being inferred; both are what the run's own breakdowns cut on.
	TilesRemaining int
	LeaveLen       int

	// LoggedLiftBits is what the original run scored this inference, when it
	// recorded one. A replay that reproduces the run should land near it.
	LoggedLiftBits  float64
	LoggedMeasured  bool
	LoggedRank      int
	LoggedLeaves    int
	HasLoggedResult bool
}

type DeterministicConfig struct {
	Seeds    [][32]byte // Pre-generated seeds (nil = generate new)
	SeedFile string     // File to read/write seeds
	NumGames int        // Number of games (used when generating seeds)
	// MasterSeed derives a seed per unit of work when there is no seed file.
	MasterSeed uint64
	// GamePairs plays each seed twice with the bots swapping seats.
	GamePairs bool
}

type DivergenceKind int

type DivergenceReport struct {
	Bot1, Bot2 string
	Pairs      int
	Divergent  int
	ExactTies  int
	// Broken counts pairs whose halves saw different tiles or ran different
	// lengths -- bugs rather than strategy differences.
	Broken int
	// NoTurnData counts divergent pairs the per-turn log had nothing for.
	NoTurnData int
	// TurnStats is the first-divergence turn across every divergent pair.
	TurnStats *stats.Statistic
	// EarliestTurn and LatestTurn bound the same distribution.
	EarliestTurn, LatestTurn int
	// Details covers the first maxDetails divergent pairs, in pair order.
	Details []PairDivergence
	// Truncated is how many divergent pairs are not in Details.
	Truncated int
}

type GameRunner struct {
	// contains filtered or unexported fields
}

type InferenceQuality struct {
	// Inferences is how many turns produced a graded posterior.
	Inferences int
	// Unscored is how many turns ran inference but had nothing to grade: no
	// history yet, an empty bag, or a bingo that left no tiles to infer.
	Unscored int

	// LiftBits is log2(posterior/prior) per inference. Its mean is the headline.
	LiftBits *stats.Statistic
	// Posterior and Prior are the raw probabilities, kept for context since the
	// lift hides how small both are in a large leave space.
	Posterior, Prior *stats.Statistic
	// RankPct is the true leave's percentile among candidates, 0 being the top.
	// Robust to leave-space size in a way the raw rank is not.
	RankPct *stats.Statistic
	// Leaves is the size of the posterior per inference.
	Leaves *stats.Statistic

	// Better and Worse count inferences that beat and lost to the prior.
	Better, Worse int
	// RuledOut counts inferences that gave the true leave no weight at all --
	// the expensive mistake, since the simmer then never samples the truth.
	RuledOut int
	// Measured counts inferences where the true leave got a real mini-sim rather
	// than an imputed weight.
	Measured int

	// ByLeaveLen breaks the mean lift down by how many tiles were being inferred,
	// which is where inference gets hard.
	ByLeaveLen map[int]*stats.Statistic
	// contains filtered or unexported fields
}

type Job struct {
	// contains filtered or unexported fields
}

type PairDivergence struct {
	Pair   int
	GameID string
	Kind   DivergenceKind

	// Turn is the first turn the halves disagreed on, 1-based.
	Turn int
	// Rack is what both halves held on that turn. When Kind is
	// DivergenceTiles the two halves held RackA and RackB instead.
	Rack         string
	RackA, RackB string

	// BotA played PlayA in the first half; BotB played PlayB in the second,
	// from the same seat and the same tiles.
	BotA, BotB       string
	PlayA, PlayB     string
	ScoreA, ScoreB   int
	EquityA, EquityB float64

	TurnsA, TurnsB int
	// ScoreDiff is bot 1's score minus bot 2's, summed over both halves. A pair
	// that never diverges scores exactly 0 here.
	ScoreDiff int
}

type PairedResult struct {
	Pairs int
	// Incomplete counts pairs that did not have both halves in the log -- a run
	// stopped midway, say. They are left out of everything below.
	Incomplete int
	// Divergent counts pairs whose halves ever chose differently, straight from
	// the log column. Pairs that never diverge contribute an exact zero, so this
	// is the count that carries any information.
	Divergent int
	// ExactTies counts pairs whose two margins cancel to zero.
	ExactTies int

	// Swept, Split and Lost count pairs where bot 1 won both games, one each,
	// and neither -- the plainest statement of a paired result, since the
	// pairs that split are the ones tile luck decided. WithDraw counts pairs
	// with a drawn game in them, which fit none of the three.
	Swept, Split, Lost, WithDraw int

	// Margin is bot 1's score margin summed over a pair's two games, one
	// observation per pair. Halve it for a per-game figure.
	Margin *stats.Statistic
	// WinShare is bot 1's share of a pair's two games: 1 for winning both, 0.5
	// for a split, 0 for losing both. The null value is 0.5.
	WinShare *stats.Statistic

	// Correlation is between the two halves' margins. The pairing is working
	// when this is well below zero.
	Correlation float64

	// MarginPValue and WinPValue come from a sign-flip randomization test over
	// the pairs, which assumes only the symmetry the design guarantees.
	MarginPValue float64
	WinPValue    float64
	// ExactP is true when every sign assignment was enumerated rather than
	// sampled.
	ExactP bool
	// MarginTPValue is the same test done by t-test, for comparison.
	MarginTPValue float64

	// NaiveScoreSE is the standard error the per-game analysis reports for the
	// same quantity, kept to show what the pairing bought.
	NaiveScoreSE float64
}

type PlayerStats struct {
	Name   string
	Score  *stats.Statistic
	Bingos *stats.Statistic
	PPT    *stats.Statistic
}

type ShadowAgreementResult struct {
	GamesPlayed   int
	TurnsPlayed   int
	Disagreements int
	Details       []string
}

type WMPAgreementResult struct {
	GamesPlayed   int
	TurnsPlayed   int
	Disagreements int
	Details       []string
}