lotofacil_monte_carlo_optimizer.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Lotofácil Monte Carlo Optimizer (7 games, 15 numbers each, from 1..25)

Principles:
- Generate many candidate sets with dispersion heuristics (low overlap across games)
- Monte Carlo simulate draws to estimate empirical probabilities for 11..15 hits
- Select best by priority: P(>=14) > P(>=13) > diversity (unique_numbers, min distance) > P(15)
- Export best set and a leaderboard CSV

Usage example:
$ python lotofacil_monte_carlo_optimizer.py \
    --n-candidates 2000 --shortlist 120 --draws 60000 \
    --seed 2025 --out-prefix resultados/lf_opt
"""

import argparse
import itertools
import os
import random
from collections import Counter

import numpy as np
import pandas as pd

N_NUMBERS = 25
K_PER_TICKET = 15
GAMES_PER_SET = 7

# ------------------------- Utilities -------------------------

def sample_ticket():
    return tuple(sorted(random.sample(range(1, N_NUMBERS+1), K_PER_TICKET)))

def set_score_heuristic(games):
    """
    Heuristic for pre-ranking candidates:
      1) maximize union_size
      2) maximize min pairwise distance (15 - intersection)
      3) minimize max pair reuse across games
      4) flatten endings (0-9) and "decades" (1-10,11-20,21-25) dispersion
    """
    union_size = len(set().union(*map(set, games)))
    dists = []
    for i in range(len(games)):
        for j in range(i+1, len(games)):
            inter = len(set(games[i]) & set(games[j]))
            dists.append(K_PER_TICKET - inter)
    min_dist = min(dists) if dists else K_PER_TICKET

    # pair reuse across games
    pair_counts = Counter()
    for g in games:
        for a,b in itertools.combinations(g, 2):
            pair_counts[(a,b)] += 1
    max_pair_reuse = max(pair_counts.values()) if pair_counts else 0

    # endings and "decades"
    endings = Counter(x % 10 for g in games for x in g)
    decades = Counter((x-1)//10 for g in games for x in g)  # 0:1-10,1:11-20,2:21-25
    end_vals = list(endings.values()) + [0]*(10-len(endings))
    dec_vals = list(decades.values()) + [0]*(3-len(decades))
    end_spread = -float(np.std(end_vals))
    dec_spread = -float(np.std(dec_vals))
    return (union_size, min_dist, -max_pair_reuse, end_spread, dec_spread)

def build_candidate_set():
    """Greedy 7-ticket builder with dispersion and mild parity control (~7-8 evens per ticket on avg)."""
    games = []
    number_freq = Counter()
    for _ in range(GAMES_PER_SET):
        best, best_m = None, None
        for __ in range(300):
            cand = sample_ticket()
            inter_penalty = sum(len(set(cand)&set(g)) for g in games) if games else 0
            avg_freq = sum(number_freq[x] for x in cand)/K_PER_TICKET
            decades = len({(x-1)//10 for x in cand})
            endings = len({x%10 for x in cand})
            # parity target ~ 7 or 8 evens (25 has 12 evens, 13 odds; close to balance is fine)
            evens = sum(1 for x in cand if x%2==0)
            par_pen = min(abs(evens-7), abs(evens-8))
            mscore = (-inter_penalty, -avg_freq, decades + endings/10.0, -par_pen, random.random())
            if best_m is None or mscore > best_m:
                best_m, best = mscore, cand
        games.append(best)
        for x in best:
            number_freq[x]+=1
    return tuple(tuple(sorted(g)) for g in games)

def generate_candidates(n_candidates=1600, shortlist=100):
    cands = []
    for _ in range(n_candidates):
        games = build_candidate_set()
        cands.append((set_score_heuristic(games), games))
    cands.sort(reverse=True, key=lambda x: x[0])
    return [g for _,g in cands[:shortlist]]

# ------------------------- Monte Carlo Engine -------------------------

def simulate_draws(n_draws=60000, rng=None):
    if rng is None:
        rng = random
    draws = []
    for _ in range(n_draws):
        draw = tuple(sorted(rng.sample(range(1, N_NUMBERS+1), K_PER_TICKET)))
        draws.append(frozenset(draw))
    return draws

def evaluate_set_monte_carlo(games, draws):
    gsets = [set(g) for g in games]
    # indicators: at least one ticket with r>=threshold
    at11 = at12 = at13 = at14 = at15 = 0
    exp11 = exp12 = exp13 = exp14 = exp15 = 0
    for d in draws:
        c11=c12=c13=c14=c15=0
        for g in gsets:
            r = len(g & d)
            if r>=11:
                if r==11: c11+=1
                elif r==12: c12+=1
                elif r==13: c13+=1
                elif r==14: c14+=1
                elif r==15: c15+=1
        if c11>0: at11 += 1
        if c12>0: at12 += 1
        if c13>0: at13 += 1
        if c14>0: at14 += 1
        if c15>0: at15 += 1
        exp11 += c11; exp12 += c12; exp13 += c13; exp14 += c14; exp15 += c15
    n = len(draws)
    # diversity
    union_size = len(set().union(*map(set, games)))
    min_dist = min([K_PER_TICKET - len(set(g1)&set(g2)) for i,g1 in enumerate(games) for g2 in games[i+1:]] or [K_PER_TICKET])
    return {
        "P(>=14)": at14/n,
        "P(>=13)": (at13+at14+at15)/n,
        "P(>=12)": (at12+at13+at14+at15)/n,
        "P(>=11)": (at11+at12+at13+at14+at15)/n,
        "E[11]": exp11/n, "E[12]": exp12/n, "E[13]": exp13/n, "E[14]": exp14/n, "E[15]": exp15/n,
        "unique_numbers": union_size,
        "min_pairwise_distance": min_dist
    }

def select_best(records):
    # Prioritize higher-tier hits first
    return sorted(records, key=lambda x: (
        x[1]["P(>=14)"],
        x[1]["P(>=13)"],
        x[1]["unique_numbers"],
        x[1]["P(>=12)"],
        x[1]["P(>=11)"],
    ), reverse=True)

# ------------------------- Orchestrator -------------------------

def run_optimizer(n_candidates=1600, shortlist=100, draws=60000, seed=None, out_prefix="lf_opt"):
    if seed is not None:
        random.seed(seed); np.random.seed(seed)
    cands = generate_candidates(n_candidates=n_candidates, shortlist=shortlist)
    draws_obj = simulate_draws(n_draws=draws)
    records = []
    for games in cands:
        metrics = evaluate_set_monte_carlo(games, draws_obj)
        records.append((games, metrics))
    sorted_records = select_best(records)
    best_games, best_metrics = sorted_records[0]

    # outputs
    os.makedirs(os.path.dirname(out_prefix), exist_ok=True) if os.path.dirname(out_prefix) else None

    best_rows = [{"Jogo #": i, "Dezenas": " ".join(f"{x:02d}" for x in g)} for i,g in enumerate(best_games,1)]
    best_df = pd.DataFrame(best_rows)
    best_csv = f"{out_prefix}_best_set.csv"; best_df.to_csv(best_csv, index=False, encoding="utf-8")

    topK = min(10, len(sorted_records))
    leader_rows = []
    for i,(games,metrics) in enumerate(sorted_records[:topK], start=1):
        row = {"Posição": i}
        row.update(metrics)
        leader_rows.append(row)
    leader_df = pd.DataFrame(leader_rows)
    leader_csv = f"{out_prefix}_topK_metrics.csv"; leader_df.to_csv(leader_csv, index=False, encoding="utf-8")

    return best_csv, leader_csv, best_games, best_metrics

def main():
    import argparse
    ap = argparse.ArgumentParser(description="Lotofácil Monte Carlo Optimizer (7 games, 15 numbers).")
    ap.add_argument("--n-candidates", type=int, default=1600)
    ap.add_argument("--shortlist", type=int, default=100)
    ap.add_argument("--draws", type=int, default=60000)
    ap.add_argument("--seed", type=int, default=None)
    ap.add_argument("--out-prefix", type=str, default="lf_opt")
    args = ap.parse_args()

    best_csv, leader_csv, best_games, best_metrics = run_optimizer(
        n_candidates=args.n_candidates,
        shortlist=args.shortlist,
        draws=args.draws,
        seed=args.seed,
        out_prefix=args.out_prefix
    )
    print("Best set saved to:", best_csv)
    print("Leaderboard saved to:", leader_csv)
    print("Best metrics:", best_metrics)

if __name__ == "__main__":
    main()