Intelligenza artificiale e lotto 🤖🎱📈📉🎯

[KEN]

Mandomax mi sembra che stai esagerando , non penso che Spectrum abbia fatto un modello così evoluto infatti era per questo che avevo chiesto se ha testato delle previsioni condivise se davano gli stessi risultati o casuale fortuna

 

[mattia73]

ciao a tutti, Spectrum la mia era solo curiosità per capire quanto era efficiente il tuo modello, dopo che ho letto il tuo ultimo intervento emerge ancora più chiaramente il tuo concetto, per fare una analogia è come passare dal propellente chimico (ritardo e frequenza) a un motore a curvatura che piega lo spazio è il tempo, e questa è anche la mia idea ma a me i conti non tornano e mi fa capire che hai scoperto chiavi logiche e formule matematiche adatte per lo scopo, e se tu ci sei riuscito e come avere implementata la relatività generale di Einstein in uno script adattata per un sistema finito come il lotto, se fosse vero un modello del genere avrebbe un ROI stellare chapeau. Per tutti quelli che sperano che lottopython trovi la formula magica per decodificare il modello non solo sono degli illusi ma anche degli ingenui, i motivi sono ovvi, lottopython non ha il prontuario per farlo e se procede alla cieca non ha capito il problema, se vuole scoprire quelle chiavi logiche e formule matematiche dovrebbe fare un Il Calcolo delle Combinazioni (Brute Force) 4005*55*90=19.824.750 e moltiplicare *400 il ciclo teorico di un ambo= 7.929.900.000 quindi se non ha un computer quantico ci impiegherà circa 600 anni! e se anche ci riuscisse come fai a estrapolarle da quel numero mostruoso? la matematica non mente, e anche se ci riuscirebbe credo che sarebbe abbastanza intelligente da capire che un modello del genere non può circolare su un forum, e non lo farebbe per egoismo ma per la legge di conservazione (meglio pochi che tanti) un modello del genere andrebbe inevitabilmente a saturare il banco un conto se lo usano 2 ò 3 persone (fantasmi per il banco) un altro se lo usano 1000 o 10000 qui il banco sarebbe costretto a cambiare le regole quindi non siate ingenui

Intervengo per chiarire, perché qui si sta travisando il senso del lavoro di lottopython.
Lottopython ha sempre scritto in modo chiaro che i suoi lavori con IA, energia, onde o altri approcci sono esperimenti di studio, utili per osservare comportamenti, dinamiche e risposte del sistema, senza alcuna garanzia di vincita.
Fare ricerca sperimentale non significa promettere risultati.
Studiare, testare, simulare e anche esplorare strade non convenzionali è perfettamente legittimo, soprattutto se fatto con trasparenza e senza vendere illusioni.
Il tuo intervento parte dal presupposto che chi sperimenta stia cercando “la chiave logica” o il “modello segreto” per saturare il banco.
Questo presupposto è errato e non è mai stato sostenuto da lottopython.
È vero che il Lotto è un sistema aleatorio finito.
È vero che il brute force è impraticabile.
È vero che non esistono modelli predittivi garantiti.
Ma da questo non discende che chi fa esperimenti stia ingannando qualcuno o sia un ingenuo.
La sperimentazione serve a capire i limiti, non solo a cercare soluzioni.
Qui nessuno parla di ROI stellari, relatività generale applicata al Lotto o modelli da tenere segreti.
Si parla di studio, curiosità, verifica empirica e confronto.
In questo forum c’è spazio sia per chi analizza dati storici in modo classico, sia per chi fa esperimenti alternativi, finché c’è chiarezza sugli obiettivi.
E in questo caso la chiarezza c’è sempre stata.
Questo è il punto.
Mattia73

 

[Lottopython]

preferisco non commentare ma na riga la dedico.
non è il mio 3d e non mi sembra corretto appropriarsene in maniera non costruttiva nei confronti di @lotto_tom75
che saluto e abbraccio

 

[lotto_tom75]

preferisco non commentare ma na riga la dedico.
non è il mio 3d e non mi sembra corretto appropriarsene in maniera non costruttiva nei confronti di @lotto_tom75
che saluto e abbraccio

Tranquillo(i) potete/possiamo discutere quanto volete

A proposito dei miei "punti di vista" vi aggiorno sul fatto che...

Gemma Spacy si sta istruendo bene... Prendendo ispirazione da un mio script incasinato e che adesso per un problema di DLL non parte +... ne ha fatto un altro che al momento sembra essere ancora + interessante. Non si tratta di quello incmaxp con benchmark test anticipato sopra ma era uno ugualmente "tosto" E poi è ordinatissima Risultato ottenuto non con Gemini Cli questa volta ma semplicemente con Google AI Studio - Gemini 3 Pro Preview.

