Méthode du produit-somme

La méthode du produit-somme, en mathématiques, est un procédé algébrique permettant de factoriser une équation du second degré de la forme

$ax^{2}+bx+c$.

Méthode

Pour factoriser le trinôme, il faut en premier lieu chercher deux nombres $m$ et $p$ tels que leur produit est égal à la valeur du produit de $a$ par $c$ et dont la somme est égale à la valeur de $b$.

Il faut ensuite remplacer le terme $bx$ par la somme des deux nombres $m$ et $p$ tels que $(m+p)x=bx$.

Puis effectuer une double mise en évidence.

Démonstration

$\forall (a,b,c\in \mathbb {Z} )\mid (((\exists \alpha ,\beta ,\gamma ,\delta \in \mathbb {Z} )\mid ax^{2}+bx+c\equiv (\gamma x+\alpha )(\delta x+\beta ))\Longrightarrow ((\exists m,p\in \mathbb {Z} )\mid b=m+p\wedge ac=mp))$

$ax^{2}+(m+p)x+c$

$ax^{2}+mx+px+c$

En introduisant $h$, plus grand commun diviseur de $a$ et $m$.

$a=hk$

$hkc=mp$

Ce qui donne :

$hkx^{2}+mx+px+{\frac {p}{h}}{\frac {m}{k}}$

$kx(hx+{\frac {m}{k}})+{\frac {p}{h}}(hx+{\frac {m}{k}})$

$(kx+{\frac {p}{h}})(hx+{\frac {m}{k}})$

Utilisation

Cette méthode peut être utilisée si et seulement si :

${\begin{cases}m+p=b\\mp=ac\end{cases}}$

Et elle ne devrait être utilisée que sur des petits nombres entiers étant donné qu'il faut trouver empiriquement $m$ et $p$ issus d’une combinaison de facteur premiers de $ac$.

Et bien évidemment le discriminant (Δ) du trinôme doit être positif.

Elle est néanmoins utile de l’envisager avant de tenter d’autres méthodes plus contraignantes comme celle de la complétion du carré.

Les conditions précédentes peuvent paraître contraignantes mais en réalité elles sont vérifiées pour toute forme $(ax+b)(cx+d)$ car pour $acx^{2}+x(ad+bc)+bd$, le “terme du milieu” ($b$ dans le trinôme $ax^{2}+bx+c$) est la somme de $ad$ et $bc$, et $ad\times bc=ac\times bd$ est équivalent à $ac=mp$.

Exemples de mise en œuvre informatique

La méthode du produit-somme peut être mise en algorithme, il existe à ce jour des programmes informatiques permettant de trouver $m$ et $p$.

Python

Ce programme a été créé par l'utilisateur marceaupatu123 et est trouvable sur le site internet Github.

import math

def primefactors(n):
    factors = []
   #Le but est de rendre n impair, tant qu'il est pair on ajoute 2 au tableau
    while n % 2 == 0:
      factors.append(2),
      n = int(n / 2)
    
   #Les diviseurs vont de pair, on s’arrête donc à srqt(n)+1 (voir https://math.stackexchange.com/questions/3875424/sieve-of-eratosthenes-why-can-we-stop-at-the-sqrt-n)
    for i in range(3,int(abs(n)**0.5)+1,2):
     
      while (n % i == 0):
         factors.append(i)
         n = int(n / i)
    
    #S'il reste encore un nombre n > 2 c'est qu'il est un facteur du nombre.
    if n:
      factors.append(n)
      
    return factors

#Cette fonction génère toutes les possibilités de somme via les facteurs
def genp(ac, factors):
    tableauDeToutesLesPossibilités = []
    tableau1 = factors.copy()
    tableau2 = []
    for i in range(0,len(factors)-1):
        tableau2.append(tableau1[0])
        tableau1.pop(0)
        n1 = 1
        n2 = 1
        for i in range(0,len(tableau1)):
            n1 = tableau1[i] * n1
        for i in range(0,len(tableau2)):
            n2 = tableau2[i] * n2
        tableauDeToutesLesPossibilités.append([n1, n2])
    return tableauDeToutesLesPossibilités

# Commute l'élément 0 et 1, 2 et 3...
def PairFactors(factorsarray):
    tableauareverse = factorsarray.copy()
    tour = math.floor((len(tableauareverse)/2))
    for i in range(0, tour*2, 2):
        element = 1
        while tableauareverse[i] == tableauareverse[i+element]:
            if i+element < len(tableauareverse)-1:
                element = element+1
            else:
                break
        tableauareverse[i] , tableauareverse[i+element] = tableauareverse[i+element], tableauareverse[i]
    return tableauareverse    

# Commute l’élément 0 et 3, 3 et 4, 6 et 7...
def ChangeBy3Factors(factorsarray):
    tableauareverse = factorsarray.copy()
    tour = math.floor((len(tableauareverse)/3)) 
    for i in range(0, tour*3, 3):
        element = 1
        while tableauareverse[i] == tableauareverse[i+element]:
            if i+element < len(tableauareverse)-1:
                element = element+1
            else:
                break
        tableauareverse[i] , tableauareverse[i+element] = tableauareverse[i+element], tableauareverse[i]
    return tableauareverse

# Création d'un "super tableau" regroupant toutes les possibilités
def Donnemoiunbeautableau(ac):
    facteurs = primefactors(ac)
    tableaunormal = genp(ac, facteurs)
    tableaupair = genp(ac,PairFactors(facteurs))
    tableauchangedby3 = genp(ac,ChangeBy3Factors(facteurs))
    lepluscomplet = tableaunormal + tableaupair + tableauchangedby3
    lepluscomplettrie = []
    for i in lepluscomplet:
        if i not in lepluscomplettrie:
            lepluscomplettrie.append(i)
    return lepluscomplettrie
    
# Test de M et P pour voir si m+p = b
def MPS(ac, b):
    posibilities = Donnemoiunbeautableau(ac)
    for i in range(0,len(posibilities)):
        m = posibilities[i][0]
        p = posibilities[i][1]
        if m + p == b:
            return [m,p]
        elif -m + p == b:
            return [-m,p]
        elif m + -p == b:
            return [m,-p]
        elif -m + -p == b:
            return [-m,-p]
    return "Aucun m et p valable."  

# Listes de Tests de Trinômes
# print(MPS(4*25, 20))
# print(MPS(16*9, 24))
# print(MPS(15*-4, -4))
# print(MPS(12, 7))
# print(MPS(-32, 4))
# print(MPS(6*8, 16))
# print(MPS(3*4, 8))
# print(MPS(12*32,56))

Articles connexes

• Fonction du second degré
• Liste de symboles logiques