Just Some Notes to Remember on New Computational and Reductional Developments

olegna · 27 Maggio 2026

lotto_tom75 ha scritto:
Mi appunto e condivido : forse un'altra ottima matrice per adesso per analisi incmaxp x s2, s3 in c11 da 2 a 5p o meglio da 3 a 5p su 3r by 1871 su 7s by 1871 è la 1190-c11-gdp5-by-newabsc33 xs2 su 7s by 1871 perchè unica ad avere per grado di presenza massima essenziale (gdp5) il numero di classe 11 pari all'unico numero, oltre al 3 per dividere per interi la base c33. Es. di risultanze di questo tipo : 04.09.23.42.49.73.81.83.88.89.90 r: FI.RO.TO p: 1.2.3.4.5 rap=rsp 180 num. inc 12 incmax att=sto 28 fqp 475 s 3; Lo schema in esame in questa ricerca statistico riduzionale predittiva avrebbe appunto come cardini strutturali 3, 11, 7 , e 1190 (170x7). Quando però interessa meno di 5p mi devo ricordare, come nell'altro caso, di non mischiare mele con pere e valutare i ritardi posizionali sulle max 4p specifiche rispetto alle 5p standard. Inoltre meglio forse quando il valore del numero di incmax è contenutissimo rispetto a quando non lo è in quanto denota una stabilità maggiore rispetto a comportamenti più baldanzosi dell'altro tipo. Un'altra curiosità emersa in altre analisi su colab è che la classe con il minimo di edge di copertura teorica massima per matrici discendenti da questo tipo di classe base abs (absc76 ecc...) è stato finora sempre 11. A c10 si perdeva il benchè minimo segnale... anche impostando un minima soglia a 0,01. Nessuna Certezza Solo Poca Probabilità

olegna · 27 Maggio 2026

Lotto tom cosa giocare

lotto_tom75 · 27 Maggio 2026

olegna ha scritto:
Lotto tom cosa giocare

all'interno della classe c11 (di per sè nella sua interezza not playable..) da ulteriore ricerca incmaxp da 2 a 5p unite si evidenza questa unica compressione posizionale per s2 by 1871 sulle 3r unite potenzialmente interessante:

09.23.49.73.83 r: FI.RO.TO p: I.V rap=rsp 570 num. inc 7 incmax att=sto 32 fqp 83 s 2.

Nessuna Certezza Solo Poca Probabilità

olegna · 27 Maggio 2026

Grazie lotto tom

olegna · 28 Maggio 2026

83. 49 peccato x il 73 che si è girato Roma secco si continua?

lotto_tom75 · 28 Maggio 2026

Ambo a colpo 49-83 in posizione (I e V). Non male direi

(chiusa)

lotto_tom75 · 28 Maggio 2026

Sempre da stessa c11 ancora compressa per s3 analizzando da c6 a c7 xs2 e da 2 a 5p unite by 1871 adesso risulterebbe sempre sulle stesse tre ruote FIROTO questa unica risultanza in c6 xs2 su 3p: 04.09.42.49.73.89 r: FI.RO.TO p: I.II.IV rap=rsp 180 num. inc 6 incmax att=sto 28 fqp 373 s 2. Nessunissima Certezza Solo Poca Probabilità

olegna · 29 Maggio 2026

Il 49 rimane e si cambia il primo e l' ultimo grazie

lotto_tom75 · 25 Giugno 2026

Nuovo sviluppo forse interessante x esito a colpo

Continua...

NA 13.85 a colpo by seguente workflow riduzionale...

analisi by 1871 by matrice 1360 c16 gdp 8 by absc29 su 11r unite con filtro diff0 incmax0

x s2 -> nada
x s3 -> nada
x s4 -> 1 risultanza -> sfaldata a colpo in s2 su TT (NA).

la coppia si è mantenuta in:

guc14 tra la c4 a a fq max unica x s2 su 11r_u by 1871 e le c4 con i primi ra unici minori x s2 su 11r_u by 1871

sviluppando il guc14 in c7 xs2 su 11r_u by 1871 la coppia si è conservata nel guc9 (della prev. si test sopra riportata)

NA come ruota di sfaldamento sarebbe stata invece l'unica insieme a PA ad avere fq x s4 0 by 1871 in quel guc9.

Analizzando infine per incmaxp x s2 da 2 a 5p unite su NAPANZ (nz aggiunta per fq max xs4 nel guc9 di cui sopra...) da 1 a 3 r unite by 1871 la coppia si sarebbe trovata nella risultanza c4 incmaxp doc su 3p unite e su 2r unite (NAPA).