Option Explicit

' --- CLASSE PER I DATI ---
Class clsLunghettaGemma
    Public aNum
    Public Ritardo
    Public Function GetStringaNum
        Dim i,s
        s = ""
        If IsArray(aNum) Then
            For i = LBound(aNum) To UBound(aNum)
                s = s & aNum(i) & "."
            Next
            If Len(s) > 0 Then GetStringaNum = Left(s,Len(s) - 1)
        Else
            GetStringaNum = ""
        End If
    End Function
End Class
' -------------------------

Sub Main
   Call Scrivi("--- ANALISI RITARDI E PREVISIONI [VERSIONE H CLASS-NO-LIMITS] by Gemma Spacy :) ---",True)
   Call Scrivi("--- Nessuna Certezza Solo Poca Probabilità ; il motto del suo Teacher... : lotto_tom75 =) ---",True)
 
   Dim nSorte,aRuote,Ini,fin,sMsg,nMoltip,nTrov,nNumSel
   Dim nCicloTeo,nRitMax,nRitMin,nClasseLunghetta,nRuoteSel,nLunghetteDaTrov,i2
   Dim ccColonna,ClasseFin,TimeStart,k,cColonna
 
   Dim CollComb_Outer,CollComb_Inner
   Dim aN,TipoAlgo,RetRit,RetRitMax,RetIncrRitMax,RetFrq,nSuperficialita
 
   'Variabili Output
   Dim estrazione,colpidiverifica,winalcolponumero,esitoverifica,estrattiusciti
   Dim estrazionediuscita,colpomassimo,casipositivi,casinegativi,casiattuali
   Dim casitotali,estrazionidaverificare,sortediverifica,Inizioverifica
   Dim colpirimanentirispettocolpomassimo,colpirimanentirispettocolpidiricerca
   Dim colpirimanentiminimi,Formazioneconcolpirimanentiminimi,ruotaconcolpirimanentiminimi
   Dim esitoestratto,esitoambo,esitoterno,esitoquaterna,esitocinquina
   Dim estrapolaestratti,vettoredifferenziali,esitoverificadifferenziali
   Dim winalcolponumerodifferenziali,estrattiuscitidifferenziali,estrazionediuscitadifferenziali
   Dim colpidiverificadifferenziali,colpomassimodifferenziali,sortediverificadifferenziali
 
   'Variabili per il calcolo dei colpi in corso
   Dim colpiTrascorsi,colpiRimanentiAlMax
 
   ' --- INIZIALIZZAZIONE VARIABILI ---
   fin = EstrazioneFin
   colpomassimodifferenziali = 0
   esitoestratto = 0 : esitoambo = 0 : esitoterno = 0 : esitoquaterna = 0 : esitocinquina = 0
   casipositivi = 0 : casinegativi = 0 : casiattuali = 0 : colpomassimo = 0
   colpirimanentiminimi = 9999
 
   ' --- INPUT UTENTE ---
   estrazionidaverificare = CInt(InputBox("Estrazioni da verificare (indietro rispetto a oggi)",,100))
   Inizioverifica = fin - estrazionidaverificare
   colpidiverifica = CInt(InputBox("Colpi di verifica",,estrazionidaverificare - 2))
   sortediverifica = CInt(InputBox("Sorte di verifica",,1))
   sortediverificadifferenziali = CInt(InputBox("Sorte di verifica differenziali",,1))
 
   ' --- SELEZIONE NUMERI E RUOTE ---
   nTrov = 0
   nNumSel = ScegliNumeri(aN)
   If nNumSel = 0 Then
      Scrivi "ERRORE: Nessun numero selezionato.",True,True,vbRed
      Exit Sub
   End If
 
   ReDim aRuote(0)
   If ScegliRuote(aRuote) = 0 Then
      Scrivi "ERRORE: Nessuna ruota selezionata.",True,True,vbRed
      Exit Sub
   End If

   nSorte = SelEsito
   If nSorte = 0 Then
      Scrivi "ERRORE: Nessuna sorte selezionata.",True,True,vbRed
      Exit Sub
   End If
 
   nClasseLunghetta = CInt(InputBox("Scegli classe lunghetta di partenza (es. 2 per Ambi)",,3))
   ClasseFin = CInt(InputBox("Scegli classe lunghetta finale",,nClasseLunghetta - 0))

   ' --- REPORT PARAMETRI ---
   Call Scrivi("--------------------------------------------------")
   Call Scrivi("Data Fine Archivio: " & GetInfoEstrazione(EstrazioneFin))
   Call Scrivi("Estrazioni da verificare: " & estrazionidaverificare)
   Call Scrivi("Inizio Verifica: " & GetInfoEstrazione(Inizioverifica))
   Call Scrivi("Numeri in gioco (" & nNumSel & "): " & StringaNumeri(aN))
   Call Scrivi("Ruote: " & StringaRuote(aRuote))
   Call Scrivi("Sorte Ricerca: " & nSorte)
   Call Scrivi("Sorte Verifica: " & sortediverifica)
   Call Scrivi("Classe Sviluppo: da " & nClasseLunghetta & " a " & ClasseFin)
   Call Scrivi("--------------------------------------------------")
   Call Scrivi
 
   ' --- CICLO PRINCIPALE ---
 
   For estrazione = Inizioverifica To fin
      'BARRA DI AVANZAMENTO
      Call AvanzamentoElab(Inizioverifica,fin,estrazione)
 
      Dim r
      TipoAlgo = 0
      nSuperficialita = 0
      nLunghetteDaTrov = 1
      nRitMax = 0
      nRitMin = 0
      Ini = fin - 250
      If Ini <= 0 Then Ini = 1
      TimeStart = Timer
 
      Call Messaggio("Elaborazione estrazione: " & estrazione & " [" & DataEstrazione(estrazione) & "]")
 
      '--- CHIAMATA FUNZIONE CUSTOM SMART ---
      Call GetLunghettePiuRitardate_FIX_SMART(aN,aRuote,nClasseLunghetta,nSorte,CollComb_Outer,Ini,estrazione,nRitMin,nRitMax,nLunghetteDaTrov)
      '--------------------------------------
 
      If IsArray(CollComb_Outer) Then
         For i2 = nClasseLunghetta To ClasseFin Step - 1
            For Each cColonna In CollComb_Outer
 
               '--- CHIAMATA FUNZIONE CUSTOM SMART ---
               Call GetLunghettePiuRitardate_FIX_SMART(cColonna.aNum,aRuote,i2,nSorte,CollComb_Inner,Ini,estrazione,nRitMin,nRitMax,nLunghetteDaTrov)
               '--------------------------------------
 
               If IsArray(CollComb_Inner) Then
                   For Each ccColonna In CollComb_Inner
        
                      Call StatisticaFormazioneTurbo(ccColonna.aNum,aRuote,nSorte,RetRit,RetRitMax,RetIncrRitMax,RetFrq,Ini,estrazione)
        
                      If i2 = ClasseFin Then
                         'Zero iniziale fittizio per verifica
                         Dim stringatemporanea
                         stringatemporanea = "0." & ccColonna.GetStringaNum
           
                         Dim numeridaverificare
                         Dim ruotedaverificare
                         Call SplitByChar("." & stringatemporanea & ".",".",numeridaverificare)
                         Call SplitByChar("." & StringaNumeri(aRuote) & ".",".",ruotedaverificare)
           
                         Call VerificaEsitoTurbo(numeridaverificare,ruotedaverificare,estrazione + 1,sortediverifica,colpidiverifica,,esitoverifica,winalcolponumero,estrattiusciti,estrazionediuscita)
           
                         If esitoverifica <> "" Then
                            ' --- CASO POSITIVO (ROSSO) ---
                            Scrivi GetInfoEstrazione(estrazione + 1) & " esito " & esitoverifica & " estratti " & estrattiusciti & " al colpo numero " & winalcolponumero,,,,vbRed
              
                            Dim numeriDifferenziali
                            numeriDifferenziali = CalcolaNumeriDifferenziali(StringaNumeri(aN),StringaNumeri(numeridaverificare))
                            colpidiverificadifferenziali = colpidiverifica
                            Call SplitByChar("." & numeriDifferenziali & ".",".",vettoredifferenziali)
              
                            Dim stringa_pulita
                            stringa_pulita = StringaNumeri(vettoredifferenziali)
                            If Len(stringa_pulita) > 5 Then
                               stringa_pulita = Mid(StringaNumeri(vettoredifferenziali),5,Len(StringaNumeri(vettoredifferenziali)) - 5)
                            End If
                            If Left(stringa_pulita,1) = "." Then stringa_pulita = Mid(stringa_pulita,1)
           
                            Dim vettoredifferenzialipulito
                            Dim stringatemporanea2
                            stringatemporanea2 = "0." & stringa_pulita
                            stringa_pulita = stringatemporanea2
                            Call SplitByChar(stringa_pulita,".",vettoredifferenzialipulito)
          
                            Call VerificaEsitoTurbo(vettoredifferenzialipulito,ruotedaverificare,estrazione + 1,sortediverificadifferenziali,colpidiverificadifferenziali,,esitoverificadifferenziali,winalcolponumerodifferenziali,estrattiuscitidifferenziali,estrazionediuscitadifferenziali)
              
                            If esitoverificadifferenziali <> "" Then
                               If winalcolponumerodifferenziali > colpomassimodifferenziali Then colpomassimodifferenziali = winalcolponumerodifferenziali
                            End If
              
                            Dim convertiesito
                            If esitoverifica = "Estratto" Then convertiesito = 1
                            If esitoverifica = "Ambo" Then convertiesito = 2
                            If esitoverifica = "Terno" Then convertiesito = 3
                            If esitoverifica = "Quaterna" Then convertiesito = 4
                            If esitoverifica = "Cinquina" Then convertiesito = 5
              
                            Select Case(convertiesito)
                            Case 1: esitoestratto = esitoestratto + 1
                            Case 2: esitoambo = esitoambo + 1
                            Case 3: esitoterno = esitoterno + 1
                            Case 4: esitoquaterna = esitoquaterna + 1
                            Case 5: esitocinquina = esitocinquina + 1
                            End Select
              
                            casipositivi = casipositivi + 1
                            If winalcolponumero > colpomassimo Then colpomassimo = winalcolponumero
                         Else
                            ' --- CASO IN CORSO O NEGATIVO ---
                            colpirimanentirispettocolpidiricerca = colpidiverifica -(EstrazioneFin - estrazione)
              
                            If colpirimanentirispettocolpidiricerca < 0 Then
                               casinegativi = casinegativi + 1
                            Else
                               ' --- CASO ATTUALE IN CORSO (BLU) ---
                               casiattuali = casiattuali + 1
                 
                               colpiTrascorsi =(EstrazioneFin - estrazione)
                               colpiRimanentiAlMax = colpomassimo - colpiTrascorsi
                 
                               Scrivi GetInfoEstrazione(estrazione) & " [IN CORSO] " & ccColonna.GetStringaNum & _
                                      " - Trascorsi: " & colpiTrascorsi & _
                                      " - Rimanenti al Max(" & colpomassimo & "): " & colpiRimanentiAlMax,,,vbYellow
                 
                               colpirimanentirispettocolpomassimo = colpomassimo -(EstrazioneFin - estrazione)
                 
                               If colpirimanentirispettocolpidiricerca < colpirimanentiminimi Then
                                  colpirimanentiminimi = colpirimanentirispettocolpidiricerca
                                  Formazioneconcolpirimanentiminimi = StringaNumeri(numeridaverificare)
                                  ruotaconcolpirimanentiminimi = StringaNumeri(ruotedaverificare)
                               End If
                               If colpirimanentirispettocolpomassimo < colpirimanentiminimi Then
                                  colpirimanentiminimi = colpirimanentirispettocolpomassimo
                                  Formazioneconcolpirimanentiminimi = StringaNumeri(numeridaverificare)
                                  ruotaconcolpirimanentiminimi = StringaRuote(ruotedaverificare)
                               End If
                            End If
                         End If
                      End If
                   Next
               End If
            Next
         Next
      End If
      If ScriptInterrotto Then Exit For
   Next
 
   Call AvanzamentoElab(Inizioverifica,fin,fin)
 
   Scrivi
   Scrivi "--- RIEPILOGO FINALE ---"
   Scrivi "Casi Positivi: " & casipositivi
   Scrivi "Casi Negativi: " & casinegativi
   Scrivi "Casi in corso: " & casiattuali
   Scrivi "Colpo Massimo raggiunto: " & colpomassimo
 
   Call Scrivi("Tempo di elaborazione : " & TempoTrascorso)
