ForHosting KIT · Mathématiques

Preuve par neuf

La preuve par neuf contrôle une somme ou un produit en quelques secondes : un total annoncé de 579 laisse un reste de 3 modulo 9, comme les restes 6 et 6 de ses termes combinés, donc il passe. Un désaccord prouve l’erreur. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

Opérandes: 123, 456
Résultat annoncé: 579
Opération: Sum

Vous obtenez

Restes des opérandes: 6, 6
Reste combiné: 3
Reste annoncé: 3
Vérification: casting_out_nines

La preuve par neuf est un contrôle arithmétique classique qui utilise la congruence modulo neuf pour détecter les erreurs d’addition et de multiplication sans refaire chaque chiffre à la main. Avec au moins deux opérandes entiers, un résultat affirmé et un indicateur d’opération, cette capacité réduit chaque nombre à sa classe de résidu modulo neuf, combine ces résidus comme le ferait l’opération d’origine, puis compare le résultat au résidu de l’affirmation. Lorsque les deux côtés divergent, la réponse affirmée est certainement fausse. Lorsqu’ils coïncident, l’affirmation n’est que cohérente avec l’arithmétique modulaire : une transposition ou une erreur multiple de neuf peut encore se cacher.

Ce que signifie la preuve par neuf et pourquoi le modulo 9 fonctionne

Tout entier est congruent à la somme de ses chiffres décimaux modulo neuf, car dix est congruent à un modulo neuf et les puissances supérieures de dix se réduisent de la même façon. Répéter la somme des chiffres jusqu’à un seul chiffre produit la racine numérique, qui coïncide avec le résidu modulo neuf sauf que les multiples de neuf se mappent à neuf plutôt qu’à zéro lorsque le nombre est non nul. La preuve par neuf utilise cette congruence comme somme de contrôle arithmétique.

Si vous additionnez plusieurs nombres, le résidu du total vrai doit égaler la somme des résidus des termes, reprise modulo neuf. Si vous multipliez, le résidu du produit vrai doit égaler le produit des résidus des facteurs, encore modulo neuf. Un écart est décisif : aucun total correct ne peut contredire les résidus combinés de ses opérandes.

L’accord n’est pas décisif : vous pouvez encore vous tromper de neuf, dix-huit ou de tout multiple de neuf, ou permuter des chiffres qui préservent la somme des chiffres, et le contrôle modulaire passera quand même. Cette limite est précisément pourquoi les manuels présentent la preuve par neuf comme un filtre rapide plutôt qu’une preuve complète. Ce point de terminaison renvoie les deux résidus et un booléen passes afin que les apprenants voient explicitement la comparaison modulaire au lieu d’entendre seulement que les neufs ont été écartés.

Les résidus sont indiqués dans l’ensemble fermé de zéro à huit pour que les entiers signés et zéro aient une représentation uniforme ; le contenu mathématique est le même que le rejet classique par somme de chiffres.

Cas d’usage

Démonstrations d’arithmétique modulaire en classe

Montrez aux élèves les réussites et échecs en direct pour des sommes et des produits tout en enseignant sommes de chiffres, racines numériques et congruence modulo neuf.

Filtrage des réponses pour devoirs et concours

Rejetez les additions ou multiplications manifestement fausses qui échouent à la preuve par neuf avant d’y consacrer une réévaluation complète.

Contrôles légers de grand livre et d’inventaire

Filtrez totaux et produits multi-opérandes avec un contrôle déterministe modulo 9 dans des scripts qui ont besoin d’un filtre de cohérence peu coûteux.

Questions fréquentes

Comment vérifier une somme avec la preuve par neuf ?

La réponse compare la somme des résidus modulo 9 au résidu affirmé et fixe passes en conséquence.

Comment vérifier un produit ?

Les résidus sont multipliés modulo 9 et comparés au résidu affirmé.

Que se passe-t-il si j’envoie moins de deux opérandes ?

La preuve par neuf sur un résultat multi-opérandes affirmé exige au moins deux opérandes.

Un contrôle réussi prouve-t-il que la réponse est correcte ?

Non. L’accord ne montre que la cohérence modulo 9. Des erreurs multiples de neuf ou des permutations de chiffres qui préservent le résidu peuvent encore réussir. Un échec prouve que l’affirmation est fausse.

Pourquoi la preuve par neuf fonctionne-t-elle ?

Parce que 10 donne un reste de 1 quand on le divise par 9, tout nombre entier a le même reste modulo 9 que la somme de ses chiffres. Les restes des termes ou des facteurs doivent donc se combiner en celui du résultat juste.

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

POSThttps://api.kit.forhosting.com/numth/casting-out-nines

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/casting-out-nines \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"operands":[123,456],"claimed":579,"operation":"sum"}'

const res = await fetch("https://api.kit.forhosting.com/numth/casting-out-nines", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "operands": [
      123,
      456
    ],
    "claimed": 579,
    "operation": "sum"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/numth/casting-out-nines",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "operands": [
        123,
        456
    ],
    "claimed": 579,
    "operation": "sum"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/casting-out-nines", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"operands":[123,456],"claimed":579,"operation":"sum"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"operands":[123,456],"claimed":579,"operation":"sum"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/casting-out-nines", 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

{
  "operands": [
    123,
    456
  ],
  "claimed": 579,
  "operation": "sum"
}

Exemple de réponse

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

par requête$0.002

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

Le moteur est pur et déterministe, s’exécute gratuitement dans le navigateur pour les démonstrations pédagogiques, et coûte $0.002 par élément API réussi lorsque vous avez besoin du même contrôle depuis des scripts, des correcteurs ou des aides aux devoirs.

Contrat d’entrée, forme de la réponse et modes d’échec

Le champ claimed est le résultat entier que vous affirmez pour ces opérandes. Les mêmes opérandes avec claimed cinq cent soixante-dix-huit échouent car cinq cent soixante-dix-huit est congruent à deux modulo neuf. Un exemple de produit est sept fois huit affirmé comme cinquante-six : les résidus sept et huit se multiplient à deux modulo neuf, ce qui correspond à cinquante-six. Moins de deux opérandes échoue toujours avant tout travail modulaire, conformément au contrat publié selon lequel les contrôles multi-opérandes exigent au moins une paire. Envoyez un objet JSON avec trois éléments obligatoires. Le champ operands est un tableau d’au moins deux entiers sûrs finis ; moins de deux opérandes échoue avec invalid_input car la preuve par neuf a besoin d’une affirmation multi-opérandes à vérifier. Le champ operation est l’enum sum ou product pour que le moteur sache s’il doit additionner ou multiplier les résidus. Les alias numbers, values et terms sont acceptés pour la liste d’opérandes ; result et total pour l’affirmation ; op et mode pour l’opération. Les non-entiers, champs manquants, tableaux vides, tableaux d’un seul élément et valeurs hors de la plage des entiers sûrs échouent avec invalid_input et ne sont pas facturés. En cas de succès, la réponse reprend operation, operands et claimed, puis liste operand_residues, combined_residue, claimed_residue, un booléen passes, l’étiquette fixe de contrôle casting_out_nines et une courte note qui explique si la coïncidence ne montre que la cohérence ou si l’écart prouve l’erreur. Exemple : opérandes cent vingt-trois et quatre cent cinquante-six avec claimed cinq cent soixante-dix-neuf et operation sum produisent les résidus six et six, résidu combiné trois, résidu affirmé trois et passes true.

Où une API de preuve par neuf apporte une vraie valeur

Les classes qui enseignent les règles de divisibilité et l’arithmétique modulaire utilisent la preuve par neuf comme premier checksum pratique que les élèves peuvent appliquer à la main ; un oracle automatisé permet aux tuteurs de montrer en direct les échecs lorsqu’une réponse décalée d’une unité contredit le modulo neuf. Les coachs de concours et les plateformes de devoirs peuvent filtrer les réponses candidates avant une réévaluation complète, en capturant à peu de frais de nombreuses erreurs d’addition et de multiplication. Associez-la à un calculateur de racine numérique lorsque vous n’avez besoin que du résidu d’un seul nombre, et à des outils arithmétiques complets lorsque vous avez besoin de la somme ou du produit exacts plutôt que d’un contrôle de cohérence modulaire. Les carnets d’ingénierie qui contrôlent des totaux de grand livre ou des multiplications d’inventaire veulent parfois un filtre modulaire léger avant une réconciliation plus lourde ; cette capacité reste dans les entiers sûrs et renvoie une forme JSON stable pour les tests. Comme l’implémentation est parse de niveau A, chaque appel réussi coûte le prix de base publié $0.002 sans jetons de modèle ni réseau sortant, et les échecs de validation ne consomment pas de solde.

Questions techniques

Combien coûte le contrôle par preuve par neuf ?

L’outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par élément réussi ; une entrée invalide n’est pas facturée.

Consulter la documentation complète du KIT →

Lancer gratuitement