User

En se basant sur le produit cartésien de 2 ensembles, on souhaite réaliser le développement d'un produit de facteurs en Python. C'est-à-dire implémenter une fonction qui pourra transformer un produit de facteurs représenté par une liste de tuples, en une somme réduite de termes représentée par un tuple de tuples.

L'objectif sera d'écrire son propre code, sans utiliser d'autres modules pour Python.


I. Développement du produit de 2 facteurs


I-A. Définition

La multiplication est distributive par rapport à l'addition, cette propriété peut se traduire par :

(a + b) × (c + d) = ac + ad + bc + bd


I-B. Développement du produit de 2 facteurs et produit cartésien

Considérons le produit :

(2a + b) × (a + 3b) = 2aa + 6ab + ba + 3bb

Après réduction de la somme des termes :

(2a + b) × (a + 3b) = 2aa + 7ab + 3bb

On voit que l'on a cette fois besoin de gérer les coefficients des variables pour pouvoir réduire la somme des termes.

Par exemple, le terme 2a sera représenté par le n-uplet (2,a), et le terme 2aa par (2,(a,a)).

Pour simplifier les choses on ne représentera l'exposant des variables que pour afficher le résultat à la fin.



En notant :

f₁=(2a + b)
f₂=(a + 3b)

Ces 2 facteurs peuvent être représentés par les 2 ensembles :

F₁ = {(2,a), (1,b)}
F₂ = {(1,a), (3,b)}

Le développement du produit :

p₂ = f₁ × f₂ = (2a + b) × (a + 3b)

nous donne :

p₂ = 2aa + 6ab + ba + 3bb

De la même façon, le produit cartésien des 2 ensembles :

E₂ = F₁ × F₂ = {(2,a), (1,b)} × {(1,a), (3,b)}

peut également s'écrire :

E₂ = {(2,(a,a)), (6,(a,b)), (1,(b,a)), (3,(b,b))}


Si maintenant on souhaite simplifier l'expression :

p₂ = 2aa + 6ab + ba + 3bb

On obtient après regroupement des variables :

p₂= 2aa + 7ab + 3bb

On peut de la même façon regrouper les éléments du produit cartésien précédent, pour obtenir l'ensemble :

R (E₂) = {(2,(a,a)), (7,(a,b)), (3,(b,b))}

R (E₂) représente l'ensemble résultat du regroupement des éléments de E₂.


I-C. Implémentation en Python

La fonction developper_produit réalise le produit cartésien entre 2 tuples, puis regroupe les éléments de la liste obtenue. Ces 2 tuples contiennent d'autres tuples représentant les termes des facteurs :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
def developper_produit(facteur1,facteur2):
    result=[] # initilisation de la liste result   
    for terme1 in facteur1: # parcours des termes de facteur1 : (a+b) -> [(1,a),(1,b)]
        for terme2 in facteur2: # parcours des termes de facteur2 : (c+d) -> [(1,c),(1,d)]
            coef = terme1[0] * terme2[0] # produit des coefficients des 2 termes : (1,'a') et (1,'c') -> coef = 1*1
            var = terme1[1] + tuple(terme2[1]); var = tuple(sorted(var)) # concaténation des variables : (1,'a') et (1,'c') -> (1,('a','c'))
            result = result + [(coef,var)] # ajoute du tuple (coef,var) à la liste result
    result = reduire_somme(result) # on réduit la liste des termes, résultat du développement du produit
    return result # renvoie la liste result

Pour réduire la liste des termes obtenue, on aura besoin d'une 2^e fonction appelée dans la fonction précédente :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
def reduire_somme(liste_termes1):
    variables = set([terme[1] for terme in liste_termes1]) # on construit la liste des variables
    liste_termes2=[] # on initialise la nouvelle liste des termes
    for var in variables: # on parcourt la liste des variables
        terme = (sum([term[0] for term in liste_termes1 if term[1]==var]),var) # on crée le tuple (sum(coef),var) en regroupant les variables identiques
        if terme[0]!=0: # si le coefficient du terme n'est pas égal à 0
            liste_termes2 = liste_termes2 + [terme] # on ajoute le tuple (sum(coef),var) à la nouvelle liste de termes
 
def get_second(elem):
    return elem[1]

II. Généralisation à plus de deux facteurs


II-A. Définition

La multiplication est dite associative, cette propriété peut se traduire par :

(a + b) × (c + d) × (e + f) = ((a + b) × (c + d)) × (e + f)
(a + b) × (c + d) × (e + f) = (ac + ad + bc + bd) × (e + f)


II-B. Développement du produit de 3 facteurs et produit cartésien

Considérons le produit de 3 facteurs :

(2a + b) × (a + 3b) × (a + 2b) = ((2a + b) × (a + 3b)) × (a + 2b)
(2a + b) × (a + 3b) × (a + 2b) = (2aa + 7ab + 3bb) × (a + 2b)