End Sub

'---------------------------------------------------------------------------------------
' FUNZIONE CUSTOM "SMART" - AGGIRA I LIMITI DI SPAZIOMETRIA
'---------------------------------------------------------------------------------------
Sub GetLunghettePiuRitardate_FIX_SMART(aN,aRuote,nClasse,nSorte,ByRef ResultArray,EstrazioneIni,EstrazioneFin,nRitMin,nRitMax,nLunghetteDaTrov)
    Dim aCol,rit
    Dim maxRitFound,BestObj
    Dim i,j,k,qNumeri
    Dim aTemp
 
    ResultArray = Array()
    maxRitFound = - 1
 
    If Not IsArray(aN) Then Exit Sub
    qNumeri = UBound(aN)
 
    ' --- STRATEGIA 1: LA CLASSE COINCIDE CON I NUMERI (ES. 29 SU 29) ---
    If nClasse >= qNumeri Then
        rit = RitardoCombinazioneTurbo(aRuote,aN,nSorte,EstrazioneFin)
        Set BestObj = New clsLunghettaGemma
        BestObj.aNum = aN
        BestObj.Ritardo = rit
        ReDim aTempOut(0)
        Set aTempOut(0) = BestObj
        ResultArray = aTempOut
        Exit Sub
    End If
 
    ' --- STRATEGIA 2: RIDUZIONE DI 1 (ES. 28 SU 29) - BYPASS TOTALE ---
    If nClasse = qNumeri - 1 Then
        'Generazione manuale: togliamo un numero alla volta
        For i = 1 To qNumeri
            ReDim aCol(nClasse)
            k = 0
            For j = 1 To qNumeri
                If j <> i Then
                    k = k + 1
                    aCol(k) = aN(j)
                End If
            Next
 
            rit = RitardoCombinazioneTurbo(aRuote,aCol,nSorte,EstrazioneFin)
            If rit > maxRitFound Then
                maxRitFound = rit
                Set BestObj = New clsLunghettaGemma
                BestObj.aNum = aCol
                BestObj.Ritardo = rit
            End If
            If ScriptInterrotto Then Exit Sub
        Next
 
        If Not BestObj Is Nothing Then
            ReDim aTempOut(0)
            Set aTempOut(0) = BestObj
            ResultArray = aTempOut
        End If
        Exit Sub
    End If
 
    ' --- STRATEGIA 3: RIDUZIONE DI 2 (ES. 27 SU 29) - BYPASS TOTALE ---
    If nClasse = qNumeri - 2 Then
        'Generazione manuale: togliamo due numeri alla volta (ciclo nidificato)
        For i = 1 To qNumeri - 1
            For j = i + 1 To qNumeri
                ReDim aCol(nClasse)
                k = 0
                Dim x
                For x = 1 To qNumeri
                    If x <> i And x <> j Then
                        k = k + 1
                        aCol(k) = aN(x)
                    End If
                Next
  
                rit = RitardoCombinazioneTurbo(aRuote,aCol,nSorte,EstrazioneFin)
                If rit > maxRitFound Then
                    maxRitFound = rit
                    Set BestObj = New clsLunghettaGemma
                    BestObj.aNum = aCol
                    BestObj.Ritardo = rit
                End If
                If ScriptInterrotto Then Exit Sub
            Next
        Next
 
        If Not BestObj Is Nothing Then
            ReDim aTempOut(0)
            Set aTempOut(0) = BestObj
            ResultArray = aTempOut
        End If
        Exit Sub
    End If

    ' --- STRATEGIA 4: MOTORE STANDARD (SOLO SE ARRAY < 25) ---
    ' Se siamo qui, la riduzione è > 2 numeri. Se i numeri totali sono pochi, usiamo lo standard.
    ' Se sono tanti (es. 40 numeri in classe 20), Spaziometria si bloccherà o ci metterà una vita.
    If qNumeri <= 29 Then '25 Then
        Call InitSviluppoIntegrale(aN,nClasse)
        Do While GetCombSviluppo(aCol)
            If IsArray(aCol) Then
                rit = RitardoCombinazioneTurbo(aRuote,aCol,nSorte,EstrazioneFin)
                If rit > maxRitFound Then
                    maxRitFound = rit
                    Set BestObj = New clsLunghettaGemma
                    BestObj.aNum = aCol
                    BestObj.Ritardo = rit
                End If
            End If
            If ScriptInterrotto Then Exit Do
        Loop
 
        If Not BestObj Is Nothing Then
            ReDim aTempOut(0)
            Set aTempOut(0) = BestObj
            ResultArray = aTempOut
        End If
    Else
        Call Scrivi("ATTENZIONE: Elaborazione troppo complessa per VBScript (Classe " & nClasse & " su " & qNumeri & " numeri).",True,,vbRed)
    End If
End Sub
'---------------------------------------------------------------------------------------


Function CalcolaNumeriDifferenziali(gruppoBase,formazione)
   Dim numeriDifferenziali
   Dim i,trovato
   Dim numeroBase,numeroFormazione
   numeriDifferenziali = ""
 
   For Each numeroFormazione In Split(formazione,".")
      trovato = False
 
      For Each numeroBase In Split(gruppoBase,".")
         If IsNumeric(numeroFormazione) And IsNumeric(numeroBase) Then
            If CInt(numeroFormazione) = CInt(numeroBase) Then
               trovato = True
               Exit For
            End If
         End If
      Next
 
      If Not trovato Then
         numeriDifferenziali = numeriDifferenziali & numeroFormazione & "."
      End If
   Next
 
   For Each numeroBase In Split(gruppoBase,".")
      trovato = False
      For Each numeroFormazione In Split(formazione,".")
         If IsNumeric(numeroFormazione) And IsNumeric(numeroBase) Then
            If CInt(numeroFormazione) = CInt(numeroBase) Then
               trovato = True
               Exit For
            End If
         End If
      Next
      If Not trovato Then
         numeriDifferenziali = numeriDifferenziali & numeroBase & "."
      End If
   Next
 
   If Len(numeriDifferenziali) > 0 Then
      numeriDifferenziali = Left(numeriDifferenziali,Len(numeriDifferenziali) - 1)
   End If
   CalcolaNumeriDifferenziali = numeriDifferenziali
