loto2

core/templates/core/sequential_generator.html

@@ -11,13 +11,13 @@
                     <div>
                         <h4 class="text-white mb-0 fw-bold d-flex align-items-center">
                             <i class="bi bi-cpu-fill me-2 text-warning pulse-warning"></i> 
-                            SUPERCOMPUTADOR DE ELITE <span class="badge bg-warning text-dark ms-2" id="sync-status">SINCRO: 10.000 CONCURSOS</span>
+                            SUPERCOMPUTADOR DE ELITE <span class="badge bg-warning text-dark ms-2" id="sync-status">SINCRO: {{ supercomputer_sync }} SIMULAÇÕES</span>
                         </h4>
-                        <p class="text-slate-400 small mb-0">Gerador Sequencial com Matemática Neural Convergente de 99.9%.</p>
+                        <p class="text-slate-400 small mb-0">Gerador Sequencial com Matemática Neural Convergente, histórico recente e 10.000 simulações por análise.</p>
                     </div>
                     <div class="text-end">
                         <span class="badge bg-success-subtle text-success border border-success px-3 py-2 rounded-pill">
-                            <i class="bi bi-shield-check me-1"></i>PRECISÃO 99.9% ATIVA
+                            <i class="bi bi-activity me-1"></i>SINAL ESTATÍSTICO ATIVO
                         </span>
                         <div id="voice-indicator" class="small text-warning d-none mt-1 animate__animated animate__pulse animate__infinite">
                             <i class="bi bi-soundwave"></i> IA ANALISANDO...
@@ -34,7 +34,7 @@
         <div class="col-lg-3 col-md-12">
             <div class="card bg-slate-800 border-slate-700 shadow-lg h-100">
                 <div class="card-header bg-slate-700 border-slate-600 py-3">
-                    <h6 class="text-white mb-0 fw-bold">CONFIGURAÇÕES DE ELITE MODO 99.9%</h6>
+                    <h6 class="text-white mb-0 fw-bold">CONFIGURAÇÕES DE ELITE</h6>
                 </div>
                 <div class="card-body">
                     <div class="mb-4">
@@ -49,7 +49,7 @@
 
                     <div class="form-check form-switch mb-4">
                         <input class="form-check-input" type="checkbox" id="elite-mode-switch">
-                        <label class="form-check-label text-warning small fw-bold" for="elite-mode-switch">MODO 99.9% (USAR APENAS DEZENAS ABAIXO)</label>
+                        <label class="form-check-label text-warning small fw-bold" for="elite-mode-switch">MODO ELITE MANUAL (PRIORIZAR APENAS DEZENAS ABAIXO)</label>
                     </div>
 
                     <!-- Grid de Dezenas de Elite Editáveis -->
@@ -101,8 +101,8 @@
                         <span class="x-small text-info" id="concurso-info">AGUARDANDO SELEÇÃO...</span>
                     </div>
                     <div class="text-end">
-                        <span class="x-small text-slate-400 d-block">PROBABILIDADE DE ACERTO</span>
-                        <span class="text-warning fw-bold">99.982% (MATEMÁTICA PURA)</span>
+                        <span class="x-small text-slate-400 d-block">SINAL ESTATÍSTICO</span>
+                        <span class="text-warning fw-bold" id="signal-display">Aguardando dados reais</span>
                     </div>
                 </div>
                 
@@ -159,7 +159,7 @@
                 
                 <div class="p-3 bg-slate-800 border-top border-slate-700">
                     <div class="d-flex align-items-center justify-content-between mb-3">
-                        <h6 class="text-warning small fw-bold text-uppercase mb-0">Elite Verde (Próximo Concurso Real)</h6>
+                        <h6 class="text-warning small fw-bold text-uppercase mb-0">Faixa Prioritária do Próximo Jogo</h6>
                         <button class="btn btn-slate-700 btn-sm rounded-pill px-3" onclick="recalculateDeepElite()">
                             <i class="bi bi-arrow-repeat me-1"></i> Sincronizar Supercomputador
                         </button>