On va donc utiliser le résultat de notre produit de 2 facteurs (2aa + 7ab + 3bb) pour développer notre produit de 3 facteurs :



En notant :

f₁=(2a + b)
f₂=(a + 3b)
f₃=(a + 2b)

Les 3 facteurs peuvent être représentés par les 3 ensembles :

F₁ = {(2,a), (1,b)}
F₂ = {(1,a), (3,b)}
F₃ = {(1,a), (2,b)}

Le produit des 3 facteurs :

p₃ = (f₁ × f₂) × f₃ = ((2a + b) × (a + 3b)) × (a + 2b)
p₃ = (2aa + 7ab + 3bb) × (a + 2b)

peut alors être représenté par :

E₃ = R (F₁ × F₂) × F₃ = {(2,(a,a)), (7,(a,b)), (3,(b,b))} × {(1,a), (2,b)}

R (F₁ × F₂) représente l'ensemble résultat du regroupement des éléments de E₂ = F₁ × F₂.


Finalement, on regroupera les éléments de l'ensemble E₃, pour obtenir :

R (E₃) = {(2,(a,a,a)), (11,(a,a,b)), (17,(a,b,b)), (6,(b,b,b))}


Note importante : Si vous devez développer un produit de plus de 2 facteurs, il est important de regrouper les variables après chaque développement d'un produit de 2 facteurs.

Imaginez d'avoir à développer le produit (a + b)²⁰, si vous choisissez de réduire la somme des termes à la fin, vous aurez à générer avant 2²⁰ termes, alors que son développement final après simplification ne contient en réalité que 21 termes.


II-C. Implémentation en Python

Dans le précédent billet produit cartésien, nous avons pu utiliser la fonction produit_cartesien à l'intérieur d'une boucle, pour réaliser le produit de plusieurs itérables.

De la même façon, on va utiliser la fonction developper_produit pour développer un produit de facteurs représenté par une liste de tuples :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for facteur in liste_facteurs: # on parcours les éléments (les facteurs) de la liste
    # on développe le produit des 2 facteurs, en réalisant le produit cartésien des 2 tuples, puis le regroupement des éléments de la liste obtenue
    result = developper_produit(result,facteur)

Au départ, la variable result ne contient qu'un seul tuple : resultat=[(1,())].

Un tuple vide en Python est noté ().

La fonction developper utilise ce code pour développer un produit de facteurs.

Elle prend comme arguments :

• facteurs : contient la liste des facteurs passée en arguments : [((1,'a'), (1,'b')), ((1,'c'), (1,'d'))] pour (a + b) × (c + d) ;
• exposant : ce paramètre optionnel permet de répéter la liste de facteurs. Il revient à élever à la puissance le produit de facteurs.

La fonction renvoie un tuple de tuples qui représente en fait une somme de termes. Cette somme pourra ainsi être utilisée comme facteur pour un autre produit.

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
def developper(facteurs,exposant=1):
    liste_facteurs = facteurs*exposant # on construit la liste de facteurs en répétant la liste de départ : [((1,'a'),(1,'b'))]*2 = [((1,'a'),(1,'b')),((1,'a'),(1,'b'))]
    result = [(1,())] # on initialise la liste result avec un seul tuple (1,())
 
    for facteur in liste_facteurs: # on parcourt les éléments (les facteurs) de la liste
        # on développe le produit des 2 facteurs, en réalisant le produit cartésien des 2 tuples, puis le regroupement des éléments de la liste obtenue
        result = developper_produit(result,facteur) 
 
    return tuple(result) # on renvoi le résultat du développement sous forme de tuple

II-C-1. Mise en œuvre de la fonction

Prenons par exemple le développement de (a + b)⁶.

Pour le réaliser, on peut utiliser notre fonction de différentes manières.

1^re méthode, on évalue directement (a + b)⁶ :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
resultat=developper([((1,'a'),(1,'b'))],exposant=6)
print(resultat)

2^e méthode, on évalue d'abord p₃ = (a + b)³, puis (p₃)² :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
resultat=developper([((1,'a'),(1,'b'))],exposant=3)
resultat=developper([resultat],exposant=2)
print(expression_somme(resultat))

Affichage :

a^6 + 6a^5b + 15a^4b^2 + 20a^3b^3 + 15a^2b^4 + 6ab^5 + b^6

On utilise la fonction expression_somme pour afficher l'expression mathématique de la somme.

Note : Si on souhaite par exemple développer le produit de facteurs (2 + 3a) × (3 - 2b), on passera à la fonction la liste de tuples [((2,()), (3,'a')), ((3,()), (-2,'b'))].

