mais ca me renvoit des résultats pas très claire  j'ai l'impression que quand je compile ca ne fait pas les instruction de la boucle ca prend à chaque fois le premier i

OOOHHH LALA !!! Je raconte des bêtises!!  oubliez   désolé , je pense qu'il me faut déjà faire intervenir la fonction phi d'Euler pour ,bof je me m'y met

salut

je suppose que primalité (p) renvoie True si p est premier

ensuite tu parles donc d'un générateur du groupe multiplicatif (Z/pZ*, x)

il me semble que pour tout p <> 2 alors 2 convient ...

carpediem Bonsoir , effectivement True si p premier  , par-contre je comprend pas comme vous dite 2 convient ?  j'étais en train de chercher une solution depuis ,.

vous voulez dire que je dois mettre  ca comme condition ?

pour tout p<>2 and p<>2i ?

ou je comprend pas votre idée

il me semble que tout élément autre que le neutre est un générateur de (Z/pZ*, x) lorsque p est premier ...puisque ce groupe est cyclique ...

oui du coup en machine ma boucle si je la parcourt pour i range(2,p) la fonction va immédiatement me renvoyer 2 si j'exclus 2 et je commence à 3 elle  va me renvoyer 3 ect ,

Je suis un peu perdu pour le coup

Bonsoir,
ton programme ne fait pas du tout ce que tu veux : il renvoie toujours 2 si p est premier, mais 2 n'est pas toujours un générateur de , même si p est premier.

Je ne sais pas si tu veux la liste des générateurs ou seulement un générateur.

Disons que j'écrirais une fonction est_generateur(a,p) qui suppose p premier, il faut donc faire le test avant de l'utiliser.

def est_generateur(a,p):
	b=a%p
        if b==0 : 
                return False
	for i in range(1,p-1):
		if b==1 :
			return False
		b=b*a%p
	return True

J'ai mis un peu trop de temps à taper mon message : je fais autre chose en même temps.
Mais tous les éléments d'un groupe cyclique ne sont pas forcément des générateurs de ce groupe, et je ne parle pas que de l'élément neutre.

effectivement !!

merci verdurin

Bonsoir verdurin merci pour votre intervention .J'ai bien du mal à comprendre pourquoi votre fonction prend 2 paramètre , je croyais qu'il devais juste contenir P et l'objectif est que ca nous revoit a^(p-1)=1mod(p) pour p premier , mais dans ce cas a appartient à (Z/pZ,x)* ;

pour répondre à votre questions , c'est un générateur qu'on cherche

c'est justement pas de vérifier que c'est un générateur , mais chercher un générateur ,

ahhhh oui pardon j'ai totalement compris ce que vous me proposez , en fait le programme n'est pas fini , ok je complète et je vous montre , merci verdurin

je pense que il y'a une  coquille c'est plutôt  if i==1

plutôt ça ?

def est_generateur(a,p):
    	b=a%p
        if b==0 : 
                return False
	for b in range(1,p-1):
		if b==1 :
			return False
		b=b*a%p
	return True

j'ai du mal par contre à comprendre ceci  , certainement que sans les parenthèses  ne m'aide pas

b=b*a%p

Pour trouver un générateur la méthode la plus simple est de prendre la liste des candidats (tous les éléments sauf l'élément neutre ) puis de la parcourir pour voir si le candidat est générateur ou non.

Sinon as tu testé ta fonction et la mienne ?
Elles sont vraiment différentes.

Et si j'ose donner un conseil :
il est dangereux de modifier l'indice de la boucle dans la boucle.

J'ai pour cela un programme qui me renvoi sous forme de liste tout les candidats c'est à dire les je peux l'utiliser ici pour ensuite parcourir la liste ?

verdurin très bien pour votre remarque c'est notée merci

Pour répondre à ceci

AAAAAHHHHH oui bien merci monsieur wou la j'ai pas vu ça sous cette angle merci

Pour faire un peu de math :
on sait que le groupe est un groupe cyclique à 12 éléments.
Il est donc isomorphe à .
On a donc un sous-groupe à deux éléments, un sous-groupe à trois éléments, un sous-groupe à quatre éléments et un sous-groupe à six éléments.
Les générateurs sont les éléments qui ne sont dans aucun de ces sous-groupes.
Sauf erreur de ma part il y en a trois.

oui je comprend , mais votre programme il me semble que je dois le compléter du coup ? il me sert juste à trouver les potentiels candidats c'est ca ?
,

Oui.
Il faut l'adapter à votre problème.

_{PS :
en principe on se tutoie sur le forum, en gros on est égaux ici.}

daccord cest noté merci à toi , je fini ensuite je te montre .

from TestPrimalite import primalite
from test import est_generateur
def Generateur (p):
    k=primalite(p)
    for a in range (1,p-1):
     if Estgenerateur(a,p) is True and k is True :
            return a
    

plutôt

rom TestPrimalite import primalite
from test import est_generateur
def Generateur (p):
    k=primalite(p)
    for a in range (1,p-1):
     if est_generateur(a,p) is True and k is True :
            return a
    

Misère.

quand j'ai copier ça pas respecté les tabulation , de toute façons ça n'a pas l'air juste tout ça , je sais pas comment  ça m'embête autant ,

En effet ce que tu as écrit n'est pas juste.
Mais on peut corriger des erreurs.
Le problème est que ce que tu as écrit n'a pas de sens. Et ça ne vient pas des indentations, ni même de langage.
Il faut avoir une idée précise de ce qu'on veut faire avant d'écrire du code.

Il est judicieux de tester les fonctions que l'on écrit.

Il est inutile de créer un module par fonction : from test import est_generateur me semble douteux.

Je crois que tu devrais faire un programme un peu plus abstrait, c'est à dire sans t'attacher aux spécificités du langage.

En particulier il est totalement inutile de tester la primalité de p à chaque itération.

Je ne saurais trop te recommander de penser avant d'écrire.
Et de tester les fonctions que tu écris.