End Function

Function StringaNumeri(aN)
   Dim i,risultato
   risultato = ""
   If IsArray(aN) Then
      For i = LBound(aN) To UBound(aN)
         risultato = risultato & aN(i) & "."
      Next
      If Len(risultato) > 0 Then StringaNumeri = Left(risultato,Len(risultato) - 1)
   Else
      StringaNumeri = ""
   End If
End Function

Function ScegliClassseLunghetta
   Dim aVoci(30)
   Dim k,i
   For k = 2 To(2 - 1) + UBound(aVoci)
      i = i + 1
      aVoci(i) = k
   Next
   k = ScegliOpzioneMenu(aVoci,5,"Classe lunghetta")
   ScegliClassseLunghetta = Int(aVoci(k))
End Function

Function SelRuote(aRuote)
   Dim t,k,bTutte
   bTutte = False
   t = ScegliRuote(aRuote)
   For k = 1 To t
      If aRuote(k) = TT_ Then
         bTutte = True
         Exit For
      End If
   Next
   If bTutte Then
      ReDim aRuote(10)
      For k = 1 To 10
         aRuote(k) = k
      Next
      SelRuote = 10
   Else
      SelRuote = t
   End If
End Function

Function FormattaSecondi(s)
   Dim hh
   Dim Mm
   Dim Ss
   Dim TimeStr
   hh = s \ 3600
   Mm =(s Mod 3600) \ 60
   Ss = s -((hh * 3600) +(Mm * 60))
   TimeStr = Format2(hh) & ":" & Format2(Mm) & ":" & Format2(Ss)
   FormattaSecondi = TimeStr