Infine sviluppando il guc9 in c5 xs2 su NAPA by 1871 la coppia uscente si sarebbe trovata sia nella c5 con fq max unica che in quella con 2° fq max unica.

olegna · 25 Giugno 2026

Si gioca ancora questi numeri? Grazie

lotto_tom75 · 25 Giugno 2026

olegna ha scritto:
Si gioca ancora questi numeri? Grazie

No. In teoria questi sono già "scarichi..." ma non è detto... Infatti dal prox sviluppo analogo potrebbero ritornare anche in parte o del tutto gli stessi...

lotto_tom75 · Oggi alle 10:42

new reductional predictive workflow perhaps very interesting...

1) Jarvis wheel target (es. absc29 su VE)
2) fix numbers c29 + random in cx (es. c8) x N numeri formazioni volute su colab o script doc da fare.. py o .ls
3) filtraggio automatico per diff (rs-ra) voluta per sorte desiderata (es. 2) -> es. output c37 x s2 con diff2 by 1871
4) riduzione ulteriore (es. c3 x s2 con scelta e unione prime terzine con ra max unico (es. ra >= 900) su ruota target
5) riduzione e filtraggio e cesellatura.. del gucZ ottenuto al punto 4.

La novità + interessante di questo nuovo tipo di sviluppo è rappresentata dalla massima velocità operativa, dall'automatismo di rilevamento unica ruota (by jarvis), dalla costituzione della formazione dinamica finale di base per il 90% da una abs e dal tempo di attesa teorico ridotto a 1 oltre che dal considerare seppur in minima parte e in modo randomico tutti i 90 elementi.
es. di guc del punto 4 : guc18 : 7-9-13-15-16-18-25-30-31-40-42-49-58-68-73-85-88-90 x VE x s2 in 1(+1) shots.

Nessuna Certezza Solo Poca Probabilità

rubino2 · Oggi alle 11:30

ciao LottoTom, per curiosità , io lavoro con javascript, html, volevo vedere se era possibile trasformare il prototipo del tuo phyton in java e vedere realmente il tempo di elaborazione e di fattibilità con difficoltà al seguito, se ne fossero, per il java, mi potresti postare in txt o altro altro modo cosa fa il tuo script?

poi un'altra domanda hai ottenuto una lunga 7-9-13-15-16-18-25-30-31-40-42-49-58-68-73-85-88-90 x VE x s2 in 1(+1) shots. che on capisco perchè jarvis wells di solito non contempla o scarta i consecutivi, perchè sono presenti nella guc18 in questo punto 15 e 16 e 30 e 31?

il lavoro finale come tuo obbiettivo sarebbe una sestina o minore cinquina fino ad un piccolo gruppetto di terzine?

olegna · Oggi alle 11:51

Ciao lotto Tom come si fa a giocare 18 numeri

lotto_tom75 · Oggi alle 12:10

rubino2 ha scritto:
ciao LottoTom, per curiosità , io lavoro con javascript, html, volevo vedere se era possibile trasformare il prototipo del tuo phyton in java e vedere realmente il tempo di elaborazione e di fattibilità con difficoltà al seguito, se ne fossero, per il java, mi potresti postare in txt o altro altro modo cosa fa il tuo script?

poi un'altra domanda hai ottenuto una lunga 7-9-13-15-16-18-25-30-31-40-42-49-58-68-73-85-88-90 x VE x s2 in 1(+1) shots. che on capisco perchè jarvis wells di solito non contempla o scarta i consecutivi, perchè sono presenti nella guc18 in questo punto 15 e 16 e 30 e 31?

il lavoro finale come tuo obbiettivo sarebbe una sestina o minore cinquina fino ad un piccolo gruppetto di terzine?

script

Codice:

