ForHosting KIT · Mathématiques

Vérificateur de nombre premier sûr

Vérifie si un premier p est sûr, c'est-à-dire si (p − 1)/2 est premier aussi : 23 est sûr car sa moitié, 11, est première, ce qui fait de 11 un premier de Sophie Germain. La moitié est toujours affichée, pour que vous la vérifiiez. 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

Puissance (W): 23

Vous obtenez

Q: 11

Le vérificateur de nombre premier sûr reçoit un entier premier p et détermine si la valeur associée q = (p − 1) / 2 est également première. Si les deux nombres sont premiers, p est un nombre premier sûr et q son nombre premier de Sophie Germain. Les entrées composées sont rejetées plutôt que marquées fausses, afin de respecter la définition et de rendre les erreurs visibles dans les traitements automatisés.

Comprendre la notion de nombre premier sûr

Un nombre premier sûr est un nombre premier p dont la valeur associée q = (p − 1) / 2 est elle aussi première. De manière équivalente, p s’écrit 2q + 1 avec q premier ; ce q plus petit est appelé nombre premier de Sophie Germain. Ainsi, 23 est sûr parce qu’il est premier et que son candidat moitié, 11, est également premier.

À l’inverse, 13 est premier mais pas sûr, car (13 − 1) / 2 vaut 6, un nombre composé. Ce vérificateur distingue clairement les deux tests. Il commence par valider la condition fournie par vous : p doit être premier.

Il calcule et teste q seulement ensuite. Le nombre premier exceptionnel 2 est accepté, mais il n’est pas sûr : son candidat est 0.5, qui n’est pas entier et ne peut donc pas être premier. Ce choix suit la définition sans limiter discrètement les entrées valides aux nombres premiers impairs.

Fonctionnement du contrôle déterministe

La capacité vérifie que p est un entier compris entre 2 et l’entier maximal représentable sans perte par JavaScript. Elle effectue ensuite un test exact de primalité avec l’arithmétique BigInt, des contrôles de divisibilité par de petits nombres premiers, l’exponentiation modulaire et un ensemble fixe de témoins Miller–Rabin, déterministe sur toute la plage admise. Des témoins fixes empêchent des appels identiques de suivre des chemins différents ou de fournir une réponse seulement probabiliste.

Pour un nombre premier impair valide, retirer un donne un entier pair : la division par deux est donc exacte. Le même test de primalité est appliqué à q et fournit la décision booléenne. Tous les calculs restent locaux, sans réseau, table externe, hasard ni horloge.

Les sorties numériques sont exactes, p et q étant limités aux nombres que JavaScript représente fidèlement.

Exploiter le résultat pour apprendre et développer

Utilisez ce vérificateur lorsque la vraie question porte sur la différence entre un nombre premier ordinaire et un nombre premier sûr. En cours de théorie des nombres, il illustre brièvement la relation du couple et expose q afin que les élèves puissent contrôler eux-mêmes le calcul. Pour créer des données de test, il valide un candidat choisi ailleurs avant son intégration à un exercice de protocole ou à un banc d’essai.

Cette capacité convient à la validation et à l’enseignement, mais elle ne génère pas de nombres premiers, ne factorise pas les composés, ne fournit pas de certificat portable et ne garantit aucune aptitude cryptographique. Les grands paramètres cryptographiques dépassent souvent la limite sûre et nécessitent des bibliothèques spécialisées ainsi qu’une revue du protocole.

Cas d’usage

Vérifier des exercices de théorie des nombres

Contrôlez un nombre premier sûr proposé et affichez le candidat de Sophie Germain correspondant afin d’examiner chaque partie de la définition.

Valider des jeux de données générés

Confirmez qu’un nombre premier choisi par un autre générateur déterministe est vraiment sûr avant de l’enregistrer dans des tests de protocole ou d’algorithme.

Distinguer les nombres premiers sûrs

Classez des valeurs déjà premières selon la primalité de leur candidat moitié, sans confondre une entrée composée avec un résultat négatif valide.

Questions fréquentes

Quel est le prix du vérificateur de nombre premier sûr ?

Le même contrôle déterministe peut être exécuté gratuitement dans l’interface du navigateur.

Pourquoi 23 est-il un nombre premier sûr ?

23 est premier et (23 − 1) / 2 vaut 11, qui est également premier.

Puis-je générer des nombres premiers sûrs cryptographiques ?

Non. L’outil vérifie seulement une valeur dans la plage des entiers sûrs ; il ne génère ni ne certifie de paramètres pour un protocole cryptographique.

Pourquoi 13 n'est-il pas un premier sûr ?

13 est premier, mais (13 − 1)/2 vaut 6, un nombre composé. Un premier sûr exige que les deux nombres soient premiers : la réponse est donc non, même si le nombre saisi est premier.

Que se passe-t-il si je saisis un nombre non premier ?

Il est refusé avec un message plutôt qu'un simple non, car un nombre composé ne peut pas être un premier sûr. Corrigez le nombre et réessayez, sans y voir un résultat négatif.

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/safe-prime

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

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

import os, requests

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

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

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

{
  "p": 23
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "numth.safe_prime",
  "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 résultat renvoie p, la valeur q calculée et le booléen explicite safe_prime.

Comprendre la notion de nombre premier sûr

La réponse rappelle p, indique q et attribue à safe_prime la valeur vraie ou fausse ; vous n’avez donc pas à recalculer la valeur intermédiaire.

Fonctionnement du contrôle déterministe

Une même entrée produit toujours le même résultat JSON. Si p est composé, le traitement s’arrête avec une erreur invalid_input qui désigne la condition non respectée ; safe_prime n’est pas renvoyé comme faux, car cela laisserait croire à tort qu’un composé est un nombre premier non sûr.

Exploiter le résultat pour apprendre et développer

Dans une application, considérez invalid_input comme une donnée à corriger, non comme un résultat négatif ni comme une panne temporaire à relancer. Une réponse réussie avec safe_prime faux signifie que p a réussi le test de primalité, contrairement à q ; une valeur vraie signifie que les deux l’ont réussi. La même implémentation fonctionne gratuitement dans le navigateur et via l’API à $0.002 par requête, avec exactement les mêmes règles.

Questions techniques

Que se passe-t-il si p est composé ?

La requête renvoie invalid_input, car un nombre premier sûr exige que p soit premier. Elle ne renvoie pas safe_prime faux pour une entrée composée.

2 est-il considéré comme un nombre premier sûr ?

Non. Même si 2 est premier, (2 − 1) / 2 vaut 0.5, qui n’est pas un entier premier ; safe_prime est donc faux.

Consulter la documentation complète du KIT →

Lancer gratuitement

Exemple résolu

Comprendre la notion de nombre premier sûr

Fonctionnement du contrôle déterministe

Exploiter le résultat pour apprendre et développer

Cas d’usage

Vérifier des exercices de théorie des nombres

Valider des jeux de données générés

Distinguer les nombres premiers sûrs

Questions fréquentes

Outils associés

Pour les développeurs — accès API

Endpoint

Appeler depuis votre stack

Exemple de requête

Exemple de réponse

Tarifs

Erreurs

Notes techniques

Comprendre la notion de nombre premier sûr

Fonctionnement du contrôle déterministe

Exploiter le résultat pour apprendre et développer

Questions techniques

merci