Fattorizzazione di Pollard p−1
Trova un fattore di un numero composto quando uno dei suoi primi p ha un p − 1 liscio: 1003 con limite 16 si divide in 17 e 59, perché 17 − 1 fa 16. Se non appare nulla, alzi il limite. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- N
- 1003
- Estremo
- 16
- Fattore
- 17
- Cofattore
- 59
- Base
- 2
Il metodo p meno uno di Pollard è un algoritmo classico di fattorizzazione di interi che trova un fattore non banale di un modulo composto n quando almeno un fattore primo p di n ha la proprietà che p meno uno è liscio rispetto a un limite B scelto — ogni potenza prima nella fattorizzazione di p meno uno è al più B. Studenti di teoria elementare dei numeri, concorrenti CTF e apprendisti di crittografia incontrano questo algoritmo quando studiano perché i moduli RSA devono evitare primi con totienti lisci. Questa capacità esegue una ricerca deterministica di stadio uno di Pollard p−1: costruisce il prodotto di potenze prime fino a B, eleva una piccola base a tale esponente modulo n e restituisce il MCD di quella potenza meno uno con n quando il MCD è un fattore proprio.
Come Pollard p−1 trova un fattore da un p−1 liscio
Fissi un intero composto n e un limite di levigatezza positivo B. L'osservazione di Pollard è semplice: se p è un divisore primo di n e ogni potenza prima che divide p meno uno è al più B, allora il minimo comune multiplo degli interi da uno a B è un multiplo di p meno uno.
Per il piccolo teorema di Fermat, qualsiasi base a coprima con p soddisfa a alla potenza p meno uno congruente a uno modulo p, e quindi a elevata a quel grande mcm è anch'essa congruente a uno modulo p. Calcolare la stessa potenza modulo n e prendere il massimo comun divisore del risultato meno uno con n spesso produce p o un altro fattore non banale.
In pratica l'implementazione non costruisce mai l'mcm completo in modo esplicito; setaccia i primi fino a B e, per ogni primo q, eleva l'accumulatore corrente alla massima potenza di q che non supera B, tutto modulo n. Dopo ogni passo di potenza prima valuta il MCD dell'accumulatore meno uno con n. Un MCD intermedio non banale viene restituito subito.
Se il MCD collassa a n, un percorso di recupero più fine su esponenti minori tenta di isolare un solo fattore primo prima di abbandonare quella base. Si provano diverse basi piccole affinché ordini sfortunati della base due non nascondano un fattore altrimenti B-liscio. Il metodo non è un algoritmo di fattorizzazione completa: restituisce un fattore non banale e il cofattore corrispondente.
Chi necessita della fattorizzazione prima completa può alimentare ogni pezzo composto a uno strumento di fattorizzazione in primi oppure alzare B e rieseguire. Il successo è garantito solo nello scenario di p−1 liscio; grandi fattori primi di p meno uno impongono una B maggiore o un altro algoritmo, come il metodo delle curve ellittiche o il crivello quadratico.
Quando conviene questo metodo di fattorizzazione
I corsi di crittografia usano Pollard p−1 per mostrare perché i primi con predecessori lisci sono pericolosi nella generazione di parametri RSA e Diffie–Hellman; uno strumento live che accetta n e B consente all'insegnante di dimostrare una scissione in classe senza scrivere a mano l'esponenziazione modulare.
Le piattaforme CTF e dei compiti necessitano di un oracolo deterministico che o restituisce un fattore documentato per semiprimi classici come milletré con limite sedici, o rifiuta limiti troppo stretti così i correttori possono valutare sia i fattori corretti sia i ragionamenti di fallimento corretti. Gli ingegneri della sicurezza che auditano la generazione di chiavi legacy possono setacciare moduli candidati alla ricerca di fattori con p−1 liscio prima che raggiungano la produzione.
Mantenga n entro il limite di cifre, scelga B abbastanza grande da coprire il maggiore fattore primo di p meno uno per qualche primo p che divide n, e otterrà fattori riproducibili per la didattica, i write-up CTF e audit leggeri senza erigere un intero stack di algebra computazionale.
Casi d'uso
Igiene dei moduli candidati
Setacci moduli candidati RSA o Diffie–Hellman alla ricerca di fattori con p−1 liscio prima del deploy, senza importare un suite completo di fattorizzazione.
Domande frequenti
Che cos'è il metodo di fattorizzazione p−1 di Pollard?
È un algoritmo di stadio uno che calcola una grande potenza liscia di una base modulo n e restituisce gcd(a^M − 1, n). Trova un fattore p quando p−1 è B-liscio per il limite B scelto.
Quando il metodo non riesce a trovare un fattore?
Quando n è primo, quando ogni fattore primo p di n ha un divisore primo di p−1 maggiore di B, o quando il recupero non isola un fattore proprio.
Restituisce la fattorizzazione prima completa?
No. Restituisce un fattore non banale e il cofattore n/factor (il minore per primo). Fattorizzi ogni pezzo con uno strumento di fattorizzazione in primi se le servono tutte le potenze prime.
Quale limite devo scegliere?
Parta da un valore piccolo e lo alzi se non compare alcun fattore. Il limite deve coprire ogni potenza di primo di p − 1 per almeno un fattore primo p del suo numero. È accettato qualsiasi intero da 2 a 50.000.
Quante cifre può avere il numero?
Fino a 18 cifre, scritto come intero senza punti, virgole o spazi. I numeri pari restituiscono subito il fattore 2, mentre un numero primo non dà alcun fattore, perché non c'è nulla da dividere.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/numth/pollard-p-minus-one \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":"1003","bound":16}'const res = await fetch("https://api.kit.forhosting.com/numth/pollard-p-minus-one", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": "1003",
"bound": 16
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/pollard-p-minus-one",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": "1003",
"bound": 16
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/pollard-p-minus-one", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":"1003","bound":16}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":"1003","bound":16}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/pollard-p-minus-one", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"n": "1003",
"bound": 16
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.pollard_p_minus_one",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Quando il limite è troppo stretto, n è primo o ogni fattore resiste al metodo, l'attività fallisce con invalid_input invece di inventare un fattore. Il percorso gratuito del browser e l'API a pagamento condividono lo stesso modulo BigInt puro, così i controlli dei compiti e l'automazione non discordano mai.
Contratto di ingresso, forma della risposta e modalità di errore
Il campo n è l'intero da fattorizzare: un intero JavaScript sicuro o una stringa decimale semplice senza virgole, spazi o notazione scientifica, con almeno due e al massimo diciotto cifre decimali. Esempio: n uguale a milletré e bound uguale a sedici restituisce fattore diciassette e cofattore cinquantanove perché diciassette meno uno è sedici, che è sedici-liscio. Se n è pari il fattore due viene restituito subito senza una ricerca completa di stadio uno. Tale fallimento è una scelta di prodotto intenzionale: un successo silenzioso con fattore uno o n romperebbe le automazioni che trattano qualsiasi risposta duecento come una scissione reale. Invii con POST un oggetto JSON con due campi obbligatori. Il campo bound è il limite di levigatezza B, un intero da due a cinquantamila; gli alias B, b, smoothness_bound e smoothness sono accettati per comodità. In caso di successo il corpo riecheggia n come stringa decimale e bound come intero, poi riporta factor e cofactor come stringhe decimali con il fattore minore per primo, la base che ha prodotto il fattore e method impostato alla stringa fissa pollard_p_minus_one. Campi assenti, non interi, n inferiore a due, bound fuori dall'intervallo pubblicato e n con più di diciotto cifre falliscono con invalid_input e non vengono addebitati. Quando lo stadio uno termina tutte le basi senza un fattore proprio — ad esempio n è primo, o ogni fattore primo p ha un divisore primo di p meno uno maggiore di B — il gestore fallisce anche con invalid_input e un messaggio che Pollard p−1 non ha trovato fattori non banali entro il limite, invitando ad alzare B o provare un altro n.
Dove un'API di fattore p−1 dà il suo valore
Gli autori di notebook che hanno già una routine generale di fattorizzazione in primi traggono ancora beneficio da un endpoint p−1 esplicito quando la lezione è il metodo stesso e non l'elenco completo dei fattori. Poiché l'implementazione è parse puro di livello A, ogni chiamata riuscita costa il prezzo base pubblicato $0.002 senza token di modello e senza rete in uscita, e la validazione fallita non consuma mai il saldo.
Casi di integrazione
Dimostrazioni in aula di p−1 liscio
Mostri come un limite B che copre p−1 di un fattore primo di un semiprimo produce una scissione non banale, con esempi classici come n=1003 con B=16.
Correttori automatici CTF e compiti
Valuti esercizi di Pollard p−1 con un oracolo deterministico che restituisce il fattore quando B basta e invalid_input quando il limite è troppo stretto.
Domande tecniche
Quali ingressi richiede l'API?
Il campo n (intero ≥ 2, ≤ 18 cifre) e il campo bound (levigatezza B da 2 a 50000). Gli alias includono number/value per n e B/smoothness_bound per bound.
Quanto costa la fattorizzazione di Pollard p−1?
Lo strumento browser è gratuito. Le richieste API usano il saldo prepagato KIT a $0.002 per chiamata riuscita; ingresso non valido e limiti falliti non vengono addebitati.