Système d'équations polynomiales

uvdose

Bonjour
J'avoue être désarmé face au système d'équations polynomiales d'inconnues complexes $a$, $b$, $c$ et $d$ suivant : 
 $\small\left\{\begin{array}{l}
b^2+c^2+5bc-85=0\\
10ab^3+22a^2b^2+10a^3b-10a^3-10b^3-25ab^2-25a^2b+5a^2c+5b^2c+25abc-32a^2-32b^2+c^2-125ab-35a-35b-7=0\\
a^4+c^4-d^4+10ac^3+27a^2c^2+10a^3c-15d^3+5a^2+5c^2-53d^2+25ac-15d=0\\
a^4-b^4-d^4-10bd^3-27b^2d^2-10b^3d+70a^3+1328a^2-35b^2-35d^2-175bd+3605a+2598=0\\
48d^4-10d^3-417d^2-2135d-7650=0
\end{array}\right.$
Je conjecture que la seule solution est $(a,b,c,d)=(2,3,4,5)$ mais je ne sais pas le prouver.
Quelles méthodes peut-on employer dans ce genre de situation ?
Merci pour votre aide.

canasson29

Bonjour,

si tu as le logiciel adéquat, tu peux utiliser des bases de Gröbner.

parisse

C'est en effet la seule solution.

La preuve peut se faire en utilisant la commande gbasis de Xcas avec le paramètre optionnel rur

S:=[b^2+c^2+5*b*c-85,
       10*a*b^3+22*a^2*b^2+10*a^3*b-10a^3-10b^3-25*a*b^2-25a^2*b+5a^2*c+5b^2*c+25a*b*c-32a^2-32b^2+c^2-125a*b-35a-35b-7,
a^4+c^4-d^4+10a*c^3+27a^2*c^2+10a^3*c-15d^3+5a^2+5c^2-53d^2+25a*c-15d,
a^4-b^4-d^4-10b*d^3-27b^2*d^2-10b^3*d+70a^3+1328a^2-35b^2-35d^2-175b*d+3605a+2598,
48d^4-10d^3-417d^2-2135d-7650];

gbasis(S,[a,b,c,d],rur);

renvoie  [rur,d,-d+5,-1,-2,-3,-4,-5]

ce qui signifie que l'ensemble des solutions est exprimé en fonction de la variable d, que d vérifie une équation de degré 1 (-d+5=0), le dénominateur commun des solutions est -1 (la dérivée, normalement c'est un polynôme) et les numérateurs des solutions sont des polynômes en d, qui sont ici constants.

uvdose

Merci pour vos réponses !

Rescassol

Bonjour
Dans Matlab, gbasis(S,[a,b,c,d]) répond [a - 2, b - 3, c - 4, d - 5].
(Dans la définition de S, il manque quelques "*")

Cordialement,
Rescassol

uvdose

Je ne dispose pas des logiciels qui me permettraient de trouver une base de Gröbner de l'idéal de Q[a,b,c,d] engendré par les 5 polynômes de la liste : 