# ============================================================================
# LOTTO RANDOM COMBINATION GENERATOR & FILTER by tom e Qwen AI :)
# Genera combinazioni ibride fisse (90%) + random (10%) e filtra per condizioni teoricamente ottimali
# ============================================================================
import requests
import numpy as np
from typing import List, Dict, Tuple
import time
from tqdm import tqdm
import random
class RandomCombinationAnalyzer:
    def __init__(self, archive_url: str):
        self.archive_url = archive_url
        self.draws_array = self._load_archive()
    def _load_archive(self) -> np.ndarray:
        print(f"📥 Download archivio da: {self.archive_url}")
        response = requests.get(self.archive_url, timeout=120)
        response.raise_for_status()
        lines = response.text.strip().split('\n')
        data = []
        for line in lines:
            parts = line.split('.')
            if len(parts) == 5:
                nums = [int(p) for p in parts if p.strip()]
                if len(nums) == 5:
                    data.append(nums)
        draws_array = np.array(data, dtype=np.int16)
        print(f"✅ Caricate {len(draws_array)} estrazioni")
        return draws_array
    def _calculate_metrics(
        self,
        numbers: np.ndarray,
        min_hits: int = 2
    ) -> Tuple[int, int, int]:
        """
        Calcola le metriche per un set di numeri
        Returns:
            (total_hits, current_delay, max_historical_delay)
        """
        # Trova tutte le estrazioni con almeno min_hits numeri
        hits_matrix = np.isin(self.draws_array, numbers)
        hits_per_draw = hits_matrix.sum(axis=1)
        hit_indices = np.where(hits_per_draw >= min_hits)[0]
        if len(hit_indices) == 0:
            return 0, 999999, 999999
        total_hits = len(hit_indices)
        # Le estrazioni recenti sono in alto (indice 0)
        # hit_indices[0] è l'ESTRAZIONE PIÙ RECENTE che ha fatto ambo
        current_delay = int(hit_indices[0])
        # Calcola il ritardo storico massimo (massimo intervallo tra ambi consecutivi)
        if len(hit_indices) > 1:
            delays = np.diff(hit_indices)
            max_historical_delay = int(np.max(delays))
        else:
            max_historical_delay = current_delay
        return total_hits, current_delay, max_historical_delay
    def analyze_random_combinations(
        self,
        fixed_numbers: List[int],
        pool_numbers: List[int],
        num_dynamic: int,
        num_combinations: int,
        target_sorte: str = "AMBO",
        min_hits: int = 2,
        max_diff: int = 10,
        show_progress: bool = True
    ) -> Dict:
        """
        Genera e analizza combinazioni random
        Args:
            fixed_numbers: Numeri fissi
            pool_numbers: Pool da cui pescare i numeri dinamici
            num_dynamic: Quanti numeri dinamici aggiungere
            num_combinations: Quante combinazioni generare
            target_sorte: Sorte da verificare
            min_hits: Colpi minimi per la sorte
            max_diff: Differenza massima accettabile (RS - RA)
            show_progress: Mostra barra di progresso
        Returns:
            Dizionario con risultati filtrati
        """
        start_time = time.time()
        print(f"\n🔧 INIZIO ANALISI COMBINAZIONI RANDOM")
        print(f"   Fissi: {len(fixed_numbers)} numeri")
        print(f"   Pool disponibile: {len(pool_numbers)} numeri")
        print(f"   Dinamici per combinazione: {num_dynamic}")
        print(f"   Combinazioni da generare: {num_combinations}")
        print(f"   Filtro: diff <= {max_diff}")
        print(f"   Sorte: {target_sorte} (min {min_hits} colpi)")
        # Calcola totale combinazioni possibili
        from math import comb
        total_possible = comb(len(pool_numbers), num_dynamic)
        print(f"   Combinazioni totali possibili: {total_possible:,}")
        results = []
        filtered_results = []
        # Genera combinazioni random
        print(f"\n🎲 Generazione e analisi combinazioni...")
        iterator = range(num_combinations)
        if show_progress:
            iterator = tqdm(iterator, desc="Analisi combinazioni")
        for i in iterator:
            # Scegli num_dynamic numeri random dal pool
            dynamic_numbers = random.sample(pool_numbers, num_dynamic)
            # Combina fissi + dinamici
            full_combo = np.array(sorted(fixed_numbers + dynamic_numbers), dtype=np.int16)
            # Calcola metriche
            total_hits, current_delay, max_hist_delay = self._calculate_metrics(
                full_combo, min_hits
            )
            diff = max_hist_delay - current_delay
            combo_data = {
                'combination': full_combo.tolist(),
                'fixed': sorted(fixed_numbers),
                'dynamic': sorted(dynamic_numbers),
                'total_hits': total_hits,
                'current_delay': current_delay,
                'max_historical_delay': max_hist_delay,
                'diff': diff
            }
            results.append(combo_data)
            # Applica filtro
            if diff <= max_diff:
                filtered_results.append(combo_data)
        elapsed_time = time.time() - start_time
        # Ordina risultati filtrati per diff (prima i migliori)
        filtered_results.sort(key=lambda x: (x['diff'], x['current_delay']))
        return {
            'total_generated': len(results),
            'filtered_count': len(filtered_results),
            'filtered_results': filtered_results,
            'elapsed_time': elapsed_time,
            'parameters': {
                'fixed_count': len(fixed_numbers),
                'dynamic_count': num_dynamic,
                'num_combinations': num_combinations,
                'target_sorte': target_sorte,
                'min_hits': min_hits,
                'max_diff': max_diff
            }
        }
    def print_results(self, result: Dict, top_n: int = 20):
        print("\n" + "="*80)
        print("📊 RISULTATI ANALISI COMBINAZIONI RANDOM")
        print("="*80)
        params = result['parameters']
        print(f"\n⚙️  PARAMETRI:")
        print(f"   Numeri fissi: {params['fixed_count']}")
        print(f"   Numeri dinamici: {params['dynamic_count']}")
        print(f"   Combinazioni generate: {params['num_combinations']}")
        print(f"   Sorte target: {params['target_sorte']}")
        print(f"   Colpi minimi: {params['min_hits']}")
        print(f"   Filtro max diff: {params['max_diff']}")
        print(f"\n📈 STATISTICHE:")
        print(f"   Totale generate: {result['total_generated']}")
        print(f"   Combinazioni filtrate: {result['filtered_count']}")
        print(f"   Percentuale filtrate: {result['filtered_count']/result['total_generated']*100:.2f}%")
        print(f"   Tempo elaborazione: {result['elapsed_time']:.2f} secondi")
        if result['filtered_count'] > 0:
            print(f"\n🏆 TOP {min(top_n, result['filtered_count'])} COMBINAZIONI MIGLIORI:")
            for idx, combo in enumerate(result['filtered_results'][:top_n], 1):
                print(f"\n   #{idx}")
                print(f"   Combinazione completa: {combo['combination']}")
                print(f"   Fissi: {combo['fixed']}")
                print(f"   Dinamici: {combo['dynamic']}")
                print(f"   Totale ambi: {combo['total_hits']}")
                print(f"   Ritardo attuale (RA): {combo['current_delay']}")
                print(f"   Ritardo storico max (RS): {combo['max_historical_delay']}")
                print(f"   Diff (RS - RA): {combo['diff']}")
        else:
            print(f"\n⚠️  Nessuna combinazione rispetta il filtro")
        print("\n" + "="*80)

