Corrigé entrée Septembre 2019

QUESTION 1.1
tous les mots de Lukasiewicz de longueur ≤ 3 sont :

• [-1]

• [1,-1,-1]

QUESTION 1.2
Supposons qu’il existe un mot de Lukasiewicz u de taille paire.
Puisque le mot est de Lukasiewicz alors p(u)=-1, ce qui veut dire que si le nombre de 1 dans
le mot est N, alors le nombre de -1 est N+1 nécessairement,alors le mot serait de taille 2N+1, en
d’autres termes de taille impaire, ce qui contredit le fait que u est de taille paire

QUESTION 1.3
[1]: def estLukasiewicz(u):
s=0
n=len(u)
for e in u[:n-1]:
s+=e
if s<0:
return False
s+=u[n-1]
if s==-1:
return True
else :
return False
le coût des lignes 2,3,5, 8 et 9 est O(1)
Donc le coût total est O(1)+O(1) + Σin=−02 O(1) + O(1) = O(n)

Remarque: il suffit de répondre que le coût est O(n) sans justification la réponse sera considérée
juste
QUESTION 1.4
Soit u et v deux mots de Lukasiewicz de taille respectivement N et M, Montons que (+1).u.v est
un mot de Lukasiewicz
*) On a p((+1).u.v) = 1+p(u)+p(v) = 1-1-1=-1, donc la première propriété est vraie
*) Soit w un préfixe strict du mot (+1).u.v:

• 1er cas : w= (+1), On a p(w) =1 ≥ 0

• 2ème cas : w=(+1)u’ tel que u’ préfixe strict de u alors puisque u est un mot de Lukasiewicz
p(u’)≥ 0 donc p(w) =1+p(u’) ≥ 0

1
 • 3ème cas : w=(+1)u alors p(w) =1-1=0 ≥ 0
• 4ème cas : w=(+1)uv’ tel que v’ préfixe strict de v alors puisque v est un mot de Lukasiewicz
p(v’)≥ 0 donc p(w) =1-1+p(v’) =p(v’)≥ 0

Donc dans tous les cas la 2ème propriété est vérifiée,

D’où (+1).u.v est un mot de Lukasiewicz

QUESTION 1.5
Soit un mot (w = w1 ...wn ) de Lukasiewicz de longueur supérieure ou égale à 3
Montrons qu’il admet une décomposition unique de la forme (+1).u.v, où u et v sont des mots
de Lukasiewicz.
Puisque w est un mot de Lukasiewicz, alors certainement il s’écrit sous la forme (+1).w0 car
sinon s’il s’ecrit sous la forme (-1).w0 alors il ne sera pas un mot de Lukasiewicz puisque le préfixe
strict (-1) ne respectera la propriété que tout préfixe strict son poids doit être supérieure ou égale
à0
et aussi certainement il existe un préfixe strict w0 de w0 tel que p(w0 ) =-1 car sinon s’il n’existe
tel préfixe vérifiant ceci, puisque w0 est préfixe strict de w0 alors (+1)w0 est préfixe strict de w et
comme w de Lukasiewicz donc p((+1).w0 ) ≥ 0 càd 1 + p(w0 ) ≥ 0, d’où p(w0 ) ≥ −1 > 0, donc
même si w_n sera égale à (1) alors p(w) sera supérieure ou égale à 0 ,contradiction car il devrait
être égale à -1 parce w est un mot de Lukasiewicz, d’où l’existence d’un tel préfixe strict w0 de w0
tel que p(w0 ) =-1
Considérons u le plus préfixe strict de w0 tel que p(u) = −1, et soit v tel que w = (+1)u.v et
montrons que u et v sont des mots de Lukasiewicz
Commençons par u :

• u vérifie la première propriété p(u) = −1

• soit u’ un préfixe strict de u alors (+1).u est préfixe de w, donc p((+1).u0 ) ≥ 0, càd p(u0 ) ≥
−1, mais p(u’) ne peut pas être égale à -1 car ça sera une contradicition avec ce qu’on a
supposé et il sera le plus petit préfixe strict de w0 tel que sons égale -1, donc p(u’) ≥ 0,

D’où on conclut que u est un mot de Lukasiewicz

Maintenant montrons que v est un mot de Lukasiewicz:

• On a p(w) = p((+1).v.w = 1 + p(u) + p(v) alors p(v) = p(w) − 1 − p(u) = −1 − 1 −

(−1) = −1
• soit v’ un préfixe strict de v alors (+1).u.v’ est préfixe de w, donc p((+1).u.v0 ) ≥ 0, alors
1 + p(u) + p(v0 ) = 1 − 1 + p(v0 ) = p(v0 ) ≥ 0

D’où on conclut que v est un mot de Lukasiewicz

Montrons maintenant l’unicité
Supposons que w admet deux décompositions différentes (+1).u.v et (+1).u0 .v0 tels que u,u’,v
et v’ sont des mots de Lukasiewicz
Alors on a deux cas soit u est préfixe strict de u’ ou bien u’ préfixe strict de u
Supposons par exemple que u est préfixe strict u’, alors comme u’ est un mot de Lukasiewicz
p(u) ≥ 0 et comme u est un mot de Lukasiewicz p(u) = −1, donc −1 ≥ 0 contradiction
De la même manière on montre que u’ ne peut pas être préfixe de u,
D’où l’unicité de la décompostion

2
 QUESTION 1.6
[1]: #solution 1

def decompose(w):
n=len(w)
for i in range(2,n):
if estLukasiewicz(w[1:i])==True:
return w[1:i],w[i:]

#solution2

def decompose(w):
n=len(w)
s=0
for i in range(1,n):
s+=w[i]
if s==-1:
return w[1:i+1],w[i+1:]

QUESTION 1.7
On essaiera d’exploiter le fait que si u et v sont des mots de Lukasiewicz alors (+1).u.v sera un mot
de Lukasiewicz d’après la question 1.4, donc pour chercher les mots de Lukasiewicz de taille n il
suffit de chercher de le précéder par un (+1) et chercher les mot de taile k et n-1-k et concaténer
toutes les possibilités
[2]: def Luka_rec(n):
if n==1:
return [[-1]]
L=[]
for k in range(1,n-1,2):
L1=Luka_rec(k)
L2=Luka_rec(n-1-k)
for u in L1:
for v in L2:
L.append([1]+u+v)
return L

QUESTION 1.8
Le problème avec la fonction récursive Luka_rec c’est qu’elle fait des calculs redondants ce qui
rend la complexité exponentiel , par exemple pour n=9 on besoin de trouver par exemple les mots
de taille 3 et de taille 5, et à son tour pour trouver les mots de taille 5 on a besoin de trouver par
exemple les mots de taille 3 et de taille 1, donc les mots de taille de 3 on va les calculer 2 fois,
imaginez si n est grand

3
 QUESTION 1.9
la solution est de mémoriser les calculs faits ainsi avant de calculer des mots d’une taille donée on
vérifie si on a déjà effectué les calculs, si oui on a pas besoin de recalculer.
[3]: dico={1:[[-1]]}
def Luka_rec_PD(n):
if n==1:
return dico[n]
L=[]
for k in range(1,n-1,2):
if k in dico:
L1=dico[k]
else:
L1=Luka_rec(k)
dico[k]=L1
if n-1-k in dico:
L2=dico[n-1-k]
else:
dico[n-1-k]=Luka_rec(n-1-k)
L2=dico[n-1-k]
for u in L1:
for v in L2:
L.append([1]+u+v)
return L

QUESTION 1.10
[4]: def conjugue_1(u):
for i in range(len(u)):
if estLukasiewicz(u[i+1:]+u[:i+1]):
return u[i+1:]+u[:i+1]

QUESTION 1.11
[ ]: def conjugue_2(u):
n=len(u)
min=n+1
p=-1
s=0
for i in range(n):
s+=u[i]
if s<min:
min=s
p=i
return u[p+1:]+u[:p+1]

4
 QUESTION 1.12
Soit un mot u de Lukasiewicz tel que |u| = n
pour la fonction conjugue_1 la boucle for fait O(n) itérations au pire des cas et la coût de la
fonction estLukasiewicz est O(n) donc le coût total est de O(n)xO(n)=O(n2 )
pour la fonction conjugue_2 la boucle for fait O(n) itérations pour chercher l’indice tel que la
somme soit minimale puis après le return a un coût de O(n) le coût de la concaténation donc le
coût total est O(n)+O(n)=O(n)
D’où on conclut que conjugue_2 est plus efficace que conjugue_1

QUESTION 1.13
[ ]: def rho(u):
n=len(u)
for i in range(n-2):
if u[i:i+3]==[1,-1,-1]:
return u[:i]+u[i+2:]
return u

QUESTION 1.14
[ ]: def rholim(u):
v=rho(u)
while(u!=v):
u=v
v=rho(u)
return v

QUESTION 1.15
Montrons que tout mot de Lukasiewicz de longueur ≥ 3 contient au moins une capsule.
Procédons par récurrence
cas de base : pour n =3, le seul mot de Lukasiewicz de longueur 3 est [+1,-1,-1] et il se voit bien
qu’il contient une capsule
induction: Supposons que le propriété est vraie tous les mots de Lukasiewicz de longueur
3 ≤ k ≤ n tel que n est impair
Soit un mot w de Lukasiewicz de taille n+2 ( il ne peut pas exister un mot de Lukasiewicz de
taille n+1 car n+1 est pair et d’après la question 1.2 il n’existe aucun mot de taille paire)
D’après la question 1.5 w une décomposition unique de la forme (+1).u.v, où u et v sont des
mots de Lukasiewicz.
Et certainement l’un des mots u et v, sa taille est comprise entre 3 et n, alors d’après l’hypothèse
de récurrence il contient une capsule
donc le mot w contient une capsule

5
QUESTION 1.16 :
Soit u = [u1 , ..., un ]

• cas 1 : Si ρ(u) = u, alors l’équivalence est évidente

• cas 2 : Si ρ(u) = [u_1, . . . u_{i − 1}, u_{i + 2}, . . . , u_n]

Supposons que u est un mot de Lukasiewicz

*) p(ρ(u)) = p([u1 , ...ui−1 , ui+2 , ..., un ]) = p(u) − p(ui ) − p(ui+1 ) = −1 − 1 − (−1) = −1, donc
la première propriété est vérifiée
*) soit u’ un préfixe strict de p(ρ(u)),