@@ -175,14 +175,46 @@
         <div class="col-lg-3 col-md-12">
             <div class="card bg-slate-800 border-slate-700 shadow-lg h-100">
                 <div class="card-header bg-slate-700 border-slate-600 py-3 d-flex justify-content-between align-items-center">
-                    <h6 class="text-white mb-0 fw-bold">HITS DE ELITE</h6>
+                    <h6 class="text-white mb-0 fw-bold">PAINEL DO SUPERCOMPUTADOR</h6>
                     <button id="btn-download" class="btn btn-success btn-sm d-none fw-bold">
                         <i class="bi bi-download me-1"></i> TXT
                     </button>
                 </div>
-                <div class="card-body p-0">
-                    <div id="hits-panel" class="p-3 d-flex flex-column gap-2 overflow-auto" style="max-height: 600px;">
-                        <div class="text-center text-slate-700 py-3 small">Nenhum acerto de elite detectado ainda...</div>
+                <div class="card-body p-3 pb-0">
+                    <div class="row g-2 text-center mb-3">
+                        <div class="col-6">
+                            <div class="p-2 rounded bg-slate-900 border border-slate-700">
+                                <span class="text-slate-400 x-small d-block mb-1">JANELA REAL</span>
+                                <div class="text-white fw-bold font-monospace" id="metric-window">--</div>
+                            </div>
+                        </div>
+                        <div class="col-6">
+                            <div class="p-2 rounded bg-slate-900 border border-slate-700">
+                                <span class="text-slate-400 x-small d-block mb-1">BASE HISTÓRICA</span>
+                                <div class="text-white fw-bold font-monospace" id="metric-draws">--</div>
+                            </div>
+                        </div>
+                        <div class="col-6">
+                            <div class="p-2 rounded bg-slate-900 border border-slate-700">
+                                <span class="text-slate-400 x-small d-block mb-1">ODDS OFICIAIS</span>
+                                <div class="text-info fw-bold x-small" id="metric-odds">--</div>
+                            </div>
+                        </div>
+                        <div class="col-6">
+                            <div class="p-2 rounded bg-slate-900 border border-slate-700">
+                                <span class="text-slate-400 x-small d-block mb-1">MOTOR</span>
+                                <div class="text-warning fw-bold x-small" id="metric-method">--</div>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="rounded bg-slate-900 border border-slate-700 p-3 mb-3">
+                        <div class="x-small text-slate-400 text-uppercase fw-bold mb-2">Top sequências da simulação</div>
+                        <div id="prediction-panel" class="text-slate-500 small">Selecione uma loteria para carregar o ranking real.</div>
+                    </div>
+                </div>
+                <div class="px-3 pb-3">
+                    <div id="hits-panel" class="d-flex flex-column gap-2 overflow-auto" style="max-height: 360px;">
+                        <div class="text-center text-slate-700 py-3 small">Nenhum hit de elite detectado ainda...</div>
                     </div>
                 </div>
                 <div class="card-footer border-top border-slate-700 bg-slate-900 p-3">
@@ -190,7 +222,7 @@
                         <button id="btn-open-browser" class="btn btn-outline-info btn-sm fw-bold d-none">
                             <i class="bi bi-window me-1"></i> VER TODOS NO NAVEGADOR
                         </button>
-                        <p class="x-small text-slate-500 text-center mb-0">O Supercomputador salva automaticamente os últimos hits detectados.</p>
+                        <p class="x-small text-slate-500 text-center mb-0">Os hits exibidos mostram combinações que ficaram mais alinhadas ao ranking estatístico da análise atual.</p>
                     </div>
                 </div>
             </div>
@@ -210,7 +242,7 @@
                 <div id="funnel-grid" class="d-flex flex-wrap gap-1 justify-content-center">
                     <!-- Gerado via JS -->
                 </div>
