Une identité 

En notant l'expression s'écrit 

>	f:=sin(2*a)/sin(3*a)^2-sin(a)/sin(2*a)^2+sin(3*a)/sin(a)^2;

 

Sa valeur numérique  

>	evalf(eval(f,a=Pi/7),30);

 

est facile à reconnaître : 

>	identify(%);

 

Il n'y a plus qu'à prouver l'identité. Il est possible d'y parvenir en utilisant simplify comme une boite noire : 

>	simplify(eval(f,a=Pi/7)^2);

 

Mais il est plus satisfaisant d'avoir une approche algorithmique maîtrisée de bout en bout. 

La première étape est de se ramener à un calcul sur des fractions rationnelles. La variable que nous allons utiliser est qui représentera et sera donc annulé par le polynôme  

>	convert(f,exp);

 

>	expand(%);

 

>	subs(exp(I*a)=x,%);

 

>	F:=normal(%);

 

Cette fraction rationnelle en annule le polynôme 

>	resultant(numer(t-F),x^7+1,x);

 

>	factor(%);

 

Il ne reste plus qu'à trouver le signe : 

>	evalf(eval(f,a=Pi/7));

 

et nous avons prouvé 

>	subs(a=Pi/7,f)=sqrt(28);

 

Une autre identité 

Le calcul peut s'effectuer en trois temps : d'abord on construit trois polynômes avec les racines cubiques de cos(a), cos(2a), cos(4a) comme racine sur une même extension algébrique, puis on en déduit un polynôme s'annulant sur les sommes deux à deux puis trois par trois par des calculs de résultants, ensuite il ne reste plus qu'à resortir de l'extension par élimination. 

D'abord les polynômes dont les cosinus sont les racines : 

>	P:=map(expand,convert([seq(X^3-cos(m*a),m=[1,2,4])],exp));

 

>	P:=subs(exp(I*a)=x,P);

 

>	resultant(subs(X=Y-X,P[1]),P[2],X);

 

deuxième addition : 

>	resultant(subs(Y=Y-X,numer(%)),P[3],X);

 

Il ne reste plus qu'à éliminer  

>	res:=factor(resultant(numer(%),x^7-1,x));

 

Ce polynôme a le membre gauche de l'identité comme racine. On vérifie tout d'abord que le membre droit en est également racine : 

>	val:=-(-(5-3*7^(1/3))/2)^(1/3);

 

>	expand(eval(res,Y=val));

 

La fin de la preuve consiste à montrer que c'est bien cette racine qui est égale à la valeur souhaitée, et une vérification numérique suffit. Les distances aux racines valent : 

>	sort(map(abs,[seq(evalf(val)-sol,sol={fsolve(res,Y,complex)})]));

 

Donc une seule d'entre elles est susceptible d'être la bonne. 

>	subs(a=2*Pi/7,[seq(cos(m*a),m=[1,2,4])]);

 

>

evalf(%);

 

>	%[1]^(1/3)-(-%[2])^(1/3)-(-%[3])^(1/3);

 

>	evalf(val);

 

Finalement, la difficulté principale, c'est que Maple ne prend pas les racines cubiques comme Ramanujan ! 

Fonctions symétriques des racines 

>

restart;

 

>	F:=alpha^10/(1+alpha^2);

 

>	P:=alpha^4+p*alpha+q;

 

Une première approche consiste à calculer un polynôme dont les racines sont exactement les valeurs de F en les racines de P, et d'en déduire leur somme : 

>	resultant(P,denom(F)*t-numer(F),alpha);

 

>	-coeff(%,t,degree(%,t)-1)/coeff(%,t,degree(%,t));

 

Une seconde approche repose sur les sommes de Newton. 

La première étape du calcul consiste à réduire à un polynôme modulo Pour celà, on commence par inverser le dénominateur : 

>	gcdex(denom(F),P,alpha,U);U;

 

Le polynôme est égal à la fraction lorsque  

>	pol:=rem(U*numer(F),P,alpha);

 

Ce polynôme de degré 3 est donc égal à modulo  

Il ne reste plus qu'à obtenir les sommes de Newton des racines pour Ces sommes sont données par leur série génératrice 

>	map(normal,series(subs(alpha=1/T,alpha*diff(P,alpha)/P),T,4));

 

Le résultat final est obtenu par combinaison linéaire : 

>	add(coeff(pol,alpha,i)*coeff(%,T,i),i=0..3);

 

>	normal(%);

 

L'ensemble de ces opérations est implanté en Maple dans la fonction sum, qui permet de vérifier le résultat : 

>	sum(F,alpha=RootOf(P,alpha));

 

Le facteur  

Celui-ci ne demande aucun calcul : et comme a des coefficients entiers doit être entier. Il est donc nul. 

>

fact:=T:

 

Les facteurs  

Comme a des coefficients entiers, est un entier. Comme ci-dessus, si sa valeur absolue est inférieure à 1, il est nul. Idem pour  

>	4^deg2*bound;

 

>	5^deg2*bound;

 

Par contre, cette méthode ne donne pas de facteur : 

>	6^deg2*bound;

 

>	fact:=fact*(1-4*T)*(1-5*T):

 

Le facteur  

>	new:=29*T^2-11*T+1;

 

>	solve(new,T);

 

>	evalf([%]);

 

Les deux racines sont dans l'intervalle [0,1/4]. Le résultant est un entier. Il est nul si et seulement si divise Par la formule de Poisson, il vaut où sont les nombres ci-dessus. On obtient donc une borne sur le résultant par : 

>	29^deg2*bound^2;

 

qui permet de conclure. 

>	fact:=fact*new;

 

L'inégalité de Markov et les multiplicités 

Il est possible d'utiliser simultanément l'inégalité de Markov et les facteurs déjà connus pour récupérer des facteurs multiples. 

>

markov:=proc(pt,knownfact,bound) local den, i, bb, new, degrest;    den:=denom(pt);    new:=1;    degrest:=deg2-degree(knownfact,T);    bb:=bound*den^degrest/abs(subs(T=pt,knownfact));    for i from 0 to degrest-1 while bb<1 do         new:=new*numer(pt-T);         bb:=bb*8/den*(degrest^2-i^2)/(2*i+1)    od;    new end;

 

>	markov(0,1,bound);

 

Dans ce cas, la connaissance de facteurs n'aide pas : 

>	markov(0,fact/T,bound);

 

>	fact:=fact*T^4;

 

Par contre, en ces facteurs aident à en trouver de nouveaux : 

>	markov(1/4,1,bound);

 

>	markov(1/4,fact/(1-4*T),bound);

 

>	fact:=fact*(1-4*T);

 

Chaque fois qu'un nouveau facteur est trouvé, il faut s'en servir pour tenter d'améliorer les autres multiplicités : 

>	markov(1/5,fact/(1-5*T),bound);

 

ça ne donne rien en 1/5, mais : 

>	markov(0,fact/T^5,bound);

 

>	fact:=fact*T;

 

et on recommence la tournée pour s'assurer que plus rien ne peut être trouvé de cette façon : 

>	markov(1/4,fact/(1-4*T)^2,bound);

 

>	markov(1/5,fact/(1-5*T),bound);

 

Pour résumer, on a trouvé que le polynôme a pour facteur 

>	factor(subs(T=X*(1-X),fact));

 

>

 

Les autres facteurs demandent un peu plus de travail. Le résultat final est