Radici di polinomi con astuzia e sacrificio

[xyz]

Quindi il trucco è abbassare il grado del polinomio. Io mi ero messo a cercare qualche trucco per individuate le radici dalla sequenza delle derivate ma il teorema di Abel-Ruffini non si può aggirare.

Ritornando al problema iniziale. Bisogna trovare tutti gli zeri di questo polinomio:

1. Calcolare la derivata prima:

2. Calcolare il massimo comune multiplo polinomiale (gcd) tra e :



Se è uguale a 1 allora e sono coprimi, in questo caso il procedimento si ferma qui e non è possibile andare avanti, altrimenti tutti gli zeri di sono anche di .

3. Calcolare il secondo fattore polinomiale con una divisione tra i polinomi e :





Il resto della divisione è nullo visto che per costruzione è un fattore polinomiale di .

4. Trovare se possibile gli zeri di e con le formule note di risoluzione quelle equazioni dal primo al quarto grado.

In questo caso è di grado 4 e è di grado 3 (la somma deve essere uguale al grado di ).

Gli zeri di :






La presenza di almeno uno zero di molteplicità maggiore di 1 ha reso possibile la fattorizzazione con la derivata prima.

Gli zeri di :

5. Unire tutti gli zeri con la loro molteplicità di e per ottenere tutti gli zeri di :

Questo è tutto, salvo errori

P.S. Le formule per trovare gli zeri dei polinomi dal primo al quarto grado:

https://it.wikipedia.org/wiki/Equazione_lineare
https://it.wikipedia.org/wiki/Equazione ... ondo_grado
https://it.wikipedia.org/wiki/Equazione_di_terzo_grado
https://it.wikipedia.org/wiki/Equazione_di_quarto_grado

[Ianero]

[xyz]

Aggiungo alla discussione alcuni script creati da me per cercare di risolvere il problema.

Questo semplice script per Maxima esegue i vari passi per la risoluzione del problema come descritto nel post precedente:

Codice: Seleziona tutto

P(x):=x^7+3*x^6+5*x^5+7*x^4+7*x^3+5*x^2+3*x+1;

PP(x):=diff(P(x),x)$
display(PP(x))$

Q(x):=gcd(P(x), PP(x))$
display(Q(x))$

R(x):=divide(P(x), Q(x))[1]$
display(R(x))$

solve(Q(x), x);
multiplicities;

solve(R(x), x);
multiplicities;

Output con gli zeri e la loro molteplicità:










Prima di questa discussione non conoscevo il teorema di Gauss–Lucas, riguarda una particolare proprietà. Gli zeri, considerati come punti nel piano complesso ℂ, della derivata prima di un polinomio sono inclusi nel convex hull formato dagli zeri del polinomio iniziale.

Il grafico del polinomio in esame con tutte le sue derivate fino a un polinomio di primo grado:

Plot 1

Un altro polinomio sempre di settimo grado fa vedere meglio questa proprietà:

Plot 2

Sono utilizzati gli stessi colori per i punti delle radici e il convex hull. I vai convex hull sono annidati come in una matrioska.

Lo script in Python per generare le immagini precedenti, usa come librerie NumPy, SymPy, SciPy e Matplotlib:

Codice: Seleziona tutto

#!/usr/bin/env python3

import sys

from itertools import cycle, tee

import numpy as np

from sympy import *
from sympy.abc import x
from mpmath.libmp.libhyper import NoConvergence

from scipy.spatial import ConvexHull
from scipy.spatial.qhull import QhullError

import matplotlib.pyplot as plt


init_printing(use_unicode=True)

plt.rc('text', usetex=True)
plt.rc('font', family='serif')


# pprint = print_latex

# Tableau 20

palette = ['#1f77b4', '#aec7e8', '#ff7f0e', '#ffbb78', '#2ca02c',
           '#98df8a', '#d62728', '#ff9896', '#9467bd', '#c5b0d5',
           '#8c564b', '#c49c94', '#e377c2', '#f7b6d2', '#7f7f7f',
           '#c7c7c7', '#bcbd22', '#dbdb8d', '#17becf', '#9edae5']

(col_ring1, col_ring2) = tee(cycle(palette))


def main():

    p = Poly([1, 3, 5, 7, 7, 5, 3, 1], x, domain=polys.domains.CC)
#    p = Poly([1, 1, 1, 1, 1, 1, 1, 1], x, domain=polys.domains.CC)

    grade = degree(p)

    equations = [diff(p, (x, n)) for n in range(grade)]

    plt.grid()
    plt.axes().set_aspect('equal', 'datalim')

    for n in range(grade):

        col1 = next(col_ring2)
        col2 = next(col_ring2)

        expr = equations[n]

        try:
            sol = solve(expr)
        except NoConvergence:
            try:
                sol = roots(expr)
            except NoConvergence:
                try:
                    sol = nroots(expr, n=10)
                except NoConvergence:
                    print('No Solution found:', sys.exc_info()[0])
                    continue

        nsol = len(sol)
        if nsol == 0:
            continue

        points = np.empty([nsol, 2])

        for i, s in enumerate(sol):
            points[i] = np.array([re(s), im(s)])

        if nsol >= 3:

            try:
                hull = ConvexHull(points)

                plt.fill(points[hull.vertices, 0], points[hull.vertices, 1],
                         c=col2, alpha=0.35)

                for simp in hull.simplices:
                    plt.plot(points[simp, 0], points[simp, 1], '-', c=col1)

            except QhullError:
                pass

        plt.plot(points[:, 0], points[:, 1], 'o', c=col1)

        pprint(expr.as_expr())

        for n, s in enumerate(sol):
            print('root {}: '.format(n + 1), end='')
            pprint(s)

        print()

    plt.title('${}$'.format(latex(p.as_expr())))
    plt.suptitle('Roots', fontsize=16)
    plt.xlabel('real', fontsize=14)
    plt.ylabel('imaginary', fontsize=14)

#    plt.savefig('plot.png')
    plt.show()


if __name__ == '__main__':
    main()


Alla fine questa parte non è servita per trovare la soluzione al problema iniziale.

[Ianero]

Complimenti per questo bel post