Théorème de Lucas
Obtenez C(n, k) modulo un nombre premier sans factorielles géantes : C(1000, 200) modulo 7 vaut 1, en écrivant les deux nombres en base 7 et en multipliant de petits binomiaux de leurs chiffres. Les chiffres sont affichés pour contrôler chaque étape. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- N
- 1 000
- K
- 200
- Puissance (W)
- 7
- Résultat
- 1
- Chiffres de n
- 6, 2, 6, 2
- Chiffres de k
- 4, 0, 4, 0
Le théorème de Lucas est la méthode classique pour évaluer un coefficient binomial modulo un nombre premier lorsque n est assez grand pour rendre la factorielle de n impraticable. Le produit est exactement C(n, k) mod p ; si un chiffre inférieur dépasse le chiffre supérieur correspondant, la valeur entière est nulle. La programmation de concours, la théorie des nombres combinatoire et les devoirs de cryptographie ont besoin de cette réduction lorsque les factorielles directes débordent ou coûtent trop cher.
Ce que dit le théorème de Lucas et quand vous en avez besoin
En combinatoire élémentaire le coefficient binomial C(n, k) compte les sous-ensembles à k éléments d’un ensemble à n éléments et vaut la factorielle de n divisée par la factorielle de k fois la factorielle de (n moins k). Cette forme close devient inutile dès que n dépasse quelques milliers si vous ne voulez que la réponse modulo un petit premier : les factorielles intermédiaires explosent et les approximations en virgule flottante perdent le résidu exact. Le théorème de Lucas, nommé d’après Édouard Lucas, résout précisément ce problème modulaire.
Chaque facteur utilise des arguments plus petits que p, ce qui permet un court boucle multiplicative et des inverses modulaires qui existent parce que p est premier et chaque dénominateur est inférieur à p. Ce seul test répond à de nombreuses questions du type « le binomial est-il divisible par ce premier ? » sans calculer un produit complet.
Le théorème exige que p soit premier ; pour des modules composites le même produit de chiffres n’est en général pas valide, et cette capacité refuse délibérément un p non premier plutôt que de renvoyer silencieusement un mauvais résidu. Les étudiants qui rencontrent le théorème dans du matériel d’olympiades, les développeurs qui branchent des bibliothèques de programmation compétitive et les enseignants qui préparent des laboratoires d’arithmétique modulaire bénéficient d’une seule fonction déterministe qui impose l’hypothèse de primalité et expose les développements de chiffres utilisés dans la preuve.
Comment ce calculateur applique le théorème de Lucas étape par étape
Appelez la capacité avec les champs entiers n, k et p. n et k doivent être des entiers non négatifs d’au plus un billion ; p doit être un premier entre deux et un million trois inclus. L’implémentation valide d’abord les types et les bornes, puis exécute un test de primalité par division d’essai déterministe sur p. Lorsque p est accepté, le solveur parcourt les chiffres en base p de n et k du moins significatif au plus significatif.
Chaque petit binomial utilise la formule multiplicative avec des inverses modulaires via le petit théorème de Fermat (a à la puissance p moins deux modulo p), implémentée avec des produits intermédiaires exacts en BigInt afin de ne perdre aucune précision dans les bornes publiées.
Les cas limites sont stables et documentés : lorsque k vaut zéro ou égale n le résultat est un modulo p (ou zéro seulement si p vaut un, ce qui est rejeté) ; lorsque k dépasse n le résultat est zéro ; lorsque n et k sont tous deux nuls les tableaux de chiffres sont le seul chiffre zéro et le résultat est un modulo p.
Usage pratique, limites, tarification et livraison
Utilisez l’outil navigateur lorsque vous voulez une vérification rapide de Lucas en lisant une note de théorie des nombres, en validant un exemple de concours ou en déboguant une routine de combinatoire modulaire. Les entrées acceptées sont des entiers non négatifs n et k jusqu’à un billion et des premiers p de deux à un million trois.
Branchez le point de terminaison à des aides d’olympiades, des bacs à sable de programmation compétitive, des démonstrations pédagogiques de cryptographie touchant les coefficients binomiaux modulo de petits premiers, ou tout pipeline d’entiers qui préfère l’arithmétique modulaire exacte aux bibliothèques approximatives.
Si vous avez besoin du C(n, k) entier sans restriction, d’une ligne binomiale pour tout k, ou de binomiaux modulaires pour des modules composites via le théorème chinois des restes, utilisez une capacité dédiée ; cet outil s’arrête délibérément à Lucas pour un premier p vérifié afin que le contrat reste simple et auditable.
Cas d’usage
Programmation de concours et pratique d’olympiades
Les programmeurs compétitifs peuvent vérifier C(n, k) mod p pour de grands n face à des cas d’exemple et voir une erreur explicite lorsqu’un module est composite par accident.
Laboratoires de théorie des nombres et de combinatoire
Enseignants et étudiants peuvent inspecter les chiffres en base p à côté du produit modulaire tout en apprenant le théorème de Lucas et le test de zéro par divisibilité par un premier.
Questions fréquentes
Que se passe-t-il si p n’est pas premier ?
Le message indique que p doit être un premier (par exemple lorsque p est composite ou égal à 1). L’échec de validation n’est pas facturé.
Quel algorithme calcule le binomial modulaire ?
Les petits binomiaux de chiffres utilisent la formule multiplicative avec inverses modulaires.
Quelles plages de n, k et p sont acceptées ?
n et k doivent être des entiers non négatifs d’au plus 1,000,000,000,000. p doit être un premier de 2 à 1,000,003. Les valeurs hors de ces limites, ou un p composite, sont rejetées.
Comment savoir si C(n, k) est divisible par un nombre premier ?
Écrivez n et k en base p et comparez-les chiffre par chiffre. Si un chiffre de k dépasse le chiffre correspondant de n, le résultat vaut 0 : p divise alors le coefficient binomial.
Que donne C(1000, 200) modulo 7 ?
Le résultat est 1. L'outil affiche aussi les chiffres en base 7, du plus faible au plus fort : 6, 2, 6, 2 pour 1000 et 4, 0, 4, 0 pour 200. Aucun chiffre de 200 ne dépasse celui de 1000.
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/lucas-theorem-binomial \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":1000,"k":200,"p":7}'const res = await fetch("https://api.kit.forhosting.com/numth/lucas-theorem-binomial", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 1000,
"k": 200,
"p": 7
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/lucas-theorem-binomial",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 1000,
"k": 200,
"p": 7
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/lucas-theorem-binomial", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":1000,"k":200,"p":7}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":1000,"k":200,"p":7}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/lucas-theorem-binomial", 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
{
"n": 1000,
"k": 200,
"p": 7
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.lucas_theorem_binomial",
"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
Étant donnés des entiers non négatifs n et k et un module premier p, le théorème développe n et k en base p et multiplie les binomiaux de chiffres C(n_i, k_i) modulo p. Ce calculateur accepte n, k et p, rejette les modules composites avec une erreur invalid_input claire, exécute une marche de Lucas déterministe et renvoie le résultat modulaire avec les chiffres en base p afin que vous puissiez auditer chaque étape sans redériver le développement à la main.
Ce que dit le théorème de Lucas et quand vous en avez besoin
Écrivez n et k en base p comme suites de chiffres n_i et k_i, chaque chiffre strictement inférieur à p. Alors C(n, k) est congruent modulo p au produit sur i de C(n_i, k_i). Un corollaire crucial est le test de zéro : si à une position le chiffre inférieur k_i est supérieur à n_i, ce binomial de chiffre est nul et donc C(n, k) est divisible par p.
Comment ce calculateur applique le théorème de Lucas étape par étape
Les valeurs composites, un, zéro et les négatifs échouent avec invalid_input et un message qui nomme p ; ces échecs ne sont pas facturés. Pour chaque paire (n_i, k_i) il coupe à zéro si k_i dépasse n_i, ou multiplie le produit courant par C(n_i, k_i) mod p. La réponse renvoie n, k, p, result (le résidu de zéro à p moins un), is_zero, les tableaux n_digits et k_digits en ordre du chiffre le moins significatif d’abord, et method égal à la chaîne lucas.
Usage pratique, limites, tarification et livraison
Utilisez l’API lorsqu’un correcteur, une plateforme pédagogique ou un script a besoin de nombreuses évaluations de C(n, k) mod p sans intégrer une porte de primalité et une marche de chiffres. Chaque requête réussie est un élément facturable à $0.002 ; les échecs de validation et les modules non premiers ne consomment pas de solde. Les résultats sont déterministes : le même triplet produit toujours le même résidu, les mêmes tableaux de chiffres et le même indicateur is_zero. Comme l’unité est un seul élément et le moteur est parse pur, la latence reste faible et le canal web gratuit reflète l’API payante sans un second chemin de code qui pourrait diverger.
Cas d'intégration
Correcteurs de devoirs et pipelines modulaires
Les correcteurs automatiques et les scripts peuvent confirmer les résidus, détecter un p non premier via invalid_input et garder chaque produit intermédiaire dans les bornes documentées.
Questions techniques
Comment calculer C(n,k) mod p avec cette API ?
Envoyez un JSON avec les champs entiers n, k et p (p premier) à numth.lucas_theorem_binomial. En cas de succès la réponse renvoie result dans 0..p−1, is_zero, les tableaux de chiffres en base p et method "lucas".
Le calculateur du théorème de Lucas est-il gratuit ?
L’outil navigateur s’exécute gratuitement sur votre appareil. Les appels API utilisent un solde KIT prépayé à $0.002 par élément réussi ; les entrées invalides et les modules non premiers ne sont pas facturés.