• si |u’|<i, alors u’ est préfixe strict aussi de u donc p(u’)≥ 0

• sinon donc u’=[u1 , ...ui−1 , ui+2 , ..., uk ], soit u“= [u1 , ..., uk ], u” est préfixe strict de u alors
p(u“)≥ 0 et on a p(u’)=p(u”)-p(ui )-p(ui+1 )=p(u“)-1-(-1)=p(u”), donc p(u’)≥ 0

Alors la deuxième propriété est vérifiée

D’où on conclut que ρ(u) est un mot de Lukasiewicz
La réciproque se montre de la même manière

QUESTION 1.17 :
Soit u Soit un mot de Lukasiewicz avec |u| > 3. Alors ρ(u) un mot de Lukasiewicz d’après la
question 1.16 et |ρ(u)| < |u| puisque u contient une capsule d’après la question 1.15. Il en découle
immédiatement que ρ(u)∗ (u) = 1 et que ρ(u)∗ (u) est un mot de Lukasiewicz, et le seul mot de
Lukasiewicz de taille 1 est [-1] donc ρ(u)∗ (u) = [ − 1]
Réciproquement,
Soit désormais u tel que ρ(u)∗ (u) = −1. Il découle de la question 1.16 que si ρ(u)(v) est un un
mot de Lukasiewicz alors v est un mot de Lukasiewicz également. Il en résulte en remontant à
partir de (−1) que u est un mot mot de Lukasiewicz.

QUESTION 1.18 :
Supposons que L est rationnel
Soit n ∈ N∗
Soit u = (+1)n (−1)n+1
On a u ∈ L et |u| ≥ n
alors, il existe une décomposition de u en trois parties u = fgh telle que : (i) : g 6= ε, (ii) : | f g| ≤
n et (iii) : ∀k ≥ 0, f gk h ∈ L
Les conditions (i) et (ii) nous permettent de distinguer trois cas - cas 1 : g=(+1)k avec 1 ≥ k ≥ n
d’après la condition (iii) fg0 h =(+1)n−k (−1)n+1 ∈ L, contradiction
0
• cas 2 : g = (+1)k (−1)k avec 1 ≥ k + k0 ≥ n et k, k0 6= 0 d’après la condition (iii) fg2 h
0 0 0 0
=(+1)n−k (+1)k (−1)k (+1)k (−1)k (−1)n+1−k = (+1)n (−1)k (+1)k (−1)n+1 ∈ L , contradic-
tion