S:=[8*b^3*c-48*b^3+22*b^2*c^2+16*b^2*c-4*b^2*d-644*b^2+24*b*c^3+64*b*c^2+16*b*c-96*b*d-1728*b+6*c^4+24*c^3+22*c^2+8*c-d^2-144*d-1295,1440*a^8+1168*a^7*b-16*a^7*d+4516*a^6*b^2+7296*a^6*b-100*a^6*d^2+576*a^6*d+1824*a^6+2224*a^5*b^3+3072*a^5*b^2+2400*a^5*b*d+768*a^5*b-304*a^5*d^3-96*a^5*d^2+2978*a^4*b^4+12128*a^4*b^3+1368*a^4*b^2*d+13464*a^4*b^2+1536*a^4*b*d+5216*a^4*b-4*a^4*c^2-96*a^4*c-454*a^4*d^4-408*a^4*d^3+144*a^4*d^2+384*a^4*d+508*a^4+1104*a^3*b^5+3328*a^3*b^4+2240*a^3*b^3*d+1344*a^3*b^3+6144*a^3*b^2*d+256*a^3*b^2+144*a^3*b*d^2+1536*a^3*b*d+32*a^3*b-32*a^3*c^2*d-768*a^3*c*d-304*a^3*d^5-704*a^3*d^4-144*a^3*d^3-1152*a^3*d+316*a^2*b^6+1536*a^2*b^5+808*a^2*b^4*d+3840*a^2*b^4+1664*a^2*b^3*d+4800*a^2*b^3+420*a^2*b^2*d^2+672*a^2*b^2*d+2520*a^2*b^2+384*a^2*b*d^2+128*a^2*b*d+576*a^2*b-72*a^2*c^2*d^2-16*a^2*c^2*d-1728*a^2*c*d^2-384*a^2*c*d-100*a^2*d^6-408*a^2*d^5-324*a^2*d^4-2496*a^2*d^2-560*a^2*d+48*a^2+48*a*b^7+256*a*b^6+160*a*b^5*d+576*a*b^5+512*a*b^4*d+256*a*b^4+144*a*b^3*d^2+1152*a*b^3*d+32*a*b^3+512*a*b^2*d+32*a*b*d^3+64*a*b*d-32*a*c^2*d^3-64*a*c^2*d^2-768*a*c*d^3-1536*a*c*d^2-16*a*d^7-96*a*d^6-144*a*d^5-32*a*d^4-1152*a*d^3-2304*a*d^2+6*b^8+48*b^7+24*b^6*d+172*b^6+128*b^5*d+336*b^5+22*b^4*d^2+288*b^4*d+458*b^4+32*b^3*d^2+128*b^3*d+304*b^3+8*b^2*d^3+72*b^2*d^2+16*b^2*d+100*b^2+32*b*d^2+16*b-c^4-48*c^3-4*c^2*d^4-16*c^2*d^3-4*c^2*d^2-648*c^2-96*c*d^4-384*c*d^3-96*c*d^2-1728*c-d^8-8*d^7-18*d^6-8*d^5-144*d^4-576*d^3-140*d^2-1295,3966*a^8+13104*a^7*b+1968*a^7*c+16108*a^6*b^2+3328*a^6*b*c+984*a^6*b+4492*a^6*c^2+9744*a^5*b^3+1344*a^5*b^2*c+1664*a^5*b^2+7488*a^5*b*c^2+4000*a^5*b*c+2256*a^5*c^3+3554*a^4*b^4+256*a^4*b^3*c+672*a^4*b^3+3024*a^4*b^2*c^2+6656*a^4*b^2*c+262*a^4*b^2+3328*a^4*b*c^3+1384*a^4*b*c^2+698*a^4*c^4+880*a^3*b^5+32*a^3*b^4*c+128*a^3*b^4+576*a^3*b^3*c^2+2688*a^3*b^3*c+416*a^3*b^3+1344*a^3*b^2*c^3+1664*a^3*b^2*c^2+144*a^3*b^2*c+416*a^3*b*c^4+704*a^3*b*c^3+304*a^3*c^5+148*a^2*b^6+16*a^2*b^5+72*a^2*b^4*c^2+512*a^2*b^4*c+168*a^2*b^4+256*a^2*b^3*c^3+672*a^2*b^3*c^2+8*a^2*b^3+168*a^2*b^2*c^4+324*a^2*b^2*c^2+408*a^2*b*c^4+100*a^2*c^6+16*a*b^7+64*a*b^5*c+32*a*b^5+32*a*b^4*c^3+128*a*b^4*c^2+32*a*b^3*c^4+32*a*b^3*c+144*a*b^2*c^3+96*a*b*c^5+16*a*c^7-24*b^7-210*b^6+16*b^5*c^2-864*b^5-32*b^4*c^3-16*b^4*c^2*d^2-64*b^4*c^2*d-88*b^4*c^2-64*b^4*c*d^2-256*b^4*c*d-96*b^4*c-4*b^4*d^4-32*b^4*d^3-88*b^4*d^2-96*b^4*d-1538*b^4-48*b^3*c^4-384*b^3*c^3-192*b^3*c^2*d^2-768*b^3*c^2*d-1048*b^3*c^2-768*b^3*c*d^2-3072*b^3*c*d-1152*b^3*c-48*b^3*d^4-384*b^3*d^3-1056*b^3*d^2-1152*b^3*d-1152*b^3-122*b^2*c^4-1120*b^2*c^3-560*b^2*c^2*d^2-2240*b^2*c^2*d-3080*b^2*c^2-2240*b^2*c*d^2-8960*b^2*c*d-3360*b^2*c-140*b^2*d^4-1120*b^2*d^3-3080*b^2*d^2-3360*b^2*d-1054*b^2+8*b*c^6-48*b*c^4-384*b*c^3-192*b*c^2*d^2-768*b*c^2*d-1056*b*c^2-768*b*c*d^2-3072*b*c*d-1152*b*c-48*b*d^4-384*b*d^3-1056*b*d^2-1152*b*d-312*b-16*c^7-8*c^6*d^2-32*c^6*d-108*c^6-96*c^5*d^2-384*c^5*d-400*c^5-18*c^4*d^4-144*c^4*d^3-732*c^4*d^2-1776*c^4*d-884*c^4-144*c^3*d^4-1152*c^3*d^3-3296*c^3*d^2-3968*c^3*d-1184*c^3-8*c^2*d^6-96*c^2*d^5-732*c^2*d^4-3296*c^2*d^3-6664*c^2*d^2-4384*c^2*d-928*c^2-32*c*d^6-384*c*d^5-1776*c*d^4-3968*c*d^3-4384*c*d^2-2176*c*d-384*c-d^8-16*d^7-108*d^6-400*d^5-884*d^4-1184*d^3-928*d^2-384*d-61,36*a^8+288*a^7*d+288*a^7+840*a^6*d^2+1920*a^6*d+840*a^6+1152*a^5*d^3+4320*a^5*d^2+4320*a^5*d+1152*a^5+24*a^4*b^4+192*a^4*b^3+96*a^4*b^2*c^2+384*a^4*b^2*c+528*a^4*b^2+384*a^4*b*c^2+1536*a^4*b*c+576*a^4*b+24*a^4*c^4+192*a^4*c^3+528*a^4*c^2+576*a^4*c+880*a^4*d^4+3968*a^4*d^3+6648*a^4*d^2+3968*a^4*d+1023*a^4+96*a^3*b^4*d+96*a^3*b^4+768*a^3*b^3*d+768*a^3*b^3+384*a^3*b^2*c^2*d+384*a^3*b^2*c^2+1536*a^3*b^2*c*d+1536*a^3*b^2*c+2112*a^3*b^2*d+2112*a^3*b^2+1536*a^3*b*c^2*d+1536*a^3*b*c^2+6144*a^3*b*c*d+6144*a^3*b*c+2304*a^3*b*d+2304*a^3*b+96*a^3*c^4*d+96*a^3*c^4+768*a^3*c^3*d+768*a^3*c^3+2112*a^3*c^2*d+2104*a^3*c^2+2272*a^3*c*d+2304*a^3*c+400*a^3*d^5+1776*a^3*d^4+3296*a^3*d^3+3288*a^3*d^2+2352*a^3*d+976*a^3+88*a^2*b^4*d^2+256*a^2*b^4*d+88*a^2*b^4+704*a^2*b^3*d^2+2048*a^2*b^3*d+704*a^2*b^3+352*a^2*b^2*c^2*d^2+1024*a^2*b^2*c^2*d+352*a^2*b^2*c^2+1408*a^2*b^2*c*d^2+4096*a^2*b^2*c*d+1408*a^2*b^2*c+1936*a^2*b^2*d^2+5632*a^2*b^2*d+1932*a^2*b^2+1408*a^2*b*c^2*d^2+4096*a^2*b*c^2*d+1408*a^2*b*c^2+5632*a^2*b*c*d^2+16384*a^2*b*c*d+5632*a^2*b*c+2112*a^2*b*d^2+6144*a^2*b*d+2096*a^2*b+88*a^2*c^4*d^2+256*a^2*c^4*d+70*a^2*c^4+704*a^2*c^3*d^2+1904*a^2*c^3*d+704*a^2*c^3+1612*a^2*c^2*d^2+5632*a^2*c^2*d+1936*a^2*c^2-144*a^2*c*d^3+2112*a^2*c*d^2+6144*a^2*c*d+2112*a^2*c+108*a^2*d^6+384*a^2*d^5+714*a^2*d^4+1152*a^2*d^3+1260*a^2*d^2+1920*a^2*d+632*a^2+32*a*b^4*d^3+64*a*b^4*d^2+64*a*b^4*d+32*a*b^4+256*a*b^3*d^3+512*a*b^3*d^2+512*a*b^3*d+256*a*b^3+128*a*b^2*c^2*d^3+256*a*b^2*c^2*d^2+256*a*b^2*c^2*d+112*a*b^2*c^2+512*a*b^2*c*d^3+1024*a*b^2*c*d^2+960*a*b^2*c*d+512*a*b^2*c+704*a*b^2*d^3+1392*a*b^2*d^2+1408*a*b^2*d+704*a*b^2+512*a*b*c^2*d^3+1024*a*b*c^2*d^2+1024*a*b*c^2*d+448*a*b*c^2+2048*a*b*c*d^3+4096*a*b*c*d^2+3840*a*b*c*d+2048*a*b*c+768*a*b*d^3+1472*a*b*d^2+1536*a*b*d+768*a*b-8*a*c^6-96*a*c^5*d+32*a*c^4*d^3-344*a*c^4*d^2+64*a*c^4*d+32*a*c^4-448*a*c^3*d^3+512*a*c^3*d^2+512*a*c^3*d+256*a*c^3-408*a*c^2*d^4+704*a*c^2*d^3+1408*a*c^2*d^2+1408*a*c^2*d+688*a*c^2-96*a*c*d^5+768*a*c*d^3+1536*a*c*d^2+1472*a*c*d+768*a*c+16*a*d^7+24*a*d^6+96*a*d^5+144*a*d^4+336*a*d^3+464*a*d^2+416*a*d+208*a+b^8+16*b^7+8*b^6*c^2+32*b^6*c+108*b^6+96*b^5*c^2+384*b^5*c+400*b^5+18*b^4*c^4+144*b^4*c^3+732*b^4*c^2+1776*b^4*c+4*b^4*d^4+16*b^4*d^2+883*b^4+144*b^3*c^4+1152*b^3*c^3+3296*b^3*c^2+3968*b^3*c+32*b^3*d^4+128*b^3*d^2+1176*b^3+8*b^2*c^6+96*b^2*c^5+728*b^2*c^4-32*b^2*c^3*d+3296*b^2*c^3+16*b^2*c^2*d^4-8*b^2*c^2*d^2+6664*b^2*c^2+64*b^2*c*d^4-32*b^2*c*d^3+256*b^2*c*d^2+4384*b^2*c+84*b^2*d^4+352*b^2*d^2+910*b^2+32*b*c^6+384*b*c^5+1760*b*c^4-128*b*c^3*d+3968*b*c^3+64*b*c^2*d^4-32*b*c^2*d^2+4384*b*c^2+256*b*c*d^4-128*b*c*d^3+1024*b*c*d^2+2176*b*c+80*b*d^4+384*b*d^2+376*b-16*c^7*d+16*c^7-100*c^6*d^2+108*c^6-304*c^5*d^3+400*c^5-450*c^4*d^4+16*c^4*d^2+880*c^4-304*c^3*d^5+32*c^3*d^4+128*c^3*d^2-32*c^3*d+1184*c^3-100*c^2*d^6+88*c^2*d^4+280*c^2*d^2+928*c^2-16*c*d^7+96*c*d^4-32*c*d^3+384*c*d^2+384*c+8*d^6+38*d^4+104*d^2+60,5*a^8+48*a^7*c-48*a^7+172*a^6*c^2+248*a^6*c+24*a^6*d^2+96*a^6*d-3260*a^6+336*a^5*c^3+576*a^5*c^2+128*a^5*c*d^2+512*a^5*c*d+1088*a^5*c+160*a^5*d^2+640*a^5*d-64400*a^5+458*a^4*c^4+256*a^4*c^3+288*a^4*c^2*d^2+1152*a^4*c^2*d+4110*a^4*c^2+512*a^4*c*d^2+2048*a^4*c*d-10848*a^4*c+22*a^4*d^4+176*a^4*d^3+1204*a^4*d^2+3408*a^4*d-4*a^4*b^4-48*a^4*b^3-140*a^4*b^2-48*a^4*b-584580*a^4+304*a^3*c^5+32*a^3*c^4+128*a^3*c^3*d^2+512*a^3*c^3*d+4928*a^3*c^3+1152*a^3*c^2*d^2+4608*a^3*c^2*d+1632*a^3*c^2+32*a^3*c*d^4+256*a^3*c*d^3+2240*a^3*c*d^2+6912*a^3*c*d-138240*a^3*c+144*a^3*d^4+1152*a^3*d^3+4832*a^3*d^2+10112*a^3*d-192*a^3*b^4-2304*a^3*b^3-6720*a^3*b^2-2304*a^3*b-2359488*a^3+100*a^2*c^6+16*a^2*c^4*d^2+64*a^2*c^4*d+2536*a^2*c^4+512*a^2*c^3*d^2+2048*a^2*c^3*d+760*a^2*c^3+72*a^2*c^2*d^4+576*a^2*c^2*d^3+1968*a^2*c^2*d^2+3264*a^2*c^2*d+2544*a^2*c^2+6144*a^2*c*d^2+24576*a^2*c*d-16*a^2*c*b^4-192*a^2*c*b^3-560*a^2*c*b^2-192*a^2*c*b-519568*a^2*c+8*a^2*d^6+96*a^2*d^5+828*a^2*d^4+4064*a^2*d^3+9336*a^2*d^2+8928*a^2*d-2592*a^2*b^4-31104*a^2*b^3-90720*a^2*b^2-31104*a^2*b-4661880*a^2+16*a*c^7+576*a*c^5+64*a*c^4*d^2+256*a*c^4*d+96*a*c^4+32*a*c^3*d^4+256*a*c^3*d^3+704*a*c^3*d^2+768*a*c^3*d+5184*a*c^3+1536*a*c^2*d^2+6144*a*c^2*d-28800*a*c^2+384*a*c*d^4+3072*a*c*d^3+8448*a*c*d^2+9216*a*c*d-384*a*c*b^4-4608*a*c*b^3-13440*a*c*b^2-4608*a*c*b-737664*a*c+32*a*d^6+384*a*d^5+1776*a*d^4+3968*a*d^3+6624*a*d^2+11136*a*d-6912*a*b^4-82944*a*b^3-241920*a*b^2-82944*a*b-4482144*a+c^8+48*c^6+4*c^4*d^4+32*c^4*d^3+88*c^4*d^2+96*c^4*d+671*c^4-288*c^3+96*c^2*d^4+768*c^2*d^3+2112*c^2*d^2+2304*c^2*d-4*c^2*b^4-48*c^2*b^3-140*c^2*b^2-48*c^2*b-21028*c^2-576*c*b^4-6912*c*b^3-20160*c*b^2-6912*c*b-373824*c+d^8+16*d^7+108*d^6+400*d^5+1024*d^4+2304*d^3+4008*d^2+3744*d-b^8-24*b^7-214*b^6-864*b^5-6699*b^4-63072*b^3-181654*b^2-62232*b-1682605]

D'ailleurs, est-ce bien raisonnable ? Ces polynômes ne sont-ils pas trop monstrueux ?

Merci pour votre aide !

Joaopa

https://www.xcasenligne.fr/giac_online/demoGiacPhp.php

uvdose

Merci.
En fait Xcas en ligne ne me fournit aucune réponse.
J'ai donc installé Xcas sur mon ordi qui répond (en 12 secondes) à gbasis(S,[a,b,c,d]) :

[a-2, b-3, c-4, d-5]

En revanche, Sage mouline depuis plusieurs heures après lui avoir demandé :

R.<a,b,c,d>=PolynomialRing(QQ,4,order='lex')
S=[... , ... , ... ,... , ...]
I=R.ideal(S)
G=I.groebner_basis()
G
Est-ce normal ? N'est-ce pas les mêmes algorithmes qui sont utilisés ?

Rescassol

Bonjour,
Matlab répond en $0.896607$ secondes.
Cordialement,
Rescasssol

GaBuZoMeu

R.=PolynomialRing(QQ,4)

S=[b^2+c^2+5*b*c-85,10*a*b^3+22*a^2*b^2+10*a^3*b-10*a^3-10*b^3-25*a*b^2-25*a^2*b+5*a^2*c+5*b^2*c+25*a*b*c-32*a^2-32*b^2+c^2-125*a*b-35*a-35*b-7,
a^4+c^4-d^4+10*a*c^3+27*a^2*c^2+10*a^3*c-15*d^3+5*a^2+5*c^2-53*d^2+25*a*c-15*d, a^4-b^4-d^4-10*b*d^3-27*b^2*d^2-10*b^3*d+70*a^3+1328*a^2-35*b^2-35*d^2-175*b*d+3605*a+2598,
48*d^4-10*d^3-417*d^2
-2135*d-7650]

J=R.ideal(S)

%time J.dimension()

CPU times: user 4min 25s, sys: 531 ms, total: 4min 26s
Wall time: 4min 25s

0

%time J.vector_space_dimension()

CPU times: user 394 µs, sys: 1 µs, total: 395 µs
Wall time: 404 µs

1

%time J.variety()

CPU times: user 1min 8s, sys: 200 ms, total: 1min 8s
Wall time: 1min 8s

[{d: 5, c: 4, b: 3, a: 2}]

uvdose

Merci !
Matlab répond la même chose, j'imagine [a-2,b-3,c-4,d-5] ?
Quelle(s) commande(s) faut-il utiliser ?
Seulement gbasis(S,[a,b,c,d]) ? 

uvdose

Heu... j'ai un doute... les 0.896607 secondes c'est pour la première liste de polynômes ou pour la seconde liste de (très gros) polynômes ?

Rescassol

Bonjour,

Uvdose, faut lire les messages précédents: https://les-mathematiques.net/vanilla/index.php?p=/discussion/comment/2430763/#Comment_2430763
Je répondais au message de Parisse.

Cordialement,
Rescassol

parisse

Quelques précisions.

Pour résoudre un système polynomial, utiliser l'ordre par défaut de la commande gbasis (ou équivalent selon votre logiciel) n'est pas forcément une bonne idée, même si ça marche ici. En effet, l'ordre par défaut entre les monômes est en général l'ordre revlex (degré total puis reverse lexicographique), ce n'est pas un ordre d'élimination, et ça ne permet en particulier pas en général d'isoler une variable puis successivment les autres ce que fait l'ordre lexicographique. Malheureusement calculer une base de Groebner pour l'ordre lexicographique est expérimentalement beaucoup plus couteux que l'ordre revlex (on procède plutôt par changement d'ordre une fois la base calculée avec revlex avec des algorithmes comme par exemple FGLM). De plus l'ordre lexicographique n'est pas idéal au sens où pour trouver les solutions exactes d'un système, il va falloir chercher des racines de polynômes dont les coefficients sont dans une extension algébrique de Q. Une méthode plus efficace consiste à déterminer une variable auxiliaire solution d'un polynôme, tel que toutes les variables s'expriment en fonction de cette unique variable auxiliaire, sous forme d'une fraction rationnelle (avec un dénominateur commun), c'est la représentation rationnelle univariée et c'est ce que Xcas calcule avec la commande gbasis(liste_equations,liste_variables,rur).
Après il y a toute une industrie pour calculer une base de Groebner de manière efficace. Xcas utilise l'algorithme F4 de Faugère dans une version multi-modulaire, que j'ai optimisé pendant je pense l'équivalent de 2 ans de travail à temps plein. Je ne pense pas que Maxima ait d'implémentation efficace, Matlab utilise il me semble Mupad, je ne sais pas ce qu'il en est mais ça m'étonnerait que ça soit très optimisé (ce n'est pas leur domaine principal). Sage peut utiliser plusieurs algorithmes, dont celui du moteur de calcul formel Giac de Xcas, mais je ne pense pas que ce soit l'algorithme par défaut qui appelle sans doute Singular. Maple a en principe une implémentation efficace, plus ou moins comparable en vitesse à celle de Xcas d'après mes benchmarks. Magma a aussi une implémentation efficace. Il existe certainement d'autres soft qui font ça rapidement, mais en général plutôt sur des corps finis que sur les rationnels.

Il faut aussi prendre garde sur le degré de certitude des résultats renvoyés. Faire des calculs de base de Groebner sur Q directement est inefficace, les implémentations efficaces que je connais font du multi-modulaire. Or ces implémentations ne donnent en général pas une certitude à 100% du résultat, car calculer et réduire toutes les s-paires de la base renvoyée s'avère trop couteux en temps. Sauf pour de petites bases (ce qui est le cas ici), on regarde juste quand la reconstruction modulaire par les restes chinois se stabilise, on teste que c'est encore bon avec 2 ou 3 nombres premiers supplémentaires et si c'est le cas on renvoie le résultat, et il n'y a pas forcément de message d'avertissement (en particulier si vous utilisez un logiciel closed-source comme Maple ou Magma). Dans le cas de la représentation rationnelle univariée, j'ai mis au point un algorithme assez simple de certification du résultat renvoyé, que Xcas effectue (via la commande gbasis(.,rur) ou directement via solve).
Au passage, je me suis aperçu d'une mauvaise optimisation de solve dans Xcas qui rend solve inefficace pour le 1er système de ce fil, ce sera corrigé dans les prochaines versions de Xcas, aussi je remercie l'auteur initial qui contribue ainsi à l'amélioration de Xcas !