Module complet pour les tests :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
def developper_produit(facteur1,facteur2):
    result=[] # initilisation de la liste result   
    for terme1 in facteur1: # parcours des termes de facteur1 : (a+b) -> ((1,a),(1,b))
        for terme2 in facteur2: # parcours des termes de facteur2 : (c+d) -> ((1,c),(1,d))
            coef = terme1[0] * terme2[0] # produit des coefficients des 2 termes : (1,'a') et (1,'c') -> coef = 1*1
            var = terme1[1] + tuple(terme2[1]); var = tuple(sorted(var)) # concaténation des variables : (1,'a') et (1,'c') -> (1,('a','c'))
            result = result + [(coef,var)] # ajoute du tuple (coef,var) à la liste result
    result = reduire_somme(result) # on réduit la liste des termes, résultat du développement du produit
    return result # renvoie la liste result
 
def get_first(elem):
    return elem[0]
 
def get_second(elem):
    return elem[1]
 
def reduire_somme(liste_termes1):
    variables = set([terme[1] for terme in liste_termes1]) # on construit la liste des variables
    liste_termes2=[] # on initialise la nouvelle liste des termes
    for var in variables: # on parcourt la liste des variables
        terme = (sum([term[0] for term in liste_termes1 if term[1]==var]),var) # on crée le tuple (sum(coef),var) en regroupant les variables identiques
        if terme[0]!=0: # si le coefficient du terme n'est pas égal à 0
            liste_termes2 = liste_termes2 + [terme] # on ajoute le tuple (sum(coef),var) à la nouvelle liste de termes
 
    liste_termes2.sort(key=get_second) # on trie la liste des termes en fonction des variables (seconde colonne : indice 1) pour permettre les regroupements.
 
    return liste_termes2 # on retourne la liste des termes réduite
 
def developper(facteurs,exposant=1):
    liste_facteurs = facteurs*exposant # on construit la liste de facteurs en répétant la liste de départ : [((1,'a'),(1,'b'))]*2 = [((1,'a'),(1,'b')),((1,'a'),(1,'b'))]
    result = [(1,())] # on initialise la liste result avec un seul tuple (1,())
 
    for facteur in liste_facteurs: # on parcourt les éléments (les facteurs) de la liste
        # on développe le produit des 2 facteurs, en réalisant le produit cartésien des 2 tuples, puis le regroupement des éléments de la liste obtenue
        result = developper_produit(result,facteur)
 
    return tuple(result) # on renvoi le résultat du développement sous forme de tuple 
 
def reduire_var(liste_variables1):
    variables = set(liste_variables1)
    liste_variables2=[] # on initialise la liste des variables
    for var in variables: # on parcourt les variables
        liste_variables2 = liste_variables2 + [(var,liste_variables1.count(var))] # on ajoute le tuple à la liste : (var, exposant) -> [.., (var, exposant)]
    liste_variables2.sort(key=get_first) # on trie la liste des variables
    return tuple(liste_variables2)
 
sign = lambda x : "+" if (x > 0) else "-"
 
def expression_somme(liste_termes):
    expr_som='' # on initialise la chaîne de caractères
 
    for terme in liste_termes: # on parcourt la liste des termes de la somme
        liste_variables = reduire_var(terme[1]) # on regroupe la liste des variables du terme en ajoutant leur exposant : ('a','a','a','b') -> (('a',3),('b',1)) 
        expr_var='' # on initialise la chaîne de caractères
        for var in liste_variables: # on parcourt la liste des variables du terme
            if var[1]==1: # si l'exposant de la variale est égal à 1
                expr_var = expr_var + str(var[0]) # on ajoute uniquement la variable à la chaîne
            else: # sinon
                expr_var = expr_var + str(var[0]) + '^' + str(var[1]) # on ajoute la variable et son exposant à la chaîne
 
        if abs(terme[0])==1: # si le coefficient du terme est égal à 1 ou -1       
            expr_som = expr_som + ' ' + sign(terme[0]) + ' ' + expr_var  # on ajoute uniquement les variables du terme sans son coefficient
        else: # sinon
            expr_som = expr_som + ' ' + sign(terme[0]) + ' ' +  str(abs(terme[0])) + expr_var # on ajoute le terme complet à la chaîne
 
    # on renvoie la chaîne contenant l'expression de la somme obtenue moins les 3 premiers caractères (' - ') ou (' + ')
    return expr_som[3:] if expr_som[:3]==' + ' else '-' + expr_som[3:]

III. Conclusion

Après avoir représenté le développement du produit de 2 facteurs à l'aide du produit cartésien de 2 ensembles, nous avons pu le généraliser à plus de 2 facteurs, pour enfin l'implémenter en Python.

Sources :
https://fr.wikipedia.org/wiki/Produi...%20%C3%A0%20Y.
https://python.developpez.com/cours/.../toc/index.php