Copertura minima delle basi per la verifica quadratica dei residui della quadratura


11

Sfida

Trova la più piccola copertura di basi (ad es. Moduli) i cui insiemi di residui quadratici possono essere testati tramite la ricerca di una tabella per determinare definitivamente se un dato numero intero non negativo n è un quadrato perfetto. Le basi devono essere tutte inferiori o uguali alla radice quadrata del valore massimo di n .

La risposta con la più piccola serie di basi per una determinata categoria di n vince la sfida. (Ciò significa che potrebbe esserci potenzialmente più di un vincitore.) Le categorie di n sono:

         Category       Maximum allowed n    Maximum allowed modulus/base
    -------------    --------------------    ----------------------------
     8-bit values                     255                              15
    16-bit values                   65535                             255
    32-bit values              4294967295                           65535
    64-bit values    18446744073709551615                      4294967295

In caso di pareggio con due set con uguale cardinalità, il pareggio andrà al set con la maggiore capacità di rilevare non quadrati all'inizio della sequenza.

Nel caso in cui non venga trovata alcuna copertura completa (che è del tutto probabile per le categorie a 32 e 64 bit), il vincitore sarà l'insieme di basi che statisticamente o dimostrabili esclude la più alta percentuale di non quadrati (senza errato quadrati di segnalazione come non quadrati). Vedi sotto per una discussione di copertine incomplete.

sfondo

In molte applicazioni della teoria dei numeri, si pone la questione se il numero n sia o meno un quadrato perfetto (0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, ecc.). Un modo per verificare se n è quadrato è verificare se floor (√n) ² = n, ovvero se la radice quadrata arrotondata per difetto di n , quando squadrata, restituisce n . Ad esempio, floor (√123) ² = 11² = 121, che non è 123, quindi 123 non è quadrato; ma piano (√121) ² = 11² = 121, quindi 121 è quadrato. Questo metodo funziona bene per piccoli numeri, specialmente quando è disponibile un'operazione hardware radice quadrata. Ma per grandi numeri (centinaia o migliaia di bit) può essere molto lento.

Un altro modo per testare la quadratura è escludere i non quadrati usando le tabelle dei residui quadratiche. Ad esempio, tutti i quadrati nella base 10 devono avere una cifra finale (a un posto) che sia 0, 1, 4, 5, 6 o 9. Questi valori formano l'insieme del residuo quadratico per la base 10. Quindi se una base -10 il numero termina con 0, 1, 4, 5, 6 o 9, sai che potrebbe essere quadrato e saranno necessari ulteriori esami. Ma se un numero base-10 termina a 2, 3, 7, o 8, allora si può essere certi che è non quadrata.

Quindi diamo un'occhiata a un'altra base. Tutti i quadrati nella base 8 devono terminare con 0, 1 o 4, che è convenientemente solo 3 su 8 possibilità, il che significa una probabilità del 37,5% di un numero casuale che può essere quadrato, o il 62,5% di probabilità che un numero casuale non sia sicuramente quadrato. Quelle sono probabilità molto migliori di quelle fornite dalla base 10. (E nota che un'operazione del modulo base 8 è semplicemente un'operazione logica e, al contrario del modulo base 10, che è una divisione per 10 con il resto.)

Ci sono basi ancora migliori? Beh, sì, in realtà. Base 120 ha 18 possibilità (0, 1, 4, 9, 16, 24, 25, 36, 40, 49, 60, 64, 76, 81, 84, 96, 100 e 105), che rappresenta solo un 15% possibilità di essere probabilmente quadrati. E la base 240 è ancora migliore, con solo 24 possibilità, che rappresentano solo il 10% di probabilità di essere probabilmente quadrate.

Ma nessuna singola base da sola può determinare definitivamente la quadratura (a meno che non sia maggiore del numero massimo da testare, il che è eminentemente impraticabile). Una sola base da sola può escludere solo la quadratura; non può verificare in modo conclusivo la quadratura. Solo un insieme accuratamente selezionato di basi, lavorando insieme, può verificare definitivamente la quadratura su un intervallo di numeri interi.

Quindi, la domanda diventa: quale insieme di basi costituisce una copertura minima che insieme consente la deduzione definitiva di quadratura o non-quadratura?

Esempio di una copertina corretta ma non minimale

La copertura della base 16 della copertura {3, 4, 5, 7, 8, 9, 11, 13, 16, 17, 19, 23, 25, 29, 31, 37} è sufficiente per determinare definitivamente la quadratura o la non-quadratura di tutti i valori da 16 bit da 0 a 65535. Ma non è una copertura minima , perché esiste almeno una copertura da 15 basi che è anche facilmente individuabile. In effetti, è probabile che esistano copertine molto più piccole, forse con solo 6 o 7 basi.

Ma a titolo di esempio, diamo un'occhiata al test di un valore campione di n usando questo set di cover a 16 basi. Ecco i set di residui quadratici per il set di basi sopra:

Base m   Quadratic residue table specific to base m
------   ----------------------------------------------------
   3     {0,1}
   4     {0,1}
   5     {0,1,4}
   7     {0,1,2,4}
   8     {0,1,4}
   9     {0,1,4,7}
  11     {0,1,3,4,5,9}
  13     {0,1,3,4,9,10,12}
  16     {0,1,4,9}
  17     {0,1,2,4,8,9,13,15,16}
  19     {0,1,4,5,6,7,9,11,16,17}
  23     {0,1,2,3,4,6,8,9,12,13,16,18}
  25     {0,1,4,6,9,11,14,16,19,21,24}
  29     {0,1,4,5,6,7,9,13,16,20,22,23,24,25,28}
  31     {0,1,2,4,5,7,8,9,10,14,16,18,19,20,25,28}
  37     {0,1,3,4,7,9,10,11,12,16,21,25,26,27,28,30,33,34,36}

Ora proviamo il numero n = 50401 usando questo set di basi, convertendolo in ciascuna base. (Questo non è il modo più efficace di esaminare i residui, ma è sufficiente per scopi esplicativi.) È il posto dell'1 che ci interessa qui (indicato di seguito tra parentesi):

 Base                               "Digits" in base m
   m          m^9   m^8   m^7   m^6   m^5   m^4   m^3   m^2   m^1  ( m^0 )
 ----      -----------------------------------------------------------------
   3           2     1     2     0     0     1     0     2     0   (  1 ) ✓
   4                       3     0     1     0     3     2     0   (  1 ) ✓
   5                             3     1     0     3     1     0   (  1 ) ✓
   7                                   2     6     6     6     4   (  1 ) ✓
   8                                   1     4     2     3     4   (  1 ) ✓
   9                                         7     6     1     2   (  1 ) ✓
  11                                         3     4     9     5   ( 10 )
  13                                         1     9    12     3   (  0 ) ✓
  16                                              12     4    14   (  1 ) ✓
  17                                              10     4     6   ( 13 ) ✓
  19                                               7     6    11   ( 13 )
  23                                               4     3     6   (  8 ) ✓
  25                                               3     5    16   (  1 ) ✓
  29                                               2     1    26   ( 28 ) ✓
  31                                               1    21    13   ( 26 )
  37                                                    36    30   (  7 ) ✓

Quindi possiamo vedere che in 13 di queste basi, il residuo corrisponde a un residuo quadratico noto (chiamalo "hit" nella tabella), e in 3 di queste basi, il residuo non corrisponde a un residuo quadratico noto (chiamalo un "Perdere"). Basta 1 miss per sapere che un numero non è quadrato, quindi potremmo fermarci alle 11, ma a fini illustrativi, abbiamo esaminato tutte e 16 le basi qui.

Esempio di copertina incompleta

Tecnicamente, una copertina incompleta non è una copertina, ma non è questo il punto. L'insieme di basi {7, 8, 11, 15} copre quasi tutti i valori a 8 bit di n da 0 a 255 correttamente, ma non del tutto. In particolare, identifica erroneamente 60 e 240 come quadrati (si tratta di falsi positivi), ma identifica correttamente tutti i quadrati effettivi (0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196 e 225) e non produce altri falsi positivi. Quindi questo è un set di 4 che quasi riesce come soluzione, ma alla fine fallisce, perché una copertura incompleta non è una soluzione valida.

Per 8 bit n , l'insieme di basi {7, 8, 11, 15} è uno dei due insiemi di 4 basi che producono due errori e ci sono sette insiemi di 4 basi che producono solo un errore. In realtà non esistono insiemi di 4 basi che formano una copertura completa e accurata dei valori a 8 bit. Riesci a trovare un set di 5 basi che non producono errori, coprendo correttamente tutti i valori a 8 bit? O ne hai bisogno di 6 o più? (Conosco la risposta per 8-bit n , ma non ho intenzione di darlo via. Non conosco la risposta per 16-bit, 32-bit o 64-bit, e credo che anche il 16- il caso dei bit è impossibile da risolvere tramite la ricerca della forza bruta. Risolvere i casi a 32 e 64 bit richiederà sicuramente tecniche di ricerca genetica, euristica o di altro tipo.)

Un commento su numeri crittograficamente grandi

Al di là dei numeri a 64 bit - su centinaia o migliaia di cifre binarie - è qui che un controllo rapido della quadratura risulta davvero utile, anche se la copertina è incompleta (cosa che sicuramente sarà per numeri molto grandi). Come può un test come questo essere ancora utile anche se non è sufficientemente decisivo? Bene, immagina di avere un test estremamente veloce per la quadratura che ha funzionato correttamente il 99,9% delle volte e ha dato falsi negativi il restante 0,1% delle volte e non ha mai dato falsi positivi. Con un test del genere, saresti in grado di determinare la non quadratura di un numero quasi istantaneamente, e quindi, in casi eccezionali di indecisione, potresti ricorrere a un metodo più lento per risolvere l'ignoto in un modo diverso. Questo ti farebbe risparmiare un bel po 'di tempo.

Ad esempio, il set {8, 11, 13, 15} è corretto il 99,61% del tempo per i valori a 8 bit da n da 0 a 255, è corretto il 95,98% del tempo per i valori a 16 bit da n da 0 a 65535, ed è corretto il 95,62% del tempo per valori a 24 bit di n da 0 a 16777215. Mentre n va all'infinito, la percentuale di correttezza per questo insieme di basi scende, ma si avvicina asintoticamente e non scende mai al di sotto del 95,5944% correttezza.

Quindi anche questa minuscola serie di 4 piccole basi è utile per identificare quasi immediatamente circa 22 su 23 numeri arbitrariamente grandi come non quadrati - ovviando alla necessità di un'ulteriore ispezione di quei numeri con metodi più lenti. I metodi più lenti devono quindi essere applicati solo nella piccola percentuale di casi che non è stato possibile escludere da questo test rapido.

È interessante notare che alcune basi a 16 bit ottengono risultati migliori del 95% da sole. In effetti, ciascuna delle basi sottostanti è in grado di estirpare meglio del 97% di tutti i numeri fino all'infinito come non quadrata. Il set di residui quadratico per ciascuna di queste basi può essere rappresentato come un array di bit compresso utilizzando solo 8192 byte.

Ecco le 10 basi singole più potenti meno di 2 ^ 16:

 Rank   Base    Prime factorization       Weeds out
 ----   ------------------------------    ---------
  1.    65520 = 2^4 x 3^2 x 5 x 7 x 13      97.95%
  2.    55440 = 2^4 x 3^2 x 5 x 7 x 11      97.92%
  3.    50400 = 2^5 x 3^2 x 5^2 x 7         97.56%
  4.    52416 = 2^6 x 3^2 x 7 x 13          97.44%
  5.    61200 = 2^4 x 3^2 x 5^2 x 17        97.41%
  6.    44352 = 2^6 x 3^2 x 7 x 11          97.40%
  7.    63360 = 2^7 x 3^2 x 5 x 11          97.39%
  8.    60480 = 2^6 x 3^3 x 5 x 7           97.38%
  9.    63840 = 2^5 x 3 x 5 x 7 x 19        97.37%
 10.    54720 = 2^6 x 3^2 x 5 x 19          97.37%

Vedi qualcosa di interessante che queste basi hanno tutte in comune? Non c'è motivo di pensare che potrebbero essere utili in combinazione (forse lo sono, forse non lo sono), ma qui ci sono alcuni buoni indizi su quali basi potrebbero essere più influenti per le più grandi categorie di numeri.

Sfida secondaria : una delle basi più influenti (se non la maggior parte) fino a 2 ^ 28 è 245044800, che da sola può eliminare correttamente il 99,67% dei non quadrati, o circa 306 su 307 numeri casuali lanciati. Riesci a trovare la base singola più influente a meno di 2 ^ 32?

Relazionato

Ci sono alcune idee molto belle nelle seguenti domande che sono strettamente correlate, oltre a diversi trucchi di micro-ottimizzazione per rendere più veloci determinate operazioni. Sebbene le domande collegate non si prefiggano in modo specifico di trovare l'insieme di basi più forte, l'idea di basi forti è implicitamente centrale in alcune delle tecniche di ottimizzazione utilizzate lì.


Come determinerete il corto del tie-break per testare ogni singolo numero nell'intervallo dato e contare quanti controlli sono stati effettuati in totale?
Martin Ender,

Vedrò la cardinalità degli insiemi di residui quadratici per ogni base. Ad esempio, 4 è una base migliore di 3, poiché solo la metà dei valori del modulo 4 sono residui quadratici, mentre i due terzi dei valori del modulo 3 sono residui quadratici. Pertanto, 4 ha una maggiore capacità di estrapolare i numeri prima. La base peggiore è 2, poiché non può escludere alcun numero e la base migliore inferiore a 256 è 240, che è in grado di escludere il 90% dei numeri. Potrebbe essere necessario campionare Monte Carlo per basi davvero grandi.
Todd Lehman,

Sì, ha senso. Ma deciderai il pareggio solo dalla prima base la cui probabilità differisce, o come riuscirai a capire l'efficienza dell'intero set in base alle probabilità? Sto anche pensando che le probabilità non sono più indipendenti dopo aver controllato altre basi.
Martin Ender,

2
Nel caso di n spazi ampi, penso che dovrò decidere il legame in base all'efficienza complessiva stimata, calcolata moltiplicando le probabilità previste da ciascun insieme di residui. Ad esempio, le basi {8,11,13,15} hanno probabilità di 0,375, 0,545455, 0,538462 e 0,4, rispettivamente, che si moltiplicano per 0,044056. Sottraendo da 1, si ottiene 0,955944, che concorda strettamente con il risultato del conteggio esaustivo del 95,62% misurato su tutto n in [0,2 ^ 24-1].
Todd Lehman,

Risposte:


7

matematica

Non so molto sulla teoria dei numeri (purtroppo), quindi questo è un approccio piuttosto ingenuo. Sto usando un algoritmo avido che aggiunge sempre la base che ha il maggior numero di mancanze per i numeri rimanenti.

bits = 8
Timing[
 maxN = 2^bits - 1;
 maxBase = 2^(bits/2) - 1;
 bases = {
     #,
     Union[Mod[Range[0, Floor[#/2]]^2, #]]
     } & /@ Range[3, maxBase];
 bases = SortBy[bases, Length@#[[2]]/#[[1]] &];
 numbers = {};
 For[i = 0, i <= Quotient[maxN, bases[[1, 1]]], ++i,
  AppendTo[numbers, # + i*bases[[1, 1]]] & /@ bases[[1, 2]]
  ];
 While[numbers[[-1]] > maxN, numbers = Most@numbers];
 numbers = Rest@numbers;
 i = 0;
 cover = {bases[[1, 1]]};
 lcm = cover[[-1]];
 Print@cover[[1]];
 While[Length@numbers > maxBase,
  ++i;
  bases = DeleteCases[bases, {b_, r_} /; b\[Divides]lcm];
  (*bases=SortBy[bases,(Print[{#,c=Count[numbers,n_/;MemberQ[#[[2]],
  Mod[n,#[[1]]]]]}];c)&];*)
  bases = SortBy[
    bases,
    (
      n = Cases[numbers, n_ /; n < LCM[#[[1]], lcm]];
      Count[n, n_ /; MemberQ[#[[2]], Mod[n, #[[1]]]]]/Length@n
      ) &
    ];
  {base, residues} = bases[[1]];
  numbers = Cases[numbers, n_ /; MemberQ[residues, Mod[n, base]]];
  AppendTo[cover, base];
  lcm = LCM[lcm, base];
  Print@base
  ];
 cover
 ]

Risolve 8 bit in pochissimo tempo con le seguenti 6 basi:

{12, 13, 7, 11, 5, 8}

16 bit richiede 6 secondi e si traduce nella seguente copertura a 6 basi:

{240, 247, 253, 119, 225, 37}

Per i casi più grandi questo approccio ovviamente esaurisce la memoria.

Per andare oltre i 16 bit, dovrò trovare un modo per verificare che una copertina sia completa senza effettivamente tenere un elenco di tutti i numeri fino a N max (o andare a conoscere la teoria dei numeri).

Modifica: tempo di esecuzione ridotto per 16 bit da 66 a 8 secondi prepopolando l'elenco di numeri con solo quelli che non sono esclusi dalla base più efficace. Ciò dovrebbe anche migliorare significativamente il footprint di memoria.

Modifica: ho aggiunto due piccole ottimizzazioni per ridurre lo spazio di ricerca. Non è una delle categorie ufficiali, ma con ciò ho trovato una copertura a 8 basi per 24 bit in 9.3 ore:

{4032, 3575, 4087, 3977, 437, 899, 1961, 799}

Per quanto riguarda le ottimizzazioni, ora sto saltando tutte le basi che dividono l'LCM delle basi già nella copertina, e quando collaudo l'efficienza di una base la collaudo solo con i numeri fino all'LCM di quella nuova base e tutte le basi che già ho avere.


1
@ToddLehman Non so se hai visto la mia prima soluzione prima di modificarla con quella golosa. (Se non lo hai fatto, dai un'occhiata alla cronologia delle modifiche.) Stavo solo selezionando le basi in base al loro rapporto hit / miss generale fino a quando non ho avuto una copertura completa. Ciò ha prodotto 8 basi per 8 bit e 29 basi per 16 bit. : D
Martin Ender,

1
@ToddLehman Grazie per i test! :) Mi chiedo che cosa potrebbero inventare le persone con una conoscenza effettiva della teoria dei numeri. Ho un paio di idee per accelerarlo, quindi potrei andare a 24 bit, ma penso che dovrei concentrarmi su come portare la mia prossima sfida in pista.
Martin Ender,

1
@ToddLehman C'è una copertina a 24 bit per te. Mi stavo già chiedendo se potevo fare uso dei fattori primi, ma non ho ancora trovato l'euristica decente. Tutto quello che potrei fare è migliorare l'ordine in cui vengono testate le basi, ma non sono ancora sicuro di quando potrò interromperlo.
Martin Ender,

1
@ToddLehman Non hai bisogno di taggarmi nei miei post in quanto riceverò comunque una notifica. Ecco perché SE disabilita il completamento automatico fino a quando non ci sono commenti da più utenti, dove potrebbe essere logico rivolgersi in modo specifico al PO.
Martin Ender,

1
Ho appena trovato una copertura a 9 basi per 28 bit: {15840, 15827, 16211, 12549, 14911, 15111, 9869, 14647, 16043}. Il tempo di esecuzione è stato di 36,5 minuti, usando un programma C ottimizzato per valutare la forma fisica usando operazioni bit per bit impacchettate usando un algoritmo avido. Questo set a 9 basi è una copertura perfetta per numeri inferiori a 2 ² ed è preciso al 99,999983% per i numeri in su nell'intervallo 2 °.
Todd Lehman,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.