# ============================================================================
# FUNZIONE PRINCIPALE - ESEMPIO DI UTILIZZO
# ============================================================================
def main():
    # URL dell'archivio estrazioni
    archive_url = "url estrazioni desiderato" # es. "https://huggingface.co/spaces/AI-tom/backtester-con-rilevamento-parametri-x-training/raw/main/LottoJarvis_Cloud/1_Data/archivi_estrazioni/estrazioni-VE.txt"
    # Inizializza l'analizzatore
    analyzer = RandomCombinationAnalyzer(archive_url)
    # ========================================================================
    # CONFIGURAZIONE - MODIFICA QUI I TUOI PARAMETRI
    # ========================================================================
    # I tuoi 29 numeri fissi (MODIFICA CON I TUOI NUMERI)
    #fixed_numbers = list(range(1, 30))  # Esempio: numeri da 1 a 29

    fixed_numbers = [1,2,3,4,5,6,7,8,9,10] # esempio di gruppo fisso fittizio


    # Pool di numeri disponibili per i dinamici
    pool_numbers = [n for n in range(1, 91) if n not in fixed_numbers]
    # Parametri di configurazione
    num_dynamic = 8 # Quanti numeri dinamici aggiungere
    num_combinations = 10000  # Quante combinazioni "ibride" random generare
    max_diff = 2  # Filtro: mostra solo combinazioni con diff <= 10
    # ========================================================================
    # ESECUZIONE ANALISI
    # ========================================================================
    result = analyzer.analyze_random_combinations(
        fixed_numbers=fixed_numbers,
        pool_numbers=pool_numbers,
        num_dynamic=num_dynamic,
        num_combinations=num_combinations,
        target_sorte="AMBO",
        min_hits=2,
        max_diff=max_diff,
        show_progress=True
    )
    # Stampa i risultati
    analyzer.print_results(result, top_n=20)
    return result

# Esegui l'analisi
if __name__ == "__main__":
    result = main()



#fixed_numbers = [1, 5, 12, 23, ...]  # I tuoi numeri fissi
#num_dynamic = 4  # Quanti numeri dinamici
#num_combinations = 1000  # Quante combinazioni generare
#max_diff = 10  # Filtro: diff <= 10

per quanto riguarda l'"incongruenza" dei consecutivi non presenti nel gruppo analizzato da jarvis sono dovuti appunto al considerare in questo caso in modo random anche gli 8 elementi aggiunti al gruppo fisso generati da tutti i 90 numeri a girare... ; per quanto riguarda il formato analizzato l'archivio estrazioni è strutturato da righe numeriche con 5 elementi cadauna intervallati da carattere punto a doppia cifra con lo 0 davanti i numeri da 1 a 9 e con le estrazioni recenti in alto e quelle vecchie in basso ; per rispondere anche alla tua ultima domanda : si ovviamente il "lavoro finale" è rappresentato da una classe <= 10 "giocabile" ottenibile dalla "cesellatura" del punto 5.

lotto_tom75 · Oggi alle 12:16

olegna ha scritto:
Ciao lotto Tom come si fa a giocare 18 numeri

Sono sopratutto per eventuali convergenze su ruota target... Ad ogni modo... come scritto sopra volendo si possono considerare le sotto formazioni con particolari situazioni statistiche di ritardo per ambo in c3,c4,c5,c6 ecc... ossia in c <= 10 e quindi in classe "giocabile". In questo caso il gruppo base di classe > 10 e pari a 18 è solo per vederne il comportamento "macro" in pochi colpi...

rubino2 · Oggi alle 15:25

ciao lottotom, purtroppo non riesco a controllare se ottengo gli stessi dati il file che ho è solo 1946, quelli del 1871 non li ho disponibili devo crearmeli.

comunque ho cercato di replicare il tuo script in python , e funziona sulla falsa riga del tuo, dovrò naturalmente delle prove verificare i risultati.

devo correggere la domanda che ti avevo fatto precedentemente, come mai jarvis wheel contiene nonstante tutto quattro numeri consecutivi la diciottina valida? risposta è proprio qui il valore o il filtro di jarvis wheel, armonia posizionale che contempla un tot. di consecutivi. quindi è proprio il filtro che funziona. la tua diciottina deve contenere in misura misurata la quantità di numeri consecutivi.

questo è il lavoro in java script ottenuto sul predictor e jarvis fatto però su altra ruota. CAGLIARI

conferma anche questo script una terzina interessante che è ai limiti ormai del ritardo corrente molto alto, 04 44 48 per ambo o la lunghettao sestina che propone 2 colpi.
jo impostato 20000 random, ma con 10000 gira in tutto 8 secondi o qualche millesimo in piu'. è iper velocissimo.

naturalmente è una prova e non c'è garanzia di nulla. ciao è grazie
ci studierò sopra.

SU TUTTE QUARTINA PER AMBO

rubino2 · Oggi alle 19:10

scusa ho voluto estendere le possibili scelte tra terzine in quantità fino a 4 o le coppie(ambi) fino a 4 per formare CUG maggiore per la sorte TRE, (terno) che tu sappia ho esteso ai fissi jarvis , ho voluto caricare tutti gli altri fino a completare i 90 numeri, che tu sappia hai mai provato a chiedere il risultato di quaterna o cinquina? su 10/12 cug massimi?

lotto_tom75 · 44 minuti fa

rubino2 ha scritto:
scusa ho voluto estendere le possibili scelte tra terzine in quantità fino a 4 o le coppie(ambi) fino a 4 per formare CUG maggiore per la sorte TRE, (terno) che tu sappia ho esteso ai fissi jarvis , ho voluto caricare tutti gli altri fino a completare i 90 numeri, che tu sappia hai mai provato a chiedere il risultato di quaterna o cinquina? su 10/12 cug massimi? Vedi l'allegato 2317679

no mi fermo al terno in questi casi.

ma al 90% il target è solo.. AMBO.

Just Some Notes to Remember on New Computational and Reductional Developments

Super Member >GOLD<

Super Member >GOLD<

Advanced Premium Member

Super Member >GOLD<

Super Member >GOLD<

Advanced Premium Member

Advanced Premium Member

Super Member >GOLD<

Advanced Premium Member

Super Member >GOLD<

Advanced Premium Member

Advanced Premium Member

Advanced Member

Super Member >GOLD<

Advanced Premium Member

Advanced Premium Member

Advanced Member

Allegati

Advanced Member

Advanced Premium Member