ForHosting KIT · Strumenti per sviluppatori

Verifica dei primi di Mersenne con Lucas-Lehmer

Questo strumento riceve un esponente primo p e stabilisce se 2^p - 1 è primo. Applica Lucas-Lehmer, il test deterministico specifico per i numeri di Mersenne, e restituisce numero esatto, iterazioni e residuo finale.

● BetaGratis · nel tuo browser

Esegui gratis nel browser Vedi l'API

Usalo da WebAPIEmailTelegramApp presto

Prima convalida l’esponente, poiché un esponente composto non può generare un primo di Mersenne. Lei può così distinguere una richiesta non valida da un test valido concluso con un numero composto.

Scelga e convalidi l’esponente

Inserisca un intero p tra 2 e 10,000. Sono accettati il campo p e l’alias exponent, anche come stringa intera. Prima di costruire il numero, una divisione di prova deterministica conferma che p sia primo. È un requisito matematico: se p è composto, 2^p - 1 ammette una fattorizzazione algebrica. Perciò tale input genera un errore e non un risultato falso. Falso indica invece che un esponente primo è stato verificato correttamente ma il relativo numero di Mersenne è composto. Sono rifiutati anche decimali, campi mancanti, array, testi non numerici e valori fuori dall’intervallo dichiarato.

Comprenda il calcolo di Lucas-Lehmer

Dopo la convalida, il sistema forma M = 2^p - 1 con aritmetica BigInt esatta. Per un primo dispari parte da s = 4 e sostituisce ripetutamente s con il suo quadrato meno 2, ridotto modulo M, per p - 2 volte. M è primo se e solo se il residuo finale è zero. Non intervengono arrotondamenti, testimoni probabilistici, rete o casualità. p = 2 produce M = 3 senza iterazioni e con residuo zero. La risposta espone numero decimale, decisione, metodo, iterazioni e residuo affinché Lei possa riprodurre e controllare il calcolo.

Interpreti e utilizzi il risultato

is_prime riguarda il numero di Mersenne, non l’esponente già convalidato. Vero indica residuo finale zero; falso indica p primo ma 2^p - 1 composto. mersenne e final_residue sono stringhe decimali per evitare perdite di precisione JSON. Lo strumento è adatto a lezioni, fixture di regressione, dimostrazioni e controlli matematici limitati. Non effettua ricerche illimitate: ogni richiesta valuta un solo esponente entro il limite. Il browser usa la stessa logica deterministica dell’API; ogni chiamata automatizzata costa $0.002. Poiché il risultato non cambia, nei sistemi ad alto volume è opportuno conservarlo in cache.

Casi d'uso

Verificare un esponente candidato

Confermi che il numero associato a un esponente primo soddisfi esattamente il criterio di Lucas-Lehmer.

Insegnare la ricorrenza modulare

Mostri come quadrature modulari ripetute raggiungano un residuo zero oppure non nullo.

Creare fixture deterministiche

Generi valori, conteggi e residui stabili per convalidare un’altra implementazione.

Domande frequenti

Cosa accade se p è composto?

La richiesta restituisce un errore di input perché p deve essere primo.

Un esponente primo garantisce un primo di Mersenne?

No. È necessario ma non sufficiente; decide il residuo di Lucas-Lehmer.

Perché numero e residuo sono stringhe?

Possono superare la precisione intera di JSON; le stringhe preservano ogni cifra.

Il test è probabilistico?

No. Lucas-Lehmer è deterministico per numeri di Mersenne con esponente primo.

Quanto costa una verifica API?

Ogni richiesta costa $0.002. La versione browser usa lo stesso calcolo puro.

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

POSThttps://api.kit.forhosting.com/numth/mersenne-prime-check

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/mersenne-prime-check \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"p":31}'

const res = await fetch("https://api.kit.forhosting.com/numth/mersenne-prime-check", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "p": 31
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/numth/mersenne-prime-check",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "p": 31
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/mersenne-prime-check", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"p":31}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"p":31}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/mersenne-prime-check", 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

{
  "p": 31
}

Esempio di risposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "numth.mersenne_prime_check",
  "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

per richiesta$0.002

Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.

Limiti

`min_p`	2
`max_p`	10000

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.

Leggi la documentazione completa del KIT →