#!/usr/bin/env python
# coding: utf-8

# # TD 2
# 
# ## Exo 1.3

# In[1]:


A.<x> = ZZ[]


# In[2]:


P = x^7 + x^5 + 2*x^3 + 2*x^2 + 3*x + 2
P


# In[3]:


P.change_ring(GF(2)).factor()


# In[4]:


P.change_ring(GF(7)).factor()


# On voit que soit $P$ est irreductible, soit il a une racine congrue à $-4 \bmod 14$. On vérifie aisément que $P(x) > 0$ si $x>0$. On vérifie aussi que $P(-4)$ n'est pas racine:

# In[5]:


P(-4)


# Reste à vérifier que $P(-4 - c·14) ≠ 0$ pour tout $c>1$. Exercice.

# In[12]:


P.is_irreducible()


# ## Exo 1.4

# In[13]:


p = 2
k = GF(p)
A.<X> = k[]
for a in k:
    print((x^p - x + a).factor())


# In[14]:


p = 3
k = GF(p)
A.<X> = k[]
for a in k:
    print((x^p - x + a).factor())


# In[15]:


p = 5
k = GF(p)
A.<X> = k[]
for a in k:
    print((x^p - x + a).factor())


# In[16]:


p = 7
k = GF(p)
A.<X> = k[]
for a in k:
    print((x^p - x + a).factor())


# On conjecture que $x^p - x + c$ est scindé pour $c=0$ (facile) et irréductible pour $c≠0$ (plus dur).

# ## Exo 2.1

# In[17]:


A.<x,y> = QQ[]


# In[18]:


P = x*y^5 + 2*y^4 + 3*y^3*x^3 + 4*x^2*y^2 + 5*x*y^2 + 6*y*x^3 + 7*y
P


# In[19]:


P.degree()


# In[20]:


Q = P.polynomial(x)
Q


# In[21]:


Q.parent()


# In[22]:


B = QQ['y']['x']
B


# In[23]:


B(P)


# Attention, le nom des variables doit être exactement le même pour que Sage accepte de faire la conversion.

# In[24]:


C = QQ['Y']['X']
C


# In[25]:


C(P)


# ## Exo 2.2

# In[26]:


A.<x,y> = QQ[]
P = (x^2 + x*y + x + y) * (x + y)
P


# In[27]:


fac = P.factor()
fac


# Attention: en Sage, une "factorisation" est un objet différent d'un polynôme.

# In[28]:


parent(fac)


# In[29]:


type(fac)


# In[30]:


fac in A


# In[31]:


e = fac.expand()
e


# In[32]:


e in A


# In[33]:


P.polynomial(x)


# In[34]:


P.polynomial(y)


# ## Exo 3.1

# In[35]:


A.<x,y> = QQ[]
P = x*y^5 + 2*y^4 + 3*y^3*x^3 + 4*x^2*y^2 + 5*x*y^2 + 6*y*x^3 + 7*y
P


# In[36]:


B.<x,y> = PolynomialRing(QQ, order='lex')
B


# In[37]:


B.term_order()


# In[38]:


A.term_order()


# In[39]:


B(P)


# In[40]:


C = A.change_ring(order='deglex')
C


# In[41]:


C.term_order()


# In[42]:


C(P)


# In[43]:


P


# In[44]:


P.parent().term_order()


# In[45]:


get_ipython().run_line_magic('display', 'latex')


# In[46]:


A.<x,y,z,t> = QQ[]
Q = x*y^3*z*t + x^2*y*z^3*t + x^2*y*z^2*t + x^3*z^2*t^2
Q


# In[47]:


A.change_ring(order='lex')(Q)


# In[48]:


A.change_ring(order='deglex')(Q)


# ## Exo 3.4

# In[49]:


A.<x,y> = PolynomialRing(QQ, order='lex')
g = x - y
h = x - y^2
p = x*y - x


# In[50]:


g, h, p


# In[51]:


p.reduce([g, h])


# In[52]:


p.reduce([h, g])


# Le résultat de `reduce` n'est pas uniquement défini si la liste des polynômes passés ne forme pas une base de Gröbner. Ceci est précisé dans la doc

# In[53]:


help(p.reduce)


# On retrouve facilement quel est le calcul qui a été fait par `reduce`

# In[54]:


p.mod(h)


# In[55]:


p.mod(g)


# In[56]:


p.mod(h).mod(g)


# In[57]:


p.mod(g).mod(h)


# On pourrait croire que `reduce` reduit modulo la liste de polynômes dans l'ordre dans lequel ils sont donnés, c'est plus compliqué que cela, cependant. Dans cet exemple, on voit que le résultat n'est pas canonique, mais ne depend pas de l'ordre.

# In[58]:


g = x^2*y^2 - x
h = x*y^2 + y


# In[59]:


g.reduce([g,h])


# In[60]:


h.reduce([g,h])


# In[61]:


g.reduce([h,g])


# In[62]:


A.ideal([g,h]).reduce(g)


# In[63]:


g.mod([g,h])


# ## Exo 3.6

# In[64]:


get_ipython().run_line_magic('display', 'plain')


# In[65]:


A.<x,y> = PolynomialRing(QQ, order='lex')
f = x^7*y^2 + x^3*y^2 - y - 1


# In[66]:


f1 = x*y^2 - x
f2 = x - y^3


# In[67]:


I = A.ideal([f1, f2])
I


# Cette fois-ci la réduction calcule bien une base de Gröbner

# In[69]:


I.reduce(f)


# In[70]:


f.mod(I)


# In[71]:


f.mod([f1, f2])


# In[72]:


B = A.change_ring(order='deglex')
B


# In[73]:


J = I.change_ring(B)
J


# In[74]:


g = B(f).mod(J)
g


# In[75]:


g.parent().term_order()


# In[76]:


f.mod([f2, f1])


# In[77]:


I2 = A.ideal([f2, f1])


# In[78]:


f.mod(I2)


# ## Exo 3.7

# In[79]:


A.<x,y,z> = QQ[]
p = z^2 - x^4*y
g1, g2 = y - x^2, z - x^3
I = A.ideal([g1, g2])
I


# In[80]:


p in I


# In[81]:


p.mod(I)


# In[82]:


a, b = p.lift(I)
a, b


# In[83]:


a*g1 + b*g2 == p


# In[ ]: