Just Some Notes to Remember on New Computational and Reductional Developments

[lotto_tom75]

esito: TERNO A COLPO 16.49.73 in c18

dettagli sfaldamento sperando si ripeta nel terzo caso consecutivo con la nuova condizione analoga..

1] almeno un ambo come nell'altro caso analogo e in questo frangente anche il terno ci sarebbe stato anche nel guc7 delle prime
tre terzine con ra max unico x s2.... e addirittura direttamente un ambo in una di queste tre...

2] analizzando l'intero guc18 x s1 in c1 su VE by 1871 il terno e quindi anche i tre ambi relativi si sarebbe(ro) trovato(i) nel guc9 delle prime 9 fq min (uniche e isofreq)

3] sviluppando questo guc9 in c5 x s2 su VE il terno si sarebbe trovato nel guc6 delle prime due c5 con fq max unica aventi 4 elementi comuni

4] infine sviluppando il guc6 in c4 xs3 su VE by 1871 quella unica con fq 0 avrebbe sfaldato i 3 points a colpo

Tutti i tre numeri usciti facevano parte anche della absc29 che quindi già adesso ha un altra ruota "illuminata" da jarvis: RO.

Proverò a postare a rilevare la c6 e la c4 ( o lunghette di classe <= 10 analoghe) per RO seguendo esattamente gli stessi analoghi steps riduzionali... che hanno portato alla win a colpo "virtuale" su MI (ambo) e VE (terno) in queste due occasioni "caso studio" distinte e consecutive.

ROMA 9-13-23-36-49-61-81-89-90 << nuovo punto di teorica rottura della nuova cx in questo caso c41 "ibrida" absc33 + 8 dynamic by 90 diff 1 x s2 su r target. Il guc9 è come negli altri due casi il gruppo unione delle prime tre c3 con ra max xs2 su RO (new Jarvis Wheel) by c41. Il gucy delle c3 xs2 con ra max > 900 su RO sarebbe di 22 elementi questa volta e solo per monitoraggio per eventuale sfaldamento in minimo 2 points su RO entro 1(+1) shots sarebbe questo: 5.9.11.13.16.23.30.36.42.43.49.55.59.61.63.67.68.81.83.86.89.90.

Nessuna Certezza Solo Poca Probabilità

Esito a colpo in c22 e quindi anche in c41 RO 16_36 . Il laghetto per la "pesca" a colpo sembra essersi ridotto notevolmente...

 

[lotto_tom75]

nuovo workflow riduzionale... forse interessante...

1) by 20inars1 -> sviluppo incmaxp in c4 x s2 su 2p su 10r unite by 1871
2) unione delle risultanze (es. 3 risultanze del caso studio)
3) sviluppo del gucx del punto 2 in c5 xs2 su 10r unite by 1871
4) scelta al punto 3 della c5 con fq min unica
5) sviluppo della c5 del punto 4 in c1 x s1 su 10r unite by 1871 e scelta e unione delle prime 3 fq max uniche... in gucy (es guc4)
6) sviluppo della c5 in c2 x s2 su 10r unite by 1871 e scelta e unione delle fq max (anche se isofreq) e fq min unica in gucy (es. guc4)
7) sviluppo della c5 in c3 x s2 su 10r unite by 1871 e scelta e unione delle fq max e min uniche in gucy (es. guc4)
8) analisi x s3 in gucy (es. guc4) su 10r separate e scelta della r con ra max unico (es. ro che ha sfaldato s2 a colpo in c4 nel caso studio).

 

[lotto_tom75]

Nuovo workflow per utopico target di s2 in 1s su 1r in micro lunghetta di classe <= 10.

1) A partire da qualsiasi ruota (meglio dalle 7 sisters che sono presenti dal 1871 o dalla ruota indicata da jarvis) e a partire da qualsiasi abs (es. absc33 x s2 su 7s) trovare con apposito tool ls la percentuale > = 98% + di esiti a colpo x s2 by diff 1 by 1871 in formazioni ibride (abs + componente random come ad es. c66 (absc33 + 33 rnd) -> prendere in considerazione i numeri selezionati alla fine del filtro xs2 in c3 >= 900 su r target by 1871 dell'ordine di ca 54 elementi.
2) Analizzare per incmaxp per s1 in c3 da 1 a 5p unite su r target by 1871 e unire le risultanze (dopo 1h ca di elab.) nel relativo gucx che sarà spesso e volentieri dell'ordine di 40 elementi ca.
3) Passo contro intuitivo ma fondamentale : non prendere il gux degli elementi risultanti dall'analisi incmaxp bensì i differenziali tra i numeri ottenuti al punto 1 e questo gux ottenendo un gruppo di "differenziali anguille posizionali" di ca 20 elementi.
4) Sviluppare con matrice iperfast questo gruppo di 20 elementi ca in c8 x s2 su r target by 1871 e scegliere come base primaria la formazione con ind conv max unico (meglio se >= 5.0) ; per tentare massima riduzione anche gli eventuali convergenti tra ind conv max unico, rs max unico , rs min unico , diff max unica e diff min unica.
5) provare a sviluppare la c8 scelta per ind conv max unico in c5 xs2 su r target by 1871 e scegliere quella con fq max unica.
6) così facendo almeno per adesso per 3 volte consecutive di cui l'ultima è stata questa ho ottenuto minimo s1 a colpo in c2 su r target.


tool ls di cui sopra (al punto 1) creato by Gemma Spacy (Gemini 3.5 flash) and me.

'SpazioScript - Analizzatore Combinazioni con Rolling Backtest, Analisi Ipergeometrica & Filtrazione Selettiva
'Versione v2.3 (ByVal Stack Protection & Deterministic Sorting)
Sub Main()
    ' Dichiarazione delle variabili principali
    Dim aFissi,aPool,aComboCompleta,aSfissi
    Dim nFissi,nDinamici,nRuota,nSorte,max_diff
    Dim i,r,temp,k,c
    Dim RetRit,RetRitMax,RetIncrRitMax,RetFreq
    Dim nInizio,nFine
    Dim sFissi,sDinamici,sCompleta
    Dim nDiff,nTrovate
    Dim sFissiTemp,aFissiString
    Dim aRuote(1)
 
    ' Variabili per il calcolo dello spazio combinatorio e probabilità
    Dim nIntegrali,nCoperturaPerc
    Dim nClasseIbrida,nAmbiInClasse,nCoverageAmbiPerc
    Dim nComb90_5,nComb90MinusC_5,nComb90MinusC_4,p0,p1,pAtLeast2,pAtLeast2Perc
 
    ' Variabili per il Backtest Rolling
    Dim bEseguiBacktest,nRangeBacktest,nCombinazioniBT,nColpi
    Dim nStartBT,nEndBT,t,iBT,nCasiTotali,nCasiVincenti
    Dim nTrovateInQuestoT,FreqEsito,sPercent
 
    ' Variabili per la Mappatura di Pre-Sfaldamento dei Singoli Estratti
    Dim nTotalWNums,nSumRA,nSumRS,nSumFreq
    Dim nFascia1,nFascia2,nFascia3,nFascia4
    Dim tEsito,colpo,aInCombo,nVal,Pos,Estr,matchesCount,aMatches
    Dim idxM,WNum,aNumSingle,RA_single,RS_single,Freq_single
 
    ' Variabili per il Salvataggio e l'Ordinamento in Memoria (Sostituiscono la tabella grafica)
    Dim nMaxSalvate,nSalvateCount
    Dim aSalvateComboStr,aSalvateFissiStr,aSalvateDinamiciStr
    Dim aSalvateDiff,aSalvateRA,aSalvateRS,aSalvateFreq,aSalvateNumeri
    Dim x,y,bScambiato,bScambia
    Dim tempDiff,tempRA,tempRS,tempFreq,tempComboStr,tempFissiStr,tempDinamiciStr,tempNum,colNum
 
    ' Variabili per la Filtrazione Dinamica (Fase 3)
    Dim bMiglioreTrovata,aMiglioreComboDiOggi
    Dim bFasciaFav(4),sFasceFav,anyFasciaActive,maxFascia,maxCount
    Dim aFavoriti,nFavoritiCount,numCurrent,RA_current,fasciaCurrent
 
    ' Variabili per i filtri finali (Fase 4)
    Dim nTipoFiltroFinale ' 1 = Multi-Convergenza Terzine | 2 = Riduzione Sequenziale Quartine
    Dim nMinRATerzina ' Ritardo minimo per Ambo in Terzina (~6.7 cicli = 900)
    Dim nMaxElementiUnione ' Soglia massima di giocabilità impostata dall'utente (es. 22)
    Dim nMinPresenze ' Per Filtro 1: presenze minime nelle terzine iper-ritardate
    Dim nMinRAQuartina ' Per Filtro 2: ritardo minimo per Ambo in Quartina (~7 cicli = 467)
 
    Dim i1,i2,i3,nRA_terz,aTerzina,aUnionMap,nUnionCount,aUnionNumeri,nCombTotaliTerz
    Dim aUnionFreq,q1,q2,q3,q4,aQuartina,aQuartUnionMap,nQuartUnionCount,aQuartUnionNumeri,nRA_quart,nCombTotaliQuart
 
    ' Variabili per l'analisi odierna
    Dim nCombinazioniOggi,nTopPrint,idxP
 
    ' Inizializzazione del generatore casuale nativo di VBScript
    Randomize

    ' ==================================================================
    ' --- CONFIGURAZIONE PARAMETRI ---
    nRuota = PA_ ' Ruota di Palermo (PA)
    nSorte = 2 ' Sorte di ricerca: 2 = AMBO
    max_diff = 1 ' Massimo scarto (RS - RA) per ritenere idonea una combinazione
    nDinamici = 33 ' Numero di elementi dinamici da pescare dal pool (Ora protetto da ByVal!)
 
    ' PARAMETRI PER L'ANALISI CORRENTE (OGGI)
    nCombinazioniOggi = 10000 ' Quante combinazioni testare per l'estrazione odierna
 
    ' PARAMETRI PER IL ROLLING BACKTEST & MAPPATURA
    bEseguiBacktest = True ' True = Attiva il Backtest e la Mappatura; False = Salta
    nRangeBacktest = 100 ' Quante estrazioni andare indietro nel passato (es. ultime 30)
    nCombinazioniBT = 500 ' Combinazioni da generare per ogni estrazione passata
    nColpi = 1 ' Colpi di gioco per verificare lo sfaldamento
 
    ' ------------------------------------------------------------------
    ' --- IMPOSTAZIONE PARAMETRI DI FILTRAZIONE FINALE (FASE 4) ---
    ' ------------------------------------------------------------------
    nTipoFiltroFinale = 2 ' SCEGLI: 1 = Multi-Convergenza Terzine | 2 = Riduzione Sequenziale Quartine
    nMinRATerzina = 900 ' Ritardo Attuale minimo per Ambo della terzina (6.7 cicli = 900)
    nMaxElementiUnione = 22 ' Limite massimo di elementi nell'unione finale (es. 22)
 
    ' Parametri specifici se nTipoFiltroFinale = 1 (Multi-Convergenza)
    nMinPresenze = 2 ' Presenza minima di un numero nelle terzine iper-ritardate (es. 2 o 3)
 
    ' Parametri specifici se nTipoFiltroFinale = 2 (Riduzione Sequenziale Quartine)
    nMinRAQuartina = 467 ' Ritardo Attuale minimo per Ambo in Quartina (7 cicli = 467)
    ' ==================================================================

    ' Prepariamo l'array delle ruote
    aRuote(1) = nRuota

    ' Range di analisi dell'archivio complessivo
    nInizio = 1
    nFine = EstrazioneFin

    ' Calcolo dei limiti temporali del Backtest
    nStartBT = nFine - nRangeBacktest
    If nStartBT < nInizio Then nStartBT = nInizio
    nEndBT = nFine - nColpi
    If nEndBT < nStartBT Then nEndBT = nStartBT

    ' Inizializzazione contatori della mappatura pre-sfaldamento
    nTotalWNums = 0
    nSumRA = 0
    nSumRS = 0
    nSumFreq = 0
    nFascia1 = 0
    nFascia2 = 0
    nFascia3 = 0
    nFascia4 = 0
 
    bMiglioreTrovata = False
    ReDim aNumSingle(1)

    ' es. caricamento dei 33 numeri fissi dell'esempio workflow...
    sFissiTemp = "1.2.3.4.5.6.7.8.9.10"  # es. numeri fittizi voluti fissi... ( in questo caso solo 10.. )
 
 
 
 
 
    aFissiString = Split(sFissiTemp,".")
    nFissi = UBound(aFissiString) + 1

    ReDim aFissi(nFissi)
    ReDim aSfissi(90)

    For i = 1 To nFissi
        aFissi(i) = CInt(aFissiString(i - 1))
        aSfissi(aFissi(i)) = True
    Next

    ' Creazione del Pool con i rimanenti numeri
    Dim nPoolSize
    nPoolSize = 90 - nFissi
    ReDim aPool(nPoolSize)
    c = 0
    For i = 1 To 90
        If Not aSfissi(i) Then
            c = c + 1
            aPool(c) = i
        End If
    Next
 
    ' Inizializziamo le strutture di salvataggio in memoria (Max 1000 righe per l'output)
    nMaxSalvate = 1000
    nSalvateCount = 0
    ReDim aSalvateComboStr(nMaxSalvate)
    ReDim aSalvateFissiStr(nMaxSalvate)
    ReDim aSalvateDinamiciStr(nMaxSalvate)
    ReDim aSalvateDiff(nMaxSalvate)
    ReDim aSalvateRA(nMaxSalvate)
    ReDim aSalvateRS(nMaxSalvate)
    ReDim aSalvateFreq(nMaxSalvate)
    ReDim aSalvateNumeri(nMaxSalvate,nFissi + nDinamici)

    ' Presentazione a video delle informazioni iniziali
    Call Titolazione()
 
    ' ==================================================================
    ' --- FASE 1: ROLLING BACKTEST & MAPPATURA NEL PASSATO ---
    ' ==================================================================
    If bEseguiBacktest Then
        Call Scrivi("==========================================================================================")
        Call Scrivi("                 FASE 1: ROLLING BACKTEST & MAPPATURA DEI SINGOLI ESTRATTI",True)
        Call Scrivi("==========================================================================================")
        Call Scrivi("Avvio della simulazione storica passata passo-passo...")
        Call Scrivi("Ogni estrazione passata viene analizzata singolarmente. Se una combinazione idonea vince,")
        Call Scrivi("mappiamo i parametri di ritardo e frequenza dei singoli numeri che hanno composto l'ambo.")
        Call Scrivi("")
     
        nCasiTotali = 0
        nCasiVincenti = 0
     
        For t = nStartBT To nEndBT
            Call AvanzamentoElab(nStartBT,nEndBT,t)
            Call Messaggio("Backtest Estrazione: " & t & " / " & nEndBT & " | Casi: " & nCasiTotali)
            If ScriptInterrotto Then Exit For
         
            nTrovateInQuestoT = 0
         
            For iBT = 1 To nCombinazioniBT
                For k = 1 To nDinamici
                    r = Int((nPoolSize - k + 1) * Rnd + k)
                    temp = aPool(k)
                    aPool(k) = aPool(r)
                    aPool(r) = temp
                Next
             
                ReDim aComboCompleta(nFissi + nDinamici)
                For k = 1 To nFissi
                    aComboCompleta(k) = aFissi(k)
                Next
                For k = 1 To nDinamici
                    aComboCompleta(nFissi + k) = aPool(k)
                Next
             
                Call OrdinaMatrice(aComboCompleta,1)
             
                Call StatisticaFormazioneTurbo(aComboCompleta,aRuote,nSorte,RetRit,RetRitMax,RetIncrRitMax,RetFreq,nInizio,t)
             
                nDiff = RetRitMax - RetRit
             
                If nDiff <= max_diff Then
                    nCasiTotali = nCasiTotali + 1
                    nTrovateInQuestoT = nTrovateInQuestoT + 1
                 
                    FreqEsito = SerieFreqTurbo(t + 1,t + nColpi,aComboCompleta,aRuote,nSorte)
                 
                    If FreqEsito > 0 Then
                        nCasiVincenti = nCasiVincenti + 1
                     
                        tEsito = 0
                        For colpo = 1 To nColpi
                            If t + colpo <= nFine Then
                                If SerieFreqTurbo(t + colpo,t + colpo,aComboCompleta,aRuote,nSorte) > 0 Then
                                    tEsito = t + colpo
                                    Exit For
                                End If
                            End If
                        Next
                     
                        If tEsito > 0 Then
                            ReDim aInCombo(90)
                            For nVal = 1 To 90
                                aInCombo(nVal) = False
                            Next
                            For nVal = 1 To UBound(aComboCompleta)
                                aInCombo(aComboCompleta(nVal)) = True
                            Next
                         
                            ReDim aMatches(5)
                            matchesCount = 0
                            For Pos = 1 To 5
                                Estr = Estratto(tEsito,nRuota,Pos)
                                If aInCombo(Estr) Then
                                    matchesCount = matchesCount + 1
                                    aMatches(matchesCount) = Estr
                                End If
                            Next
                         
                            For idxM = 1 To matchesCount
                                WNum = aMatches(idxM)
                                aNumSingle(1) = WNum
                             
                                RA_single = SerieRitardoTurbo(nInizio,t,aNumSingle,aRuote,1)
                                RS_single = SerieStoricoTurbo(nInizio,t,aNumSingle,aRuote,1)
                                Freq_single = SerieFreqTurbo(nInizio,t,aNumSingle,aRuote,1)
                             
                                nTotalWNums = nTotalWNums + 1
                                nSumRA = nSumRA + RA_single
                                nSumRS = nSumRS + RS_single
                                nSumFreq = nSumFreq + Freq_single
                             
                                If RA_single <= 9 Then
                                    nFascia1 = nFascia1 + 1
                                ElseIf RA_single <= 18 Then
                                    nFascia2 = nFascia2 + 1
                                ElseIf RA_single <= 36 Then
                                    nFascia3 = nFascia3 + 1
                                Else
                                    nFascia4 = nFascia4 + 1
                                End If
                            Next
                        End If
                    End If
                End If
            Next
         
            If nCasiTotali > 0 Then
                sPercent = Round((nCasiVincenti / nCasiTotali) * 100,1) & "%"
            Else
                sPercent = "0.0%"
            End If
         
            Call Scrivi("Estr. " & t & " (" & DataEstrazione(t) & ") | Idonee trovate: " & nTrovateInQuestoT & " | Progressivo: " & nCasiVincenti & " vinti su " & nCasiTotali & " casi (" & sPercent & ")")
        Next
     
        Call Scrivi("")
        Call Scrivi("------------------------------------------------------------------------------------------")
        Call Scrivi("RIEPILOGO STORICO BACKTEST ROLLING:",True)
        Call Scrivi("Totale combinazioni idonee rilevate nel passato: " & nCasiTotali)
        Call Scrivi("Totale combinazioni vincenti entro " & nColpi & " colpi: " & nCasiVincenti)
        Call Scrivi("Rendimento medio (Win-Rate) della strategia: " & sPercent,True)
        Call Scrivi("------------------------------------------------------------------------------------------")
        Call Scrivi("")
     
        If nTotalWNums > 0 Then
            Call Scrivi("==========================================================================================",True)
            Call Scrivi("    MAPPATURA STATISTICA PRE-SFALDAMENTO DEI SINGOLI ESTRATTI VINCENTI (AMBO)",True)
            Call Scrivi("==========================================================================================",True)
            Call Scrivi("Analisi eseguita su un campione di " & nTotalWNums & " singoli estratti usciti nelle vincite:")
            Call Scrivi(" - Ritardo Medio individuale un attimo prima dell'uscita: " & Round(nSumRA / nTotalWNums,1) & " estrazioni")
            Call Scrivi(" - Ritardo Storico Medio individuale dei numeri vincenti : " & Round(nSumRS / nTotalWNums,1) & " estrazioni")
            Call Scrivi(" - Frequenza Media individuale dei numeri usciti        : " & Round(nSumFreq / nTotalWNums,1) & " presenze")
            Call Scrivi("")
            Call Scrivi("DISTRIBUZIONE DEL RITARDO (RA) AL MOMENTO DEL RILEVAMENTO:")
            Call Scrivi(" - Fascia 1 (Ritardo da 0 a 9 colpi - Warm)      : " & nFascia1 & " estratti (" & Round((nFascia1 / nTotalWNums) * 100,1) & "%)")
            Call Scrivi(" - Fascia 2 (Ritardo da 10 a 18 colpi - Medium)  : " & nFascia2 & " estratti (" & Round((nFascia2 / nTotalWNums) * 100,1) & "%)")
            Call Scrivi(" - Fascia 3 (Ritardo da 19 a 36 colpi - Cold)    : " & nFascia3 & " estratti (" & Round((nFascia3 / nTotalWNums) * 100,1) & "%)")
            Call Scrivi(" - Fascia 4 (Ritardo superiore a 36 colpi - Ice) : " & nFascia4 & " estratti (" & Round((nFascia4 / nTotalWNums) * 100,1) & "%)")
            Call Scrivi("==========================================================================================")
            Call Scrivi("")
        End If
    End If

    ' ==================================================================
    ' --- FASE 2: ANALISI COMBINAZIONI PER L'ESTRAZIONE CORRENTE ---
    ' ==================================================================
    ' Calcoli matematici e probabilistici della classe
    nClasseIbrida = nFissi + nDinamici
    nAmbiInClasse = CombinazioniSenzaRipetizione(nClasseIbrida,2)
    nCoverageAmbiPerc =(nAmbiInClasse / 4005) * 100
 
    nComb90_5 = CombinazioniSenzaRipetizione(90,5)
    nComb90MinusC_5 = CombinazioniSenzaRipetizione(90 - nClasseIbrida,5)
    nComb90MinusC_4 = CombinazioniSenzaRipetizione(90 - nClasseIbrida,4)
 
    p0 = nComb90MinusC_5 / nComb90_5
    p1 =(nClasseIbrida * nComb90MinusC_4) / nComb90_5
    pAtLeast2 = 1.0 - p0 - p1
    pAtLeast2Perc = pAtLeast2 * 100
 
    ' Ora protetto da ByVal, nDinamici non viene più corrotto internamente!
    nIntegrali = CombinazioniSenzaRipetizione(90 - nFissi,nDinamici)
    nCoperturaPerc =(nCombinazioniOggi / nIntegrali) * 100
 
    Call Scrivi("==========================================================================================")
    Call Scrivi("                 FASE 2: ANALISI PER L'ESTRAZIONE CORRENTE (DI OGGI)",True)
    Call Scrivi("==========================================================================================")
    Call Scrivi("DATI PARAMETRICI DELL'ANALISI:")
    Call Scrivi(" - Ruota di Analisi                        : " & NomeRuota(nRuota))
    Call Scrivi(" - Sorte Target                            : " & nSorte & " (Ambo)")
    Call Scrivi(" - Estrazione di Riferimento               : " & nFine & " (" & DataEstrazione(nFine) & ")")
    Call Scrivi(" - Struttura Massa Ibrida                  : " & nFissi & " Fissi + " & nDinamici & " Dinamici (Totale: " & nClasseIbrida & " numeri)")
    Call Scrivi(" - Dimensione Pool Numeri Dinamici         : " &(90 - nFissi) & " numeri")
    Call Scrivi(" - Filtro Scarto Massimo (max_diff)        : <= " & max_diff)
    Call Scrivi(" - Combinazioni Integrali Teoriche         : " & FormatNumber(nIntegrali,0))
    Call Scrivi(" - Combinazioni Ibride Generate per Test   : " & FormatNumber(nCombinazioniOggi,0))
    Call Scrivi(" - Percentuale di Copertura dell'Analisi   : " & FormatNumber(nCoperturaPerc,6) & "%")
    Call Scrivi("")
    Call Scrivi("GIUSTIFICAZIONE MATEMATICA DELLA CLASSE IBRIDA SCELTA:")
    Call Scrivi(" - Classe Ibrida Attiva                    : " & nClasseIbrida & " numeri")
    Call Scrivi(" - Ambi Interni Sviluppabili               : " & nAmbiInClasse & " su 4.005 totali (" & FormatNumber(nCoverageAmbiPerc,2) & "% del totale)")
    Call Scrivi(" - Probabilità Matematica Ambo a Colpo     : " & FormatNumber(pAtLeast2Perc,2) & "% (Distribuzione Ipergeometrica)")
    Call Scrivi(" - Nota di Sintesi Statistica: ")
    Call Scrivi("   La scelta di questa classe numerica (" & nClasseIbrida & " numeri) è ottimizzata per garantire che")
    Call Scrivi("   la formazione di partenza contenga statisticamente almeno un ambo vincente in circa")
    Call Scrivi("   " & FormatNumber(pAtLeast2Perc,1) & " estrazioni su 100. Questo costituisce un eccellente bacino")
    Call Scrivi("   di partenza (massa numerica densa) su cui applicare i filtri di ritardo storici")
    Call Scrivi("   (Fase 2) e le riduzioni successive (Fase 3 e Fase 4), isolando solo i blocchi sincroni")
    Call Scrivi("   iper-ritardati pronti allo sfaldamento.")
    Call Scrivi("")
    Call Scrivi("Generazione e analisi di " & FormatNumber(nCombinazioniOggi,0) & " combinazioni per il prossimo colpo...")
    Call Scrivi("")

    nTrovate = 0

    For i = 1 To nCombinazioniOggi
        If i = 1 Or i Mod 2000 = 0 Or i = nCombinazioniOggi Then
            Call AvanzamentoElab(1,nCombinazioniOggi,i)
            Call Messaggio("Analisi odierna: " & i & " / " & nCombinazioniOggi & " | Idonee: " & nTrovate)
            If ScriptInterrotto Then Exit For
        End If

        For k = 1 To nDinamici
            r = Int((nPoolSize - k + 1) * Rnd + k)
            temp = aPool(k)
            aPool(k) = aPool(r)
            aPool(r) = temp
        Next

        ReDim aComboCompleta(nFissi + nDinamici)
        For k = 1 To nFissi
            aComboCompleta(k) = aFissi(k)
        Next
        For k = 1 To nDinamici
            aComboCompleta(nFissi + k) = aPool(k)
        Next

        Call OrdinaMatrice(aComboCompleta,1)

        Call StatisticaFormazioneTurbo(aComboCompleta,aRuote,nSorte,RetRit,RetRitMax,RetIncrRitMax,RetFreq,nInizio,nFine)

        nDiff = RetRitMax - RetRit

        If nDiff <= max_diff Then
            nTrovate = nTrovate + 1

            If nSalvateCount < nMaxSalvate Then
                nSalvateCount = nSalvateCount + 1
             
                aSalvateDiff(nSalvateCount) = nDiff
                aSalvateRA(nSalvateCount) = RetRit
                aSalvateRS(nSalvateCount) = RetRitMax
                aSalvateFreq(nSalvateCount) = RetFreq
             
                For k = 1 To UBound(aComboCompleta)
                    aSalvateNumeri(nSalvateCount,k) = aComboCompleta(k)
                Next
             
                Dim aDinamiciOrdinati
                ReDim aDinamiciOrdinati(nDinamici)
                For k = 1 To nDinamici
                    aDinamiciOrdinati(k) = aPool(k)
                Next
                Call OrdinaMatrice(aDinamiciOrdinati,1)

                aSalvateComboStr(nSalvateCount) = StringaNumeri(aComboCompleta,".")
                aSalvateFissiStr(nSalvateCount) = StringaNumeri(aFissi,".")
                aSalvateDinamiciStr(nSalvateCount) = StringaNumeri(aDinamiciOrdinati,".")
            End If
        End If
    Next

    If nSalvateCount > 0 Then
        Call Messaggio("Ordinamento dei risultati in corso...")
     
        For x = 1 To nSalvateCount - 1
            bScambiato = False
            For y = 1 To nSalvateCount - x
                bScambia = False
             
                If aSalvateDiff(y) > aSalvateDiff(y + 1) Then
                    bScambia = True
                ElseIf aSalvateDiff(y) = aSalvateDiff(y + 1) Then
                    If aSalvateRA(y) < aSalvateRA(y + 1) Then
                        bScambia = True
                    ElseIf aSalvateRA(y) = aSalvateRA(y + 1) Then
                        If aSalvateFreq(y) < aSalvateFreq(y + 1) Then
                            bScambia = True
                        End If
                    End If
                End If
             
                If bScambia Then
                    tempDiff = aSalvateDiff(y)
                    aSalvateDiff(y) = aSalvateDiff(y + 1)
                    aSalvateDiff(y + 1) = tempDiff
                 
                    tempRA = aSalvateRA(y)
                    aSalvateRA(y) = aSalvateRA(y + 1)
                    aSalvateRA(y + 1) = tempRA
                 
                    tempRS = aSalvateRS(y)
                    aSalvateRS(y) = aSalvateRS(y + 1)
                    aSalvateRS(y + 1) = tempRS
                 
                    tempFreq = aSalvateFreq(y)
                    aSalvateFreq(y) = aSalvateFreq(y + 1)
                    aSalvateFreq(y + 1) = tempFreq
                 
                    tempComboStr = aSalvateComboStr(y)
                    aSalvateComboStr(y) = aSalvateComboStr(y + 1)
                    aSalvateComboStr(y + 1) = tempComboStr
                 
                    tempFissiStr = aSalvateFissiStr(y)
                    aSalvateFissiStr(y) = aSalvateFissiStr(y + 1)
                    aSalvateFissiStr(y + 1) = tempFissiStr
                 
                    tempDinamiciStr = aSalvateDinamiciStr(y)
                    aSalvateDinamiciStr(y) = aSalvateDinamiciStr(y + 1)
                    aSalvateDinamiciStr(y + 1) = tempDinamiciStr
                 
                    For colNum = 1 To(nFissi + nDinamici)
                        tempNum = aSalvateNumeri(y,colNum)
                        aSalvateNumeri(y,colNum) = aSalvateNumeri(y + 1,colNum)
                        aSalvateNumeri(y + 1,colNum) = tempNum
                    Next
                 
                    bScambiato = True
                End If
            Next
            If Not bScambiato Then Exit For
        Next
     
        ReDim aMiglioreComboDiOggi(nFissi + nDinamici)
        For k = 1 To(nFissi + nDinamici)
            aMiglioreComboDiOggi(k) = aSalvateNumeri(1,k)
        Next
        bMiglioreTrovata = True
     
        nTopPrint = 20
        If nTopPrint > nSalvateCount Then nTopPrint = nSalvateCount
     
        Call Scrivi("?? CLASSIFICA TOP " & nTopPrint & " COMBINAZIONI MIGLIORI DI OGGI (Ord. Diff Crescente | RA Decrescente | Freq Decrescente):",True)
        Call Scrivi("Rank" & vbTab & "Diff" & vbTab & "RA" & vbTab & "RS" & vbTab & "Freq" & vbTab & "Combinazione Completa")
        Call Scrivi("---------------------------------------------------------------------------------------------------------")
        For idxP = 1 To nTopPrint
            Call Scrivi("#" & idxP & vbTab & aSalvateDiff(idxP) & vbTab & aSalvateRA(idxP) & vbTab & aSalvateRS(idxP) & vbTab & aSalvateFreq(idxP) & vbTab & aSalvateComboStr(idxP))
        Next
        Call Scrivi("---------------------------------------------------------------------------------------------------------")
        If nTrovate > nTopPrint Then
            Call Scrivi("... e altre " &(nTrovate - nTopPrint) & " combinazioni idonee salvate in memoria.")
        End If
        Call Scrivi("")
     
        Call Scrivi("==========================================================================================",True)
        Call Scrivi("?? COMBINAZIONE BASE ELETTA PER GLI SVILUPPI SUCCESSIVI (RANK #1):",True)
        Call Scrivi("   " & StringaNumeri(aMiglioreComboDiOggi,"."),True)
        Call Scrivi("   [Scelta deterministicamente per: Scarto min -> Ritardo max -> Frequenza max]")
        Call Scrivi("   Questa combinazione (" & UBound(aMiglioreComboDiOggi) & "ina) sarà l'unico bacino di numeri")
        Call Scrivi("   utilizzato per estrarre i Super Favoriti (Fase 3) e sviluppare i filtri di Fase 4.")
        Call Scrivi("==========================================================================================")
        Call Scrivi("")
     
    Else
        Call Scrivi("Nessuna combinazione ha soddisfatto i criteri per l'estrazione odierna.")
    End If
 
    ' ==================================================================
    ' --- FASE 3: SVILUPPO FILTRO DINAMICO ED ESTRAZIONE SUPER FAVORITI ---
    ' ==================================================================
    If bEseguiBacktest And bMiglioreTrovata And nTotalWNums > 0 Then
        Call Scrivi("==========================================================================================")
        Call Scrivi("  FASE 3: GENERAZIONE FILTRO DINAMICO E RIDUZIONE PER LA PROSSIMA GIOCATA",True)
        Call Scrivi("==========================================================================================")
        Call Scrivi("In base al profilo statistico emerso dal backtest, identifichiamo le fasce ideali.")
     
        sFasceFav = ""
        If(nFascia1 / nTotalWNums) >= 0.20 Then bFasciaFav(1) = True : sFasceFav = sFasceFav & "Fascia 1 (RA 0-9) | "
        If(nFascia2 / nTotalWNums) >= 0.20 Then bFasciaFav(2) = True : sFasceFav = sFasceFav & "Fascia 2 (RA 10-18) | "
        If(nFascia3 / nTotalWNums) >= 0.20 Then bFasciaFav(3) = True : sFasceFav = sFasceFav & "Fascia 3 (RA 19-36) | "
        If(nFascia4 / nTotalWNums) >= 0.20 Then bFasciaFav(4) = True : sFasceFav = sFasceFav & "Fascia 4 (RA > 36) | "
     
        anyFasciaActive = False
        For k = 1 To 4
            If bFasciaFav(k) Then anyFasciaActive = True
        Next
     
        If Not anyFasciaActive Then
            maxCount = 0
            maxFascia = 1
            If nFascia1 > maxCount Then maxCount = nFascia1 : maxFascia = 1
            If nFascia2 > maxCount Then maxCount = nFascia2 : maxFascia = 2
            If nFascia3 > maxCount Then maxCount = nFascia3 : maxFascia = 3
            If nFascia4 > maxCount Then maxCount = nFascia4 : maxFascia = 4
         
            bFasciaFav(maxFascia) = True
            If maxFascia = 1 Then sFasceFav = "Fascia 1 (RA 0-9) | "
            If maxFascia = 2 Then sFasceFav = "Fascia 2 (RA 10-18) | "
            If maxFascia = 3 Then sFasceFav = "Fascia 3 (RA 19-36) | "
            If maxFascia = 4 Then sFasceFav = "Fascia 4 (RA > 36) | "
        End If
     
        Call Scrivi("-> Filtro dinamico attivo su fasce vincenti (Incidenza >= 20%): " & Left(sFasceFav,Len(sFasceFav) - 3))
        Call Scrivi("-> Applicazione filtro sui " & UBound(aMiglioreComboDiOggi) & " numeri della migliore formazione di oggi (Rank 1)...")
        Call Scrivi("")
     
        nFavoritiCount = 0
        ReDim aFavoriti(90)
     
        For k = 1 To UBound(aMiglioreComboDiOggi)
            numCurrent = aMiglioreComboDiOggi(k)
            aNumSingle(1) = numCurrent
         
            RA_current = SerieRitardoTurbo(nInizio,nFine,aNumSingle,aRuote,1)
         
            If RA_current <= 9 Then
                fasciaCurrent = 1
            ElseIf RA_current <= 18 Then
                fasciaCurrent = 2
            ElseIf RA_current <= 36 Then
                fasciaCurrent = 3
            Else
                fasciaCurrent = 4
            End If
         
            If bFasciaFav(fasciaCurrent) Then
                nFavoritiCount = nFavoritiCount + 1
                aFavoriti(nFavoritiCount) = numCurrent
            End If
        Next
     
        ReDim Preserve aFavoriti(nFavoritiCount)
        Call OrdinaMatrice(aFavoriti,1)
     
        Call Scrivi("? LUNGHETTA SUPER FAVORITI FILTRATA DINAMICAMENTE ?",True)
        Call Scrivi(" -> Quantità originaria della combinazione: " & UBound(aMiglioreComboDiOggi) & " numeri")
        Call Scrivi(" -> Quantità rimasta dopo il filtro d'incidenza: " & nFavoritiCount & " numeri")
        Call Scrivi(" -> Percentuale di abbattimento della massa numerica: " & Round((1 -(nFavoritiCount / UBound(aMiglioreComboDiOggi))) * 100,1) & "%")
        Call Scrivi("")
        Call Scrivi(" -> Sotto-gruppo Consigliato (Giocabile per Ambo/Terno):",True)
        Call Scrivi(" " & StringaNumeri(aFavoriti,"."),True)
        Call Scrivi("==========================================================================================")
        Call Scrivi("")
    End If

    ' ==================================================================
    ' --- FASE 4: FILTRAZIONE SELETTIVA FINALE (DUAL FILTER SYSTEM) ---
    ' ==================================================================
    If bMiglioreTrovata Then
        Call Scrivi("==========================================================================================")
        Call Scrivi("  FASE 4: SVILUPPO MOTORE DI RIDUZIONE SELETTIVA FINALE",True)
        Call Scrivi("==========================================================================================")
     
        ' -----------------------------------------------------------
        ' OPZIONE 1: FILTRO DINAMICO DI MULTI-CONVERGENZA SU TERZINE
        ' -----------------------------------------------------------
        If nTipoFiltroFinale = 1 Then
            Call Scrivi("FILTRO ATTIVO: [1] MULTI-CONVERGENZA SULLE TERZINE (RA PER AMBO >= " & nMinRATerzina & ")")
            Call Scrivi("I singoli elementi vengono trattenuti solo se presenti in almeno " & nMinPresenze & " terzine iper-ritardate.")
            Call Scrivi("Sviluppo di tutte le terzine possibili della combinazione Rank 1...")
            Call Scrivi("")
         
            ReDim aTerzina(3)
            ReDim aUnionFreq(90)
            For k = 1 To 90
                aUnionFreq(k) = 0
            Next
         
            nCombTotaliTerz = 0
            For i1 = 1 To UBound(aMiglioreComboDiOggi) - 2
                For i2 = i1 + 1 To UBound(aMiglioreComboDiOggi) - 1
                    For i3 = i2 + 1 To UBound(aMiglioreComboDiOggi)
                        nCombTotaliTerz = nCombTotaliTerz + 1
                     
                        aTerzina(1) = aMiglioreComboDiOggi(i1)
                        aTerzina(2) = aMiglioreComboDiOggi(i2)
                        aTerzina(3) = aMiglioreComboDiOggi(i3)
                     
                        nRA_terz = SerieRitardoTurbo(nInizio,nFine,aTerzina,aRuote,2)
                     
                        If nRA_terz >= nMinRATerzina Then
                            aUnionFreq(aTerzina(1)) = aUnionFreq(aTerzina(1)) + 1
                            aUnionFreq(aTerzina(2)) = aUnionFreq(aTerzina(2)) + 1
                            aUnionFreq(aTerzina(3)) = aUnionFreq(aTerzina(3)) + 1
                        End If
                    Next
                Next
            Next
         
            nUnionCount = 0
            For k = 1 To 90
                If aUnionFreq(k) >= nMinPresenze Then
                    nUnionCount = nUnionCount + 1
                End If
            Next
         
            If nUnionCount > 0 Then
                ReDim aUnionNumeri(nUnionCount)
                c = 0
                For k = 1 To 90
                    If aUnionFreq(k) >= nMinPresenze Then
                        c = c + 1
                        aUnionNumeri(c) = k
                    End If
                Next
                Call OrdinaMatrice(aUnionNumeri,1)
             
                Call Scrivi("? GRUPPO FINALE PER MULTI-CONVERGENZA SU TERZINE ?",True)
                Call Scrivi(" -> Terzine totali sviluppate e testate: " & nCombTotaliTerz)
                Call Scrivi(" -> Soglia minima convergenza impostata: comparsa in >= " & nMinPresenze & " terzine iper-ritardate.")
                Call Scrivi(" -> Quantità elementi finali risultanti: " & nUnionCount & " numeri")
             
                If nUnionCount <= nMaxElementiUnione Then
                    Call Scrivi(" -> CONDIZIONE DI VALIDITA' (<= " & nMaxElementiUnione & " elementi): COPERTA! (PRONTA AL GIOCO)",True)
                Else
                    Call Scrivi(" -> CONDIZIONE DI VALIDITA' (<= " & nMaxElementiUnione & " elementi): SUPERATA (Troppi elementi: " & nUnionCount & " n.)")
                End If
                Call Scrivi("")
                Call Scrivi(" -> Sotto-gruppo Ristretto Consigliato (Giocabile per Ambo a Colpo):",True)
                Call Scrivi(" " & StringaNumeri(aUnionNumeri,"."),True)
            Else
                Call Scrivi("Nessun numero della migliore combinazione odierna partecipa ad almeno " & nMinPresenze & " terzine con RA >= " & nMinRATerzina & ".")
            End If
         
        ' -----------------------------------------------------------
        ' OPZIONE 2: RIDUZIONE SEQUENZIALE IN QUARTINE (DOPPIO LIVELLO DI RITARDO X7)
        ' -----------------------------------------------------------
        ElseIf nTipoFiltroFinale = 2 Then
            Call Scrivi("FILTRO ATTIVO: [2] RIDUZIONE SEQUENZIALE IN QUARTINE (DOPPIO LIVELLO X7)")
            Call Scrivi("Livello 1: Isola i numeri tramite unione di terzine iper-ritardate (RA >= " & nMinRATerzina & ")...")
         
            ReDim aTerzina(3)
            ReDim aUnionMap(90)
            nUnionCount = 0
            For k = 1 To 90
                aUnionMap(k) = False
            Next
         
            nCombTotaliTerz = 0
            For i1 = 1 To UBound(aMiglioreComboDiOggi) - 2
                For i2 = i1 + 1 To UBound(aMiglioreComboDiOggi) - 1
                    For i3 = i2 + 1 To UBound(aMiglioreComboDiOggi)
                        nCombTotaliTerz = nCombTotaliTerz + 1
                     
                        aTerzina(1) = aMiglioreComboDiOggi(i1)
                        aTerzina(2) = aMiglioreComboDiOggi(i2)
                        aTerzina(3) = aMiglioreComboDiOggi(i3)
                     
                        nRA_terz = SerieRitardoTurbo(nInizio,nFine,aTerzina,aRuote,2)
                     
                        If nRA_terz >= nMinRATerzina Then
                            If Not aUnionMap(aTerzina(1)) Then aUnionMap(aTerzina(1)) = True : nUnionCount = nUnionCount + 1
                            If Not aUnionMap(aTerzina(2)) Then aUnionMap(aTerzina(2)) = True : nUnionCount = nUnionCount + 1
                            If Not aUnionMap(aTerzina(3)) Then aUnionMap(aTerzina(3)) = True : nUnionCount = nUnionCount + 1
                        End If
                    Next
                Next
            Next
         
            If nUnionCount >= 4 Then
                ReDim aUnionNumeri(nUnionCount)
                c = 0
                For k = 1 To 90
                    If aUnionMap(k) Then
                        c = c + 1
                        aUnionNumeri(c) = k
                    End If
                Next
                Call OrdinaMatrice(aUnionNumeri,1)
             
                Call Scrivi(" -> Gruppo Intermedio Rilevato (Passaggio 1): " & nUnionCount & " numeri")
                Call Scrivi("    [" & StringaNumeri(aUnionNumeri,".") & "]")
                Call Scrivi("Livello 2: Sviluppo in quartine dei " & nUnionCount & " numeri intermedi...")
                Call Scrivi("Filtro di ritardo quartine abilitato su RA per Ambo >= " & nMinRAQuartina & " (Ciclo x7 per Quartina)...")
                Call Scrivi("")
             
                ReDim aQuartina(4)
                ReDim aQuartUnionMap(90)
                nQuartUnionCount = 0
                For k = 1 To 90
                    aQuartUnionMap(k) = False
                Next
             
                nCombTotaliQuart = 0
                For q1 = 1 To nUnionCount - 3
                    For q2 = q1 + 1 To nUnionCount - 2
                        For q3 = q2 + 1 To nUnionCount - 1
                            For q4 = q3 + 1 To nUnionCount
                                nCombTotaliQuart = nCombTotaliQuart + 1
                             
                                aQuartina(1) = aUnionNumeri(q1)
                                aQuartina(2) = aUnionNumeri(q2)
                                aQuartina(3) = aUnionNumeri(q3)
                                aQuartina(4) = aUnionNumeri(q4)
                             
                                nRA_quart = SerieRitardoTurbo(nInizio,nFine,aQuartina,aRuote,2)
                             
                                If nRA_quart >= nMinRAQuartina Then
                                    If Not aQuartUnionMap(aQuartina(1)) Then aQuartUnionMap(aQuartina(1)) = True : nQuartUnionCount = nQuartUnionCount + 1
                                    If Not aQuartUnionMap(aQuartina(2)) Then aQuartUnionMap(aQuartina(2)) = True : nQuartUnionCount = nQuartUnionCount + 1
                                    If Not aQuartUnionMap(aQuartina(3)) Then aQuartUnionMap(aQuartina(3)) = True : nQuartUnionCount = nQuartUnionCount + 1
                                    If Not aQuartUnionMap(aQuartina(4)) Then aQuartUnionMap(aQuartina(4)) = True : nQuartUnionCount = nQuartUnionCount + 1
                                End If
                            Next
                        Next
                    Next
                Next
             
                If nQuartUnionCount > 0 Then
                    ReDim aQuartUnionNumeri(nQuartUnionCount)
                    c = 0
                    For k = 1 To 90
                        If aQuartUnionMap(k) Then
                            c = c + 1
                            aQuartUnionNumeri(c) = k
                        End If
                    Next
                    Call OrdinaMatrice(aQuartUnionNumeri,1)
                 
                    Call Scrivi("? UNIONE SEQUENZIALE DELLE QUARTINE (RITARDO X7 SU CLASSE 4) ?",True)
                    Call Scrivi(" -> Quartine totali sviluppate dal gruppo intermedio: " & nCombTotaliQuart)
                    Call Scrivi(" -> Soglia minima ritardo per Ambo in Quartina: " & nMinRAQuartina & " estrazioni")
                    Call Scrivi(" -> Quantità elementi finali ristretti: " & nQuartUnionCount & " numeri")
                 
                    If nQuartUnionCount <= nMaxElementiUnione Then
                        Call Scrivi(" -> CONDIZIONE DI VALIDITA' (<= " & nMaxElementiUnione & " elementi): COPERTA! (PRONTA AL GIOCO)",True)
                    Else
                        Call Scrivi(" -> CONDIZIONE DI VALIDITA' (<= " & nMaxElementiUnione & " elementi): SUPERATA (Troppi elementi: " & nQuartUnionCount & " n.)")
                    End If
                    Call Scrivi("")
                    Call Scrivi(" -> Sotto-gruppo Ristretto Consigliato (Giocabile per Ambo a Colpo):",True)
                    Call Scrivi(" " & StringaNumeri(aQuartUnionNumeri,"."),True)
                Else
                    Call Scrivi("Nessuna quartina formata dai " & nUnionCount & " numeri intermedi ha un ritardo per Ambo >= " & nMinRAQuartina & ".")
                End If
             
            ElseIf nUnionCount > 0 Then
                ReDim aUnionNumeri(nUnionCount)
                c = 0
                For k = 1 To 90
                    If aUnionMap(k) Then
                        c = c + 1
                        aUnionNumeri(c) = k
                    End If
                Next
                Call OrdinaMatrice(aUnionNumeri,1)
             
                Call Scrivi(" -> Il gruppo intermedio generato dal primo livello ha solo " & nUnionCount & " numeri (minore di 4).")
                Call Scrivi(" -> Impossibile procedere con lo sviluppo in quartine. Viene restituito il gruppo senza il secondo filtro:")
                Call Scrivi(" " & StringaNumeri(aUnionNumeri,"."),True)
            Else
                Call Scrivi("Nessuna terzina della migliore 41ina di oggi ha un ritardo per Ambo >= " & nMinRATerzina)
            End If
        End If
        Call Scrivi("==========================================================================================")
        Call Scrivi("")
    End If

    ' Riepilogo finale
    Call Scrivi("--- ELABORAZIONE TERMINATA ---")
    Call Scrivi("Combinazioni totali testate per oggi: " & FormatNumber(i - 1,0))
    Call Scrivi("Combinazioni totali idonee oggi: " & FormatNumber(nTrovate,0))
End Sub

Sub Titolazione()
    Call Scrivi("==========================================================================================",True)
    Call Scrivi("  ANALIZZATORE DI COMBINAZIONI CASUALI CON ROLLING BACKTEST & FILTRO DINAMICO v2.3",True)
    Call Scrivi("==========================================================================================",True)
    Call Scrivi("")
End Sub

' Funzione matematica per calcolare le combinazioni teoriche senza ripetizione (Fissata con ByVal!)
Function CombinazioniSenzaRipetizione(ByVal n,ByVal k)
    Dim i,p
    p = 1
    If k > n Then
        CombinazioniSenzaRipetizione = 0
        Exit Function
    End If
    If k > n / 2 Then k = n - k
    For i = 1 To k
        p = p *(n - i + 1) / i
    Next
    CombinazioniSenzaRipetizione = p
End Function