• cas 3 : g=(-1)k avec 1 ≥ k ≥ n d’après la condition (iii) fg0 h =(+1)n (−1)n+1−k ∈ L, contra-
diction

6
QUESTION 1.19 :
G=({S,X},{-1,+1},S,{S→+1 S -1|X,X→-1})

QUESTION 2.1 :

2. ‘bec’ : 00000110010
3. ’000010010’ : bac

7
 QUESTION 2.2 :
[107]: def nbr_occurrence(mot,lettre):
c=0
for x in mot:
if lettre ==x:
c=c+1
return c

def frequence(mot):
L=[]
deja_traité=[]
for lettre in mot:
if lettre not in deja_traité :
deja_traité.append(lettre)
L.append([lettre,nbr_occurrence(mot,lettre)])
return L

Question 2.3 :
[11]: def trierL(L):
if len(L)<=1:
return L
else:
PP=[L[0]]
PG=[L[i] for i in range(1,len(L)) if L[i][0]>L[0][0]]
PD=[L[i] for i in range(1,len(L)) if L[i][0]<=L[0][0]]
return trierL(PG)+PP+trierL(PD)
Soit n la taille de la liste à trier et C(n) le coût de la fonction trier
si n ≤ 1, alors C(n) = O(1)
le coût des lignes 5,6,7 et la concaténation dans la ligne 8 est O(n)

• dans le pire des cas l’une des Listes PD et PG sera vide et l’autre aura n-1 éléments

donc la complexité de la fonction trierL est C(n) = O(n)+O(n)+0(n)+C(n-1)+C(0)+O(n) = C(n-

1)+O(n)=O(n2 )

• dans le meilleur des cas les listes PD et PG seront de tailles égales

donc la complexité de la fonction trierL est C(n) = O(n)+O(n)+0(n)+C( n2 )+C( n2 )+O(n)=2C( n2 )+O(n)
Alors d’après le théorème général C(n) = O(n log n )

8
 Question 2.4 :
[106]: # 1)

def initialiseL(TabFreq):
L=[]
for elt in TabFreq:
L.append([elt[1],[elt[0],'']])
return L
[105]: # 2)

def etape_creation_listeCodes(L):
plus_petit_elt=L.pop()
deuxieme_plus_petit_elt=L.pop()
for i in range(1,len(plus_petit_elt)):
plus_petit_elt[i][1]='1'+plus_petit_elt[i][1]
for i in range(1,len(deuxieme_plus_petit_elt)):
deuxieme_plus_petit_elt[i][1]='0'+deuxieme_plus_petit_elt[i][1]
x=[plus_petit_elt[0]+deuxieme_plus_petit_elt[0]]+deuxieme_plus_petit_elt[1:
,→]+plus_petit_elt[1:]

L.append(x)
[104]: # 3)

def ListeCodes(TabFreq):
L=initialiseL(TabFreq)
while (len(L)!=1):
etape_creation_listeCodes(L)
L=trierL(L)
return L[0][1:]

Question 2.5 :
[103]: def arbreHuffman(Tablecode):

if len(Tablecode) ==1:
return Arbre(Tablecode[0][0])
else:
L1=[]
L2=[]
for elt in Tablecode:
if elt[1][0]=='1':
s=elt[1][1:]
L1.append([elt[0],s])

else:
s=elt[1][1:]

9
 L2.append([elt[0],s])
return Arbre('x',arbreHuffman(L1),arbreHuffman(L2))

Question 2.6 :
[101]: def encoder(message,TableCodes):
MsgEncode=''
for lettre in message:
for elt in TableCodes :
if elt[0]==lettre:
MsgEncode=MsgEncode+elt[1]
break
return MsgEncode

Question 2.7 :
[100]: def decoder(message,ArbreHuff):
p=ArbreHuff
i=0
s=''
for lettre in message :
if lettre =='1':
p=p.filsg
else:
p=p.filsd
if p.estFeuille():
s+=p.val
p=ArbreHuff
return s

10