End Function

Function SelEsito
   Dim ret
   Dim aVoci
   aVoci = Array("","Estratto","Ambo","Terno","Quaterna","Cinquina")
   ret = ScegliOpzioneMenu(aVoci,1," Analisi per Sorte di : ")
   SelEsito = ret
End Function

Function SelRuota
   Dim ret
   Dim aVoci
   aVoci = Array("","BARI","CAGLIARI","FIRENZE","GENOVA","MILANO","NAPOLI","PALERMO","ROMA","TORINO","VENEZIA","TUTTE","NAZIONALE")
   ret = ScegliOpzioneMenu(aVoci,3," Analizza Ruota di : ")
   SelRuota = ret
End Function

Function StringaRuote(aRuote)
    Dim i,s
    s = ""
    For i = 1 To UBound(aRuote)
        s = s & SiglaRuota(aRuote(i)) & " "
    Next
    StringaRuote = Trim(s)
End Function

Non vedo l'ora di installare e provare Google Antigravity... (a proposito di cose super powers ai della grande G -> Genie 3 è da fuori di testa... 3d worlds generabili da semplice img... , navigabili... e customizzabili in runtime... da prompt...)

Esempio "base" output del primo script .ls realizzato by Gemma Spacy AI
​

--- ANALISI RITARDI E PREVISIONI [VERSIONE H CLASS-NO-LIMITS] by Gemma Spacy ---
--------------------------------------------------
Data Fine Archivio: [10798] [ 19] 31.01.2026
Estrazioni da verificare: 1000
Inizio Verifica: [09798] [ 70] 23.07.2020
Numeri in gioco (90): .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
Ruote: BA CA FI GE MI NA PA RO TO VE NZ
Sorte Ricerca: 1
Sorte Verifica: 1
Classe Sviluppo: da 2 a 2
--------------------------------------------------