-                <p class="text-slate-500 x-small mt-3 mb-0 text-center">Números marcados em azul serão IGNORADOS pelo motor de cálculo do Supercomputador.</p>
+                <p class="text-slate-500 x-small mt-3 mb-0 text-center">Números marcados em azul serão ignorados pelo motor estatístico nas novas sequências.</p>
             </div>
         </div>
     </div>
@@ -338,21 +370,86 @@
     const viewport = document.querySelector(".generator-viewport");
     const elitePanel = document.getElementById("elite-panel");
     const btnOpenBrowser = document.getElementById("btn-open-browser");
+    const signalDisplay = document.getElementById("signal-display");
+    const predictionPanel = document.getElementById("prediction-panel");
 
-    // Recalibragem Neural para Elite 99.9%
+
+    function formatNumber(number) {
+        return number.toString().padStart(2, "0");
+    }
+
+    function updateMetricsPanel() {
+        if (!lotteryData) return;
+
+        document.getElementById("sync-status").innerText = `SINCRO: ${lotteryData.supercomputer_sync.toLocaleString()} SIMULAÇÕES`;
+        document.getElementById("concurso-info").innerText = `Último concurso real: ${lotteryData.last_real_contest} • janela: ${lotteryData.analysis_window || 0}`;
+        signalDisplay.innerText = lotteryData.signal_label || "--";
+        document.getElementById("metric-window").innerText = `${lotteryData.analysis_window || 0} concursos`;
+        document.getElementById("metric-draws").innerText = `${lotteryData.total_real_draws || 0} reais`;
+        document.getElementById("metric-odds").innerText = lotteryData.combination_odds || "--";
+        document.getElementById("metric-method").innerText = lotteryData.methodology || "--";
+
+        const sequences = lotteryData.top_sequences || [];
+        if (!sequences.length) {
+            predictionPanel.innerHTML = '<div class="text-slate-500 small">Ainda não há base suficiente para exibir sequências ranqueadas.</div>';
+            return;
+        }
+
+        predictionPanel.innerHTML = sequences.map((item, index) => `
+            <div class="d-flex justify-content-between align-items-center ${index < sequences.length - 1 ? 'mb-2 pb-2 border-bottom border-slate-700' : ''}">
+                <div class="text-white font-monospace">${item.numbers.map(formatNumber).join(' • ')}</div>
+                <span class="badge bg-warning text-dark">${item.hits}x</span>
+            </div>
+        `).join('');
+    }
+
+    function buildWeightedSequence() {
+        const pool = (lotteryData.weighted_numbers || []).filter(item => !annulledFunnel.has(item.num));
+        const fallbackPool = [];
+        for (let i = 1; i <= lotteryData.max_number; i++) {
+            if (!annulledFunnel.has(i)) fallbackPool.push({ num: i, score: 1 });
+        }
+        const source = pool.length >= lotteryData.numbers_to_draw ? pool : fallbackPool;
+        const selected = [];
+        const available = source.map(item => ({ ...item }));
+
+        while (available.length && selected.length < lotteryData.numbers_to_draw) {
+            const totalWeight = available.reduce((acc, item) => acc + Math.max(item.score || 1, 0.1), 0);
+            let threshold = Math.random() * totalWeight;
+            let chosenIndex = available.length - 1;
+
+            for (let idx = 0; idx < available.length; idx++) {
+                threshold -= Math.max(available[idx].score || 1, 0.1);
+                if (threshold <= 0) {
+                    chosenIndex = idx;
+                    break;
+                }
+            }
+
+            const [picked] = available.splice(chosenIndex, 1);
+            if (picked && !selected.includes(picked.num)) {
+                selected.push(picked.num);
+            }
+        }
+
+        return selected.sort((a, b) => a - b);
+    }
+
+    // Recalibragem do motor estatístico
     async function recalculateDeepElite() {
         if (!lotteryData) return;
         
         const key = lotterySelect.value;
-        speak(`Sincronizando Supercomputador com 10.000 concursos da ${lotteryData.name}.`);
+        speak(`Sincronizando Supercomputador com ${lotteryData.supercomputer_sync || 10000} simulações da ${lotteryData.name}.`);
         
         const resp = await fetch(`/api/lottery-info/${key}/`);
         lotteryData = await resp.json();
         
         fillEliteInputs(lotteryData.elite_greens);
         updateElitePanel();
+        updateMetricsPanel();
         
-        speak("Matemática de Elite aplicada com convergência de 99.9%. Previsão para o próximo sorteio calculada.");
+        speak("Análise atualizada com base no histórico real, atrasos e 10.000 simulações.");
     }
 
     lotterySelect.addEventListener("change", async (e) => {
@@ -360,7 +457,6 @@
         if (!key) return;
         
         document.getElementById("lottery-display").innerText = e.target.options[e.target.selectedIndex].text;
-        document.getElementById("concurso-info").innerText = "SINCRO 10K: OK";
         
         const resp = await fetch(`/api/lottery-info/${key}/`);
         lotteryData = await resp.json();
@@ -378,6 +474,7 @@
         setupFunnel(lotteryData.max_number);
         fillEliteInputs(lotteryData.elite_greens);
         updateElitePanel();
+        updateMetricsPanel();
         
         btnStart.disabled = false;
         resetGenerator();
@@ -431,7 +528,7 @@
         if (lotteryData.next_prediction) {
             const nextDiv = document.createElement("div");
             nextDiv.className = "w-100 mt-2 p-2 rounded bg-black border border-warning text-center";
-            nextDiv.innerHTML = `<span class="x-small text-warning fw-bold">PRÓXIMO SORTEIO PREVISTO: </span><br>`;
+            nextDiv.innerHTML = `<span class="x-small text-warning fw-bold">FAIXA PRIORITÁRIA DO PRÓXIMO JOGO: </span><br>`;
             lotteryData.next_prediction.forEach(n => {
                 nextDiv.innerHTML += `<span class="badge bg-warning text-dark me-1">${n.toString().padStart(2, "0")}</span>`;
             });
@@ -471,20 +568,12 @@
 
         for (let i = 0; i < 5; i++) {
             let sequence = [];
-            let attempts = 0;
             
-            while (sequence.length < nToDraw && attempts < 500) {
-                let val;
-                if (eliteModeActive && eliteNums.length >= nToDraw) {
-                    val = eliteNums[Math.floor(Math.random() * eliteNums.length)];
-                } else {
-                    val = Math.floor(Math.random() * maxNum) + 1;
-                }
-                
-                if (!annulledFunnel.has(val) && !sequence.includes(val)) {
-                    sequence.push(val);
-                }
-                attempts++;
+            if (eliteModeActive && eliteNums.length >= nToDraw) {
+                const shuffledElite = [...eliteNums].filter(val => !annulledFunnel.has(val)).sort(() => Math.random() - 0.5);
+                sequence = shuffledElite.slice(0, nToDraw);
+            } else {
+                sequence = buildWeightedSequence();
             }
 
             if (sequence.length === nToDraw) {
@@ -550,7 +639,7 @@
         generatorRunning = true;
         btnStart.classList.add("d-none");
         btnPause.classList.remove("d-none");
-        speak("Cálculos iniciados. Supercomputador sincronizado com 10.000 concursos.");
+        speak("Cálculos iniciados. Supercomputador sincronizado com 10.000 simulações estatísticas.");
         generateChunk();
     });
 
@@ -595,7 +684,7 @@
         let html = `
             <html>
             <head>
-                <title>HITS DE ELITE - Supercomputador 99.9%</title>
+                <title>HITS DE ELITE - Supercomputador Estatístico</title>
                 <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
                 <style>
                     body { background: #000; color: #fff; font-family: sans-serif; padding: 20px; }
@@ -608,7 +697,7 @@
             <body>
                 <div class="container">
                     <h1 class="text-center mb-4">TODOS OS JOGOS DE ELITE GERADOS</h1>
-                    <p class="text-center text-secondary">Sincronizado com 10.000 concursos - Precisão 99.9%</p>
+                    <p class="text-center text-secondary">Sincronizado com 10.000 simulações e histórico real das loterias</p>
                     <div class="row">
         `;
         

core/views.py

@@ -12,6 +12,9 @@ from .forms import LotterySimulatorForm
 from .models import AdminAccess, DrawResult, Lottery
 
 
+SUPERCOMPUTER_SIMULATION_COUNT = 10000
+
+
 def _format_int(value):
     return f"{int(value):,}".replace(",", ".")
 
@@ -24,6 +27,18 @@ def _format_percent(value):
     return f"{value:.6f}%".replace(".", ",")
 
 
+def _format_decimal(value, digits=1):
+    return f"{value:.{digits}f}".replace(".", ",")
+
+
+def _format_odds(max_number, numbers_to_draw):
+    try:
+        total_combinations = math.comb(max_number, numbers_to_draw)
+    except ValueError:
+        return "Configuração personalizada"
+    return f"1 em {_format_int(total_combinations)}"
+
+
 def _parse_annulled_numbers(lottery):
     return [int(number.strip()) for number in lottery.annulled_numbers.split(",") if number.strip().isdigit()]
 
@@ -115,22 +130,183 @@ def _build_lottery_cards(lotteries):
 
     cards = []
     for lottery in lotteries:
-        try:
-            combinations = math.comb(lottery.max_number, lottery.numbers_to_draw)
-            odds = f"1 em {_format_int(combinations)}"
-        except ValueError:
-            odds = "Configuração personalizada"
-
         cards.append({
             "label": lottery.get_name_display(),
             "tagline": tagline_map.get(lottery.name, "Análise estatística por histórico real"),
             "picks": lottery.numbers_to_draw,
             "range_max": lottery.max_number,
-            "odds": odds,
+            "odds": _format_odds(lottery.max_number, lottery.numbers_to_draw),
         })
     return cards
 
 
+def _weighted_sample_without_replacement(numbers, weight_map, picks, rng):
+    available = list(numbers)
+    selected = []
+
+    while available and len(selected) < picks:
+        weights = [max(float(weight_map.get(number, 1.0)), 0.001) for number in available]
+        total_weight = sum(weights)
+
+        if total_weight <= 0:
+            choice = rng.choice(available)
+        else:
+            threshold = rng.uniform(0, total_weight)
+            cumulative = 0
+            choice = available[-1]
+            for number, weight in zip(available, weights):
+                cumulative += weight
+                if cumulative >= threshold:
+                    choice = number
+                    break
+
+        selected.append(choice)
+        available.remove(choice)
+
+    return sorted(selected)
+
+
+def _build_supercomputer_payload(lottery, simulation_count=SUPERCOMPUTER_SIMULATION_COUNT):
+    annulled = _parse_annulled_numbers(lottery)
+    annulled_set = set(annulled)
+    draws_db = DrawResult.objects.filter(lottery=lottery).order_by("draw_number")
+    real_draws = [
+        [int(number) for number in draw.numbers.split(",") if number]
+        for draw in draws_db
+    ]
+    total_real_draws = len(real_draws)
+    last_real_num = draws_db.last().draw_number if draws_db.exists() else 0
+    last_real_draw = real_draws[-1] if real_draws else []
+
+    if total_real_draws:
+        configured_window = lottery.analysis_window or min(total_real_draws, 60)
+        analysis_window = min(total_real_draws, configured_window)
+        recent_draws = real_draws[-analysis_window:]
+    else:
+        analysis_window = 0
+        recent_draws = []
+
+    recent_total = max(len(recent_draws), 1)
+    history_total = max(total_real_draws, 1)
+    trend_window = recent_draws[-12:] if recent_draws else []
+    trend_total = max(len(trend_window), 1)
+
+    counts_recent = Counter(number for draw in recent_draws for number in draw)
+    counts_total = Counter(number for draw in real_draws for number in draw)
+    counts_trend = Counter(number for draw in trend_window for number in draw)
+
+    last_seen_recent = {}
+    for distance, draw in enumerate(reversed(recent_draws), start=1):
+        for number in draw:
+            last_seen_recent.setdefault(number, distance)
+
+    all_numbers = list(range(1, lottery.max_number + 1))
+    available_numbers = [number for number in all_numbers if number not in annulled_set]
+
+    base_scores = {}
+    unfiltered_scores = []
+    for number in all_numbers:
+        recent_frequency = counts_recent.get(number, 0) / recent_total
+        total_frequency = counts_total.get(number, 0) / history_total
+        trend_frequency = counts_trend.get(number, 0) / trend_total
+        delay_ratio = min(last_seen_recent.get(number, recent_total), recent_total) / recent_total
+        last_draw_penalty = 0.08 if number in last_real_draw else 0
+        base_score = max(
+            0.01,
+            (recent_frequency * 0.38)
+            + (total_frequency * 0.22)
+            + (trend_frequency * 0.20)
+            + (delay_ratio * 0.28)
+            - last_draw_penalty,
+        )
+        base_scores[number] = base_score
+        unfiltered_scores.append((number, base_score))
+
+    if not available_numbers:
+        available_numbers = all_numbers
+
+    weight_map = {number: 1 + (base_scores[number] * 100) for number in available_numbers}
+    rng = random.Random(f"{lottery.name}:{last_real_num}:{total_real_draws}:{simulation_count}")
+
+    simulated_number_counts = Counter()
+    sequence_counter = Counter()
+    top_window_size = max(lottery.numbers_to_draw * 2, lottery.numbers_to_draw)
+    ranked_base = [number for number, _ in sorted(
+        ((number, base_scores[number]) for number in available_numbers),
+        key=lambda item: (-item[1], item[0]),
+    )]
+    priority_window = set(ranked_base[:top_window_size])
+    aggregate_overlap = 0
+
+    for _ in range(simulation_count):
+        sequence = _weighted_sample_without_replacement(
+            available_numbers,
+            weight_map,
+            lottery.numbers_to_draw,
+            rng,
+        )
+        sequence_key = tuple(sequence)
+        sequence_counter[sequence_key] += 1
+        aggregate_overlap += sum(1 for number in sequence if number in priority_window)
+        for number in sequence:
+            simulated_number_counts[number] += 1
+
+    filtered_candidates = []
+    for number in available_numbers:
+        simulation_rate = simulated_number_counts[number] / simulation_count if simulation_count else 0
+        final_score = (base_scores[number] * 0.65) + (simulation_rate * 0.35)
+        filtered_candidates.append({
+            "num": number,
+            "score": round(final_score * 100, 2),
+            "sim_rate": round(simulation_rate * 100, 2),
+        })
+
+    filtered_candidates.sort(key=lambda item: (-item["score"], item["num"]))
+    unfiltered_scores.sort(key=lambda item: (-item[1], item[0]))
+
+    elite_greens = [candidate["num"] for candidate in filtered_candidates[: min(20, len(filtered_candidates))]]
+    next_prediction = sorted(candidate["num"] for candidate in filtered_candidates[: lottery.numbers_to_draw])
+    reclaimed_numbers = [number for number, _ in unfiltered_scores if number in annulled_set][:5]
+    top_sequences = [
+        {
+            "numbers": list(sequence),
+            "hits": hits,
+        }
+        for sequence, hits in sequence_counter.most_common(3)
+    ]
+
+    signal_strength = 0.0
+    if next_prediction:
+        signal_strength = sum(
+            next(candidate["score"] for candidate in filtered_candidates if candidate["num"] == number)
+            for number in next_prediction
+        ) / len(next_prediction)
+
+    average_priority_overlap = (aggregate_overlap / simulation_count) if simulation_count else 0
+
+    return {
+        "name": lottery.get_name_display(),
+        "max_number": lottery.max_number,
+        "numbers_to_draw": lottery.numbers_to_draw,
+        "elite_greens": elite_greens,
+        "annulled_numbers": annulled,
+        "reclaimed_numbers": reclaimed_numbers,
+        "supercomputer_sync": simulation_count,
+        "last_real_contest": last_real_num,
+        "last_real_draw": last_real_draw,
+        "total_real_draws": total_real_draws,
+        "analysis_window": analysis_window,
+        "next_prediction": next_prediction,
+        "signal_strength": round(signal_strength, 1),
+        "signal_label": f"{_format_decimal(signal_strength, 1)} / 100",
+        "priority_overlap": round(average_priority_overlap, 2),
+        "combination_odds": _format_odds(lottery.max_number, lottery.numbers_to_draw),
+        "methodology": "Histórico recente + frequência + atraso + 10.000 simulações",
+        "weighted_numbers": filtered_candidates[: min(max(lottery.numbers_to_draw * 5, 20), len(filtered_candidates))],
+        "top_sequences": top_sequences,
+    }
+
+
 def _build_home_result(form):
     if not form.is_valid():
         return None
@@ -215,63 +391,15 @@ def home(request):
 def lottery_info_api(request, lottery_key):
     """Retorna indicadores estatísticos da loteria selecionada para o gerador sequencial."""
     lottery = get_object_or_404(Lottery, name=lottery_key)
-    annulled = _parse_annulled_numbers(lottery)
-
-    draws_db = DrawResult.objects.filter(lottery=lottery).order_by("draw_number")
-    real_draws = [[int(n) for n in draw.numbers.split(",")] for draw in draws_db]
-    last_real_num = draws_db.last().draw_number if draws_db.exists() else 0
-
-    random.seed(f"{lottery_key}_supercomputer")
-    all_draws = list(real_draws)
-    max_num = lottery.max_number
-    n_draw = lottery.numbers_to_draw
-
-    while len(all_draws) < 10000:
-        hist_flat = [number for draw in all_draws[-50:] for number in draw]
-        counts = Counter(hist_flat)
-        candidates = []
-        for number in range(1, max_num + 1):
-            score = 100 - (counts.get(number, 0) * 2)
-            candidates.append((number, score + random.randint(1, 10)))
-        candidates.sort(key=lambda item: item[1], reverse=True)
-        all_draws.append(sorted(candidate[0] for candidate in candidates[:n_draw]))
-
-    global_counts = Counter(number for draw in all_draws for number in draw)
-    last_seen_real = {}
-    for index, draw in enumerate(reversed(real_draws)):
-        for number in draw:
-            last_seen_real.setdefault(number, index)
-
-    elite_candidates = []
-    for number in range(1, max_num + 1):
-        if number in annulled:
-            continue
-        freq_score = (global_counts.get(number, 0) / 10000.0) * 100
-        delay_score = last_seen_real.get(number, len(real_draws)) * 1.5
-        total_score = (freq_score * 0.4) + (delay_score * 0.6)
-        elite_candidates.append({"num": number, "score": total_score})
-
-    elite_candidates.sort(key=lambda item: item["score"], reverse=True)
-    elite_greens = [candidate["num"] for candidate in elite_candidates[:20]]
-    next_prediction = sorted(candidate["num"] for candidate in elite_candidates[:n_draw])
-
-    return JsonResponse({
-        "name": lottery.get_name_display(),
-        "max_number": lottery.max_number,
-        "numbers_to_draw": lottery.numbers_to_draw,
-        "elite_greens": elite_greens,
-        "annulled_numbers": annulled,
-        "reclaimed_numbers": [number for number in elite_greens if number in annulled][:5],
-        "supercomputer_sync": 10000,
-        "last_real_contest": last_real_num,
-        "next_prediction": next_prediction,
-        "precision": "99.9%",
-    })
+    return JsonResponse(_build_supercomputer_payload(lottery))
 
 
 def sequential_generator(request):
-    loterias = _lottery_queryset()
-    return render(request, "core/sequential_generator.html", {"loterias": loterias})
+    loterias = list(_lottery_queryset())
+    return render(request, "core/sequential_generator.html", {
+        "loterias": loterias,
+        "supercomputer_sync": SUPERCOMPUTER_SIMULATION_COUNT,
+    })
 
 
 def lottery_results(request):