papillon.mw

Le théorème du papillon 

> infolevel[all]:=5:
 

Q1. Des procédures géométriques 

> cercle:=proc(pt) x[pt]^2+y[pt]^2-1 end;
 

proc (pt) `+`(`*`(`^`(x[pt], 2)), `*`(`^`(y[pt], 2)), `-`(1)) end proc
 

Cette façon de coder un segment rajoute une variable, mais permet de forcer les trois points à être confondus lorsque deux d'entre eux le sont. 

> droite:=proc(pt1,pt2,mid) local T; T:=t[pt1,pt2,mid]; T*x[pt1]+(1-T)*x[pt2]-x[mid],T*y[pt1]+(1-T)*y[pt2]-y[mid] end;
 

proc (pt1, pt2, mid) local T; `assign`(T, t[pt1, pt2, mid]); `+`(`*`(T, `*`(x[pt1])), `*`(`+`(1, `-`(T)), `*`(x[pt2])), `-`(x[mid])), `+`(`*`(T, `*`(y[pt1])), `*`(`+`(1, `-`(T)), `*`(y[pt2])), `-`(y[m...
 

Q2. Le système et une base de Gröbner 

> sys:=subs(t[P,Q,M]=1/2,{seq(cercle(pt),pt=[A,B,P,Q,C,D]), seq(droite(op(segment)),segment=[[A,B,M],[P,Q,M],[C,D,M],[B,C,Y],[A,D,X],[P,M,X],[Q,M,Y]]),x[M],y[P]-y[Q],x[P]+x[Q]});
 

{x[M], `+`(x[P], x[Q]), `+`(y[P], `-`(y[Q])), `+`(`*`(`/`(1, 2), `*`(x[P])), `*`(`/`(1, 2), `*`(x[Q])), `-`(x[M])), `+`(`*`(`/`(1, 2), `*`(y[P])), `*`(`/`(1, 2), `*`(y[Q])), `-`(y[M])), `+`(`*`(`^`(x[...
{x[M], `+`(x[P], x[Q]), `+`(y[P], `-`(y[Q])), `+`(`*`(`/`(1, 2), `*`(x[P])), `*`(`/`(1, 2), `*`(x[Q])), `-`(x[M])), `+`(`*`(`/`(1, 2), `*`(y[P])), `*`(`/`(1, 2), `*`(y[Q])), `-`(y[M])), `+`(`*`(`^`(x[...
 

> vars:=op(indets(sys));
 

t[A, B, M], t[A, D, X], t[B, C, Y], t[C, D, M], t[P, M, X], t[Q, M, Y], x[A], x[B], x[C], x[D], x[M], x[P], x[Q], x[X], x[Y], y[A], y[B], y[C], y[D], y[M], y[P], y[Q], y[X], y[Y]
 

> G1:=Groebner[Basis](sys ,tdeg(vars)):
 

LowerCase: Defining mstring_lowercase
 

-> FGb
domain: rat_int_cof
 

503 polynomials, 11212 terms
total time:        10.576 sec
------------------------------
 

Q3. Appartenance à l'idéal 

> Groebner[Reduce]((x[C]+x[D]),G1,tdeg(vars));
 

`+`(x[C], x[D])
 

Donc ce n'est pas dans l'idéal. 

> testrad:=Groebner[Basis]([op(G1),1-t*(x[C]+x[D])],tdeg(vars,t)):
 

-> FGb
 

domain: rat_int_cof
 

481 polynomials, 11303 terms
total time:        10.277 sec
------------------------------
 

> evalb(testrad=[1]);
 

false
 

Ni dans le radical. 

Q4. Une base sans les cas dégénérés 

> varsrat:=op(subs(y[M]=NULL,y[A]=NULL,y[C]=NULL,[vars]));
 

t[A, B, M], t[A, D, X], t[B, C, Y], t[C, D, M], t[P, M, X], t[Q, M, Y], x[A], x[B], x[C], x[D], x[M], x[P], x[Q], x[X], x[Y], y[B], y[D], y[P], y[Q], y[X], y[Y]
 

> infolevel[all]:=2:
 

> G2:=Groebner[Basis](sys ,tdeg(varsrat)):
 

-> F4 algorithm
 

gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
 

gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M] y[C]]
gcd/LinZip:    degree bounds:  [1 1]
gcd/LinZip:    max degrees  :  [3 2]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M] y[A]]
gcd/LinZip:    degree bounds:  [1 1]
gcd/LinZip:    max degrees  :  [3 2]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [5]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [5]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
 

gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [5]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [5]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[A] y[M]]
gcd/LinZip:    degree bounds:  [1 4]
gcd/LinZip:    max degrees  :  [2 8]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[A] y[M]]
gcd/LinZip:    degree bounds:  [1 2]
gcd/LinZip:    max degrees  :  [2 4]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[A] y[M]]
gcd/LinZip:    degree bounds:  [1 2]
gcd/LinZip:    max degrees  :  [1 4]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [5]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [6]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [5]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[A] y[M]]
gcd/LinZip:    degree bounds:  [1 2]
gcd/LinZip:    max degrees  :  [3 8]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[C] y[A] y[M]]
gcd/LinZip:    degree bounds:  [1 1 2]
gcd/LinZip:    max degrees  :  [2 2 6]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [6]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
 

gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[C] y[M]]
gcd/LinZip:    degree bounds:  [1 1]
gcd/LinZip:    max degrees  :  [1 3]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[C] y[M]]
gcd/LinZip:    degree bounds:  [1 1]
gcd/LinZip:    max degrees  :  [1 4]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M] y[C]]
gcd/LinZip:    degree bounds:  [1 1]
gcd/LinZip:    max degrees  :  [4 2]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M] y[C]]
gcd/LinZip:    degree bounds:  [1 1]
gcd/LinZip:    max degrees  :  [3 2]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[A] y[M]]
gcd/LinZip:    degree bounds:  [1 2]
gcd/LinZip:    max degrees  :  [2 3]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[C] y[M]]
gcd/LinZip:    degree bounds:  [1 1]
gcd/LinZip:    max degrees  :  [1 3]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[C] y[M]]
gcd/LinZip:    degree bounds:  [1 2]
gcd/LinZip:    max degrees  :  [2 5]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[A] y[M]]
gcd/LinZip:    degree bounds:  [1 2]
gcd/LinZip:    max degrees  :  [3 9]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[C] y[M]]
gcd/LinZip:    degree bounds:  [1 2]
gcd/LinZip:    max degrees  :  [3 9]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [4]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[C] y[M]]
gcd/LinZip:    degree bounds:  [1 2]
gcd/LinZip:    max degrees  :  [3 8]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [7]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[C] y[A] y[M]]
gcd/LinZip:    degree bounds:  [2 2 4]
gcd/LinZip:    max degrees  :  [3 3 8]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [6]
gcd/LinZip: Using 8-byte integer mod
 

gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[M]]
gcd/LinZip:    degree bounds:  [2]
gcd/LinZip:    max degrees  :  [8]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Core problem
gcd/LinZip:    variables    :  [y[A] y[M]]
gcd/LinZip:    degree bounds:  [1 2]
gcd/LinZip:    max degrees  :  [2 5]
gcd/LinZip: Using 8-byte integer mod
gcd/LinZip: Using 8-byte integer mod
total time:         0.693 sec
 

> Groebner[Reduce](x[X]+x[Y],G2,tdeg(varsrat));
 

0
 

> nops(G2);
 

26
 

Q5. Les cas dégénérés 

> infolevel[all]:=0:
 

Équations de degré 2 

> select(proc(p) evalb(degree(p)=2) end,G1):
 

> select(type,map(factor,%),`*`);
 

 

Rien à voir en ce degré. 

En degré 3 

> select(type,map(factor,select(proc(p) evalb(degree(p)=3) end, G1)),`*`);
 

[`*`(`+`(y[D], `-`(y[Y])), `*`(`+`(y[C], `-`(y[Y])), `*`(`+`(x[X], x[Y])))), `*`(`+`(y[D], `-`(y[Y])), `*`(`+`(`*`(y[C], `*`(t[B, C, Y])), `*`(y[D], `*`(t[A, D, X])), `-`(`*`(t[A, D, X], `*`(y[Y]))), ...
[`*`(`+`(y[D], `-`(y[Y])), `*`(`+`(y[C], `-`(y[Y])), `*`(`+`(x[X], x[Y])))), `*`(`+`(y[D], `-`(y[Y])), `*`(`+`(`*`(y[C], `*`(t[B, C, Y])), `*`(y[D], `*`(t[A, D, X])), `-`(`*`(t[A, D, X], `*`(y[Y]))), ...
[`*`(`+`(y[D], `-`(y[Y])), `*`(`+`(y[C], `-`(y[Y])), `*`(`+`(x[X], x[Y])))), `*`(`+`(y[D], `-`(y[Y])), `*`(`+`(`*`(y[C], `*`(t[B, C, Y])), `*`(y[D], `*`(t[A, D, X])), `-`(`*`(t[A, D, X], `*`(y[Y]))), ...
[`*`(`+`(y[D], `-`(y[Y])), `*`(`+`(y[C], `-`(y[Y])), `*`(`+`(x[X], x[Y])))), `*`(`+`(y[D], `-`(y[Y])), `*`(`+`(`*`(y[C], `*`(t[B, C, Y])), `*`(y[D], `*`(t[A, D, X])), `-`(`*`(t[A, D, X], `*`(y[Y]))), ...
[`*`(`+`(y[D], `-`(y[Y])), `*`(`+`(y[C], `-`(y[Y])), `*`(`+`(x[X], x[Y])))), `*`(`+`(y[D], `-`(y[Y])), `*`(`+`(`*`(y[C], `*`(t[B, C, Y])), `*`(y[D], `*`(t[A, D, X])), `-`(`*`(t[A, D, X], `*`(y[Y]))), ...
[`*`(`+`(y[D], `-`(y[Y])), `*`(`+`(y[C], `-`(y[Y])), `*`(`+`(x[X], x[Y])))), `*`(`+`(y[D], `-`(y[Y])), `*`(`+`(`*`(y[C], `*`(t[B, C, Y])), `*`(y[D], `*`(t[A, D, X])), `-`(`*`(t[A, D, X], `*`(y[Y]))), ...
 

Le facteur -1+t[A,B,M] montre qu'il est possible d'avoir M sur le cercle, ce qui est en effet possible si P et Q sont confondus. 

Si P et Q ne sont pas confondus 

> G1bis:=Groebner[Basis]([op(G1),1-t*x[P]],tdeg(vars,t)):
 

> Groebner[Reduce](x[X]+x[Y],G1bis,tdeg(vars));
 

`+`(x[X], x[Y])
 

> select(type,map(factor,select(proc(p) degree(p)=2 end,G1bis)),`*`);
 

[`*`(`+`(y[D], `-`(y[Y])), `*`(`+`(x[X], x[Y]))), `*`(`+`(y[D], `-`(y[Y])), `*`(`+`(t[P, M, X], `-`(t[Q, M, Y])))), `*`(`+`(y[C], `-`(y[Y])), `*`(`+`(x[X], x[Y]))), `*`(`+`(y[C], `-`(y[Y])), `*`(`+`(t...
[`*`(`+`(y[D], `-`(y[Y])), `*`(`+`(x[X], x[Y]))), `*`(`+`(y[D], `-`(y[Y])), `*`(`+`(t[P, M, X], `-`(t[Q, M, Y])))), `*`(`+`(y[C], `-`(y[Y])), `*`(`+`(x[X], x[Y]))), `*`(`+`(y[C], `-`(y[Y])), `*`(`+`(t...
 

On observe l'apparition de y[D]-y[Y], c'est-à-dire le cas où CD et PQ sont confondus. De même le cas où AB et PQ sont confondus est dégénéré.  

et si PQ n'est pas confondu avec AB ou CD 

> G1ter:=Groebner[Basis]([op(G1bis),1-t2*(y[C]-y[Y])*(y[A]-y[Y])],tdeg(vars,t,t2)):
 

> Groebner[Reduce](x[X]+x[Y],G1ter,tdeg(vars,t,t2));
 

0
 

>
 

Alors le résultat est vrai ! On peut aussi mener les études des cas dégénérés.