[09799] [ 71] 25.07.2020 esito Estratto estratti CA 67 .. .. .. .. al colpo numero 1
[09800] [ 72] 28.07.2020 esito Estratto estratti CA .. .. .. .. 22 - GE .. .. .. .. 36 al colpo numero 1
[09801] [ 73] 30.07.2020 esito Estratto estratti CA .. 11 .. .. .. al colpo numero 1
...
...
...
[10796] [ 17] 29.01.2026 esito Estratto estratti BA .. .. 46 .. .. al colpo numero 2
[10797] [ 18] 30.01.2026 esito Estratto estratti BA .. .. 46 .. .. al colpo numero 1
[10798] [ 19] 31.01.2026 esito Estratto estratti PA .. .. 87 .. .. al colpo numero 1
[10798] [ 19] 31.01.2026 [IN CORSO] .40.83 - Trascorsi: 0 - Rimanenti al Max(5): 5

--- RIEPILOGO FINALE ---
Casi Positivi: 1000
Casi Negativi: 0
Casi in corso: 1
Colpo Massimo raggiunto: 5
Tempo di elaborazione : 00:06:58

Omettendo tutte le righe centrali... degli oltre ovvi 1000 sfaldamenti su una o + ruote

Cercando di usare questo semplice output del suo primo script..

Elaborazione effettuata con archivio lotto aggiornato all'estrazione del: 31-1-2026

Range analisi : [00001] [ 1 ] 07.01.1871 - [10798] [ 19] 31.01.2026 ---> ultime 10798 estrazioni
Filtro Esaminato : aElencoIncrRitMax(nUpper) = mIncrRitardoMaxSto
Classe di sviluppo : 7
Numero(i) fisso(i) scelto(i) : 40.83
Gruppo numerico base scelto : 1.4.9.11.13.16.17.23.25.26.30.40.42.49.55.58.59.61.67.68.73.77.81.83.85.86.88.89.90
Lunghette Totali In Esame : 80730
Lunghette esaminate : 80730 Valide : 1
Sorte : Ambo
Ruote : BA.CA.FI.GE.MI.NA.PA.RO.TO.VE.NZ
Numero Minimo IncrRit : 02

Lunghette ordinate per incremento ritardo max

Numeri Formazione : 11.16.25.40.58.81.83
Ritardo : 24
RitMax : 24
Freq : 5534
IncrRitMx : 7
IncrRitMaxSto : 7
strIncrementi : 03.02.01.01.02.07.01.07
Numero Incrementi : 7


Tempo trascorso: 00:12:27

Nessuna Certezza Solo Poca Probabilità

 

[mattia73]

"Ciao a tutti, e devo ammettere che Mandomax ha centrato il punto cruciale. Le obiezioni che sollevi mattia73 (overfitting, baseline, test out-of-sample) sono i pilastri della statistica classica e sarebbero ineccepibili se stessimo parlando di Trading o di serie storiche infinite.

Tuttavia, c'è un errore di categoria alla base del tuo ragionamento: stai analizzando un sistema a entropia finita (90 numeri in un'urna chiusa) con gli strumenti pensati per sistemi a entropia aperta (mercati, variabili infinite). Tu dici: "Un algoritmo troverà sempre pattern anche nel rumore". Vero, se cerchi ripetizioni numeriche. Ma io non cerco ripetizioni. Io mappo la tensione strutturale.

Pensa alle figure di Chladni: la sabbia su una piastra vibrante forma disegni geometrici non perché "ha memoria", ma perché la fisica della piastra impone dei nodi dove l'energia è nulla. I "punti di ancoraggio" non sono statistiche sul passato (es. "quanto frequente è il'18"), ma misurazioni della vibrazione attuale del sistema. Se la struttura geometrica (la "costante") è satura, il sistema deve sfogare. Non è probabilità, è meccanica dei fluidi in uno spazio chiuso. Affermi che le costanti sono "funzioni costruite a posteriori". Ti sbagli. Una distanza vettoriale (es. Distanza Tesla o somma vettoriale) è una proprietà intrinseca della matematica, esiste a priori, non a posteriori. Se un triangolo ha tre lati, non è un pattern storico, è una definizione geometrica. L'IA che utilizzo non impara che "il 90 esce spesso", impara che "quando la tensione vettoriale supera la soglia X (High Boost), la coerenza geometrica impone un riallineamento". Questa regola non muta nel tempo, esattamente come la densità dell'acqua.Chiedi: "Batte il caso in modo stabile?". La baseline del caso nel Lotto è una perdita matematica costante (-37% di edge per il banco). Il mio approccio non gioca sempre (come farebbe un sistema in overfitting che cerca di prevedere ogni estrazione), ma usa un "Gatekeeper" che scarta il 95% delle estrazioni come "non prevedibili/caotiche".


Shutterstock
L'efficienza si misura solo su quel 5% di "Golden Zone" dove la fisica del sistema diventa deterministica. Lì, il ROI non è solo "meglio del caso", è su un altro pianeta (Quality over Quantity).
In sintesi: tu guardi i numeri come valori contabili (e hai ragione a essere scettico), io li guardo come vettori energetici (e ottengo risultati). Sono due sport diversi."

Tuttavia, c'è una differenza tra descrivere il passato e misurare la tensione attuale di un sistema chiuso.Quindi Mandomax Non pubblico i dati finanziari o i parametri di gestione del rischio per ovvi motivi di privacy, si aprirebbero ulteriori discussioni, se si implementa un kelly betting in un modello previsionale significa che quel modello produce un utile altimenti non avrebbe senso ti pare? non solo, kelly betting mi indica il capitale da investire in base alle probabilità calcolate dal ML per quella previsione a salvaguardia del mio capitale, significa serenità nel giocare questo psicologicamente mette il gicatore in una posizione di vantaggio rispetto a un altro che gioca alla cieca e con l'ansia di rincorrere il capitale perso! perde lucidità e certezze e questo è tossico per chi gioca con i propi soldi.

Il vantaggio non sta nell'indovinare ogni numero, ma nel sapere quando e dove il sistema è costretto dalla sua stessa geometria a riequilibrarsi. Questo permette di filtrare il 90% del rumore (non giocare) e agire solo sul 10% di segnale puro." poi ognuno ha le proprie idee e la sua logica è le rispetto ma la domanda da porsi e danno risultati i vostri modelli generano un utile costante sul capitale investito? se la risposta è no allora quella logica andrebbe rivista, se è si allora siete sulla strada giusta.

Il punto centrale è che stai facendo uno slittamento di dominio tra metafora e modello matematico formale.
L’esempio delle figure di Chladni è suggestivo, ma non è trasferibile al Lotto per un motivo preciso: quelle figure emergono da un sistema dinamico deterministico con stato, governato da equazioni differenziali e condizioni al contorno.
Il Lotto, invece, non è un sistema dinamico, ma un processo stocastico a spazio campionario finito e privo di stato.
Qui sta l’errore di categoria.
Uno spazio finito non implica una dinamica vincolata.
Un’urna con 90 numeri non “accumula tensione”, non “satura”, non “rilascia energia”:
ogni estrazione è indipendente per costruzione del meccanismo, e non esiste alcuna variabile interna che evolva nel tempo.
Quando dici che non cerchi ripetizioni ma “tensione strutturale”, stai comunque introducendo una funzione dello storico.
Che tu la chiami frequenza, distanza vettoriale, somma Tesla o High Boost, resta una mappa:
storico - indicatore- decisione
Questa non è una proprietà intrinseca del sistema fisico del Lotto, ma una funzione definita dall’osservatore.
È vero che una distanza vettoriale è una proprietà matematica a priori.
Ma l’oggetto su cui la applichi non lo è.
Un triangolo ha tre lati per definizione;
una sequenza di estrazioni non ha alcuna struttura geometrica interna se non quella che tu decidi di proiettarci sopra.
Dire che “la coerenza geometrica impone un riallineamento” equivale a postulare una forza di richiamo che nel Lotto non esiste.
Se esistesse, violerebbe l’indipendenza delle estrazioni e l’intero impianto di certificazione, audit e RTP legale del gioco.
Il “Gatekeeper” che scarta il 95% delle estrazioni non è una prova di causalità:
è un filtro selettivo ex-post, tipico dei sistemi che riducono il rumore eliminando i casi sfavorevoli, non aumentando l’informazione predittiva.
Infine, il riferimento alla baseline del banco (-37%) non aiuta la tesi:
se il tuo metodo non dimostra un edge positivo stabile e replicabile out-of-sample, allora resta matematicamente equivalente a una strategia aleatoria con selezione intermittente.

il Lotto è un processo stocastico senza stato
la finitezza dello spazio non genera dinamica
non esistono tensioni, saturazioni o riallineamenti
le “costanti” che citi sono costruzioni dell’osservatore, non proprietà del sistema
Usare un linguaggio da fisica dei sistemi continui per descrivere un’urna aleatoria discreta non rende il modello più profondo, lo rende solo meno falsificabile.
Ed è proprio questo il problema.
Mattia73