Petit théorème de Fermat
Saisissez une base et un module, et voyez si a^(n−1) mod n vaut 1 : avec 2 et 7, le reste de 2^6 est 1 ; avec 2 et 15, il est de 4. Utile pour corriger un devoir ou repérer un contre-exemple composé. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- A
- 2
- N
- 7
- Résultat
- 1
- Premier texte
- 2
- N
- 7
- Exposant
- 6
Le petit théorème de Fermat est l’énoncé clair de l’arithmétique modulaire : si n est premier et que la base a n’est pas divisible par n, alors a élevé à la puissance n moins un est congruent à un modulo n. Élèves, tuteurs et développeurs ont constamment besoin d’évaluer vite ce résidu de puissance exact—pas un résumé de la preuve—pour vérifier des devoirs, explorer des contre-exemples composés ou tester des routines modulaires. Ce vérificateur du petit théorème de Fermat prend les entiers a et n, refuse le couple lorsque gcd(a, n) n’est pas un, et sinon renvoie a^(n−1) mod n avec un indicateur booléen qui vous dit si le reste vaut un.
Ce que le petit théorème de Fermat affirme et ce que cet outil calcule
Sous sa forme usuelle de manuel, le petit théorème de Fermat dit : si n est un nombre premier et a un entier non divisible par n, alors a à la puissance n moins un est congruent à un modulo n. Écrit avec l’opérateur modulaire que les programmeurs utilisent chaque jour, cela donne a^(n−1) mod n égal à 1 dès que ces hypothèses tiennent. Vous fournissez la base a et le module n.
Le vérificateur exige d’abord que n soit un entier au moins égal à deux, car la réduction modulaire avec un module inférieur à deux n’est pas un contrat utile en classe. Il exige ensuite que le plus grand commun diviseur de a et n vaille un—l’hypothèse de coprimalité qui rejoint l’énoncé classique quand n est premier (a non divisible par n) et reste pertinente pour n composé lorsque vous voulez explorer ce qui se passe hors de la garantie du théorème.
Lorsque les deux contrôles passent, le moteur exécute une exponentiation modulaire binaire (élever au carré et multiplier) sur BigInt afin que les produits intermédiaires restent exacts même si l’exposant n−1 est grand.
En classe, pour les devoirs et les contre-exemples
Les enseignants utilisent un vérificateur du petit théorème de Fermat pour que les élèves vérifient à la main a^(p−1) mod p sur de petits premiers avant d’écrire une preuve, et pour qu’ils tentent volontairement des n composés et voient que le reste n’est pas toujours un. Les générateurs d’examens et les plugins LMS ont besoin d’un oracle déterministe qui refuse les entrées non coprimes au lieu de renvoyer silencieusement un reste qui brouille la correction.
Les carnets de cours de cryptographie ont souvent besoin d’une seule étape exacte de puissance modulaire pour introduire des clés RSA jouet ou illustrer pourquoi l’exposant n−1 apparaît en théorie élémentaire des nombres avant que le théorème d’Euler généralise le récit avec φ(n).
Lorsque vous aurez plus tard besoin du théorème d’Euler avec φ(n), d’inverses modulaires ou de décompositions par le théorème chinois des restes, appelez ces capacités séparées ; celle-ci reste la landing dédiée à Fermat a^(n−1) mod n pour que l’intention de recherche et la forme de la réponse restent claires.
Cas d’usage
Contrôles FLT pour devoirs et classe
Les élèves saisissent la base a et un premier n pour confirmer que a^(n−1) mod n vaut 1, ou testent des n composés pour voir quand le reste n’est pas 1.
Oracles de notation automatique LMS et examens
Notez des items d’arithmétique modulaire avec un reste déterministe et refusez les paires non coprimes comme invalides plutôt que d’inventer une charge utile de succès.
Tests unitaires de puissance modulaire
Les scripts figent des résidus connus comme 2^6 mod 7 = 1 et 2^14 mod 15 = 4 sans réimplémenter BigInt square-and-multiply dans chaque langage.
Questions fréquentes
Pourquoi gcd(a, n) doit-il valoir 1 ?
Le petit théorème de Fermat s’énonce pour des bases coprimes au module (équivalemment non divisibles par le premier n).
Un résultat égal à 1 prouve-t-il que n est premier ?
Non. Lorsque n est premier et gcd(a,n)=1 le reste vaut toujours 1, mais des composés peuvent aussi donner 1 pour certaines bases. Utilisez un outil de primalité dédié pour cette question.
Comment vérifier le petit théorème de Fermat avec la base 2 et le module 7 ?
Saisissez 2 comme base et 7 comme module. L'outil élève 2 à la puissance 6, divise par 7 et renvoie un reste de 1 : le théorème se vérifie pour ce nombre premier, comme prévu.
Pourquoi 2^14 mod 15 donne-t-il 4 et non 1 ?
Parce que 15 n'est pas premier : le théorème ne garantit alors rien. La base 2 n'a aucun diviseur commun avec 15, l'outil calcule donc le reste de 2 puissance 14 et obtient 4, ce qui montre que 15 échoue au test.
Puis-je utiliser une base négative ou un très grand module ?
Oui. Une base négative est d'abord réduite modulo n, et le module doit seulement être un entier d'au moins 2. La puissance se calcule par élévations au carré et multiplications sur des entiers exacts : même avec d'énormes exposants, le reste est exact.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/numth/fermat-little-check \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"a":2,"n":7}'const res = await fetch("https://api.kit.forhosting.com/numth/fermat-little-check", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"a": 2,
"n": 7
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/fermat-little-check",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"a": 2,
"n": 7
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/fermat-little-check", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"a":2,"n":7}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"a":2,"n":7}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/fermat-little-check", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"a": 2,
"n": 7
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.fermat_little_check",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
La même logique pure BigInt alimente l’outil gratuit du navigateur et le chemin API payant à $0.002 par requête réussie, afin que les démos de cours et les scripts de production ne divergent jamais sur un résidu.
Ce que le petit théorème de Fermat affirme et ce que cet outil calcule
La preuve n’est pas le produit de cet endpoint ; le produit est le reste exact de cette puissance. La réponse renvoie a et n en chaînes décimales, signale l’exposant n−1, le reste non négatif result, gcd comme la chaîne "1", un booléen congruent_to_one vrai exactement quand result vaut 1, et une courte expression que vous pouvez afficher à côté de la réponse. Contrôle classique avec un premier : a égal à 2 et n égal à 7 donne 2^6 mod 7 égal à 1, donc congruent_to_one est vrai. Sondage classique avec un composé : a égal à 2 et n égal à 15 donne 2^14 mod 15 égal à 4, donc congruent_to_one est faux—précisément le type de contre-exemple qui montre que a^(n−1) ≡ 1 n’est pas, à lui seul, un certificat de primalité.
Contrat d’entrée, erreurs et lecture de la réponse
Si n est inférieur à deux, la tâche échoue avec un message indiquant que le module doit être au moins deux. Si gcd(a, n) n’est pas un, la tâche échoue avec un message qui nomme le gcd—par exemple gcd(2, 4) égal à 2—afin que l’appelant sache que le couple sort de l’hypothèse de coprimalité plutôt que de deviner pourquoi la puissance n’a pas été calculée. Les bases négatives sont acceptées et réduites dans le système de résidus non négatifs modulo n avant l’élévation, ce qui correspond à l’arithmétique modulaire standard. Envoyez un corps JSON en POST avec deux champs entiers obligatoires : a (alias base) et n (alias modulus, mod). Chaque champ peut être un nombre JSON ou une chaîne d’entier décimal ; la forme chaîne est préférée lorsque les valeurs sortent de la plage d’entiers sûrs de JavaScript. Fractions, chaînes vides, jetons non numériques et valeurs de plus de soixante-quatre chiffres décimaux échouent avec invalid_input et ne sont jamais facturés. En cas de succès, chaque champ numérique du corps est une chaîne décimale sauf congruent_to_one, qui est un booléen, de sorte que les grands entiers circulent en JSON sans perte de précision. Associez ce vérificateur à un outil distinct de factorisation ou de primalité lorsque votre flux nécessite plus que le résidu de puissance ; cet endpoint ne répond qu’à a^(n−1) mod n sous la barrière de coprimalité pour garder l’intention SEO claire et la réponse minimale. Le tarif est un $0.002 fixe par requête réussie sur l’unité item ; une validation en échec ne consomme pas le solde prépayé.
Démos de cours, sondages composés et automatisation API
Les développeurs branchent l’API sur des tests de propriétés qui affirment a^(n−1) ≡ 1 pour des bases aléatoires coprimes à un module premier connu, ou sur des suites de régression qui figent des contre-exemples composés connus tels que 2^14 mod 15 égal à 4. Gardez a et n dans la limite de chiffres publiée, figez dans vos tests le result en chaîne et l’indicateur congruent_to_one, et vous obtenez des résidus reproductibles pour devoirs, plateformes de tutorat et edge workers sans déployer un système d’algèbre informatique complet.
Questions techniques
Que calcule ce vérificateur du petit théorème de Fermat ?
Étant donnés des entiers a et n avec n ≥ 2 et gcd(a,n)=1, il renvoie a^(n−1) mod n, et si ce reste vaut 1 (congruent_to_one).
Que se passe-t-il si n est composé ?
Le vérificateur calcule encore a^(n−1) mod n lorsque gcd(a,n)=1. congruent_to_one peut être vrai ou faux ; les cas faux sont des contre-exemples utiles en classe.
Combien coûte le vérificateur du petit théorème de Fermat ?
L’outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide n’est jamais facturée.