1 | initial version |

The explanation can be found in the documentation for `QuotientRing`

:

ASSUMPTION:

`I`

has a method`I.reduce(x)`

returning the normal form of elements $x \in R$. In other words, it is required that`I.reduce(x)==I.reduce(y)`

$\iff x-y \in I$, and`x-I.reduce(x) in I`

, for all $x,y \in R$.

That is, elements of a `QuotientRing`

are represented by normal forms (usually obtained by polynomial division).

We can see that $(2) \subset \mathbf{Z}[x]$ in Sage does not possess such a method:

```
R.<x> = ZZ[]
I = R.ideal(2)
I.reduce??
```

This shows the source code of `I.reduce`

which is the default implementation `lambda f: return f`

, which doesn't satisfy the property that `QuotientRing`

assumes: e.g. `I.reduce(2) != I.reduce(0)`

but $2 \in I$.

The implementation of `I.reduce`

is the same for `I = R.ideal(2,x)`

which explains your last result.

Note that $\mathbf{Z}[x]$ is not a Euclidean ring because not every ideal is principal (e.g. the ideal $(2,x)$ is a non-principal), so it is impossible to have a normal form for elements in a quotient via polynomial division in $\mathbf{Z}[x]$ in general. Also $\mathbf{Z}[x]$ is not the type of ring where one can have a Groebner basis.

Of course not all is lost, because the ideals you consider are nice enough, e.g. $\mathbf{Z}[x]/(2) \cong \mathbf{F}_2[x]$ and $\mathbf{Z}[x]/(2,x) \cong \mathbf{F}_2[x]/(x) \cong \mathbf{F}_2$ and the objects on the right-hand sides *can* be represented easily in Sage:

```
sage: (2*t1 + a*t2).change_ring(GF(2)[a])
a*t2
sage: (2*t1 + a*t2).change_ring(GF(2)[a].quotient(a))
0
```

Or, if you prefer the name `abar`

for the image of `a`

in the quotient:

```
sage: S.<abar> = GF(2)[]
sage: (2*t1 + a*t2).change_ring(S)
abar*t2
sage: (2*t1 + a*t2).change_ring(S.quotient(abar))
0
```

2 | No.2 Revision |

The explanation can be found in the documentation for `QuotientRing`

:

ASSUMPTION:

`I`

has a method`I.reduce(x)`

returning the normal form of elements $x \in R$. In other words, it is required that`I.reduce(x)==I.reduce(y)`

$\iff x-y \in I$, and`x-I.reduce(x) in I`

, for all $x,y \in R$.

That is, elements of a `QuotientRing`

are represented by normal forms (usually obtained by polynomial division).

We can see that $(2) \subset \mathbf{Z}[x]$ in Sage does not possess such a method:

```
R.<x> = ZZ[]
I = R.ideal(2)
I.reduce??
```

This shows the source code of `I.reduce`

which is the default implementation `lambda f: return f`

, which doesn't satisfy the property that `QuotientRing`

assumes: e.g. `I.reduce(2) != I.reduce(0)`

but $2 \in I$.

The implementation of `I.reduce`

is the same for `I = R.ideal(2,x)`

which explains your last result.

Note that $\mathbf{Z}[x]$ is not a Euclidean ring because not every ideal is principal (e.g. the ideal $(2,x)$ is a non-principal), so it is impossible to have a normal form for elements in a quotient via polynomial division in $\mathbf{Z}[x]$ in general. ~~Also $\mathbf{Z}[x]$ is not the type of ring where one can have a ~~There is a theory of Groebner ~~basis.~~bases for polynomial rings over PIDs which would apply to $\mathbf{Z}[x]$, but it doesn't seem to be implemented in Sage.

Of course not all is lost, because the ideals you consider are nice enough, e.g. $\mathbf{Z}[x]/(2) \cong \mathbf{F}_2[x]$ and $\mathbf{Z}[x]/(2,x) \cong \mathbf{F}_2[x]/(x) \cong \mathbf{F}_2$ and the objects on the right-hand sides *can* be represented easily in Sage:

```
sage: (2*t1 + a*t2).change_ring(GF(2)[a])
a*t2
sage: (2*t1 + a*t2).change_ring(GF(2)[a].quotient(a))
0
```

Or, if you prefer the name `abar`

for the image of `a`

in the quotient:

```
sage: S.<abar> = GF(2)[]
sage: (2*t1 + a*t2).change_ring(S)
abar*t2
sage: (2*t1 + a*t2).change_ring(S.quotient(abar))
0
```

3 | No.3 Revision |

The explanation can be found in the documentation for `QuotientRing`

:

ASSUMPTION:

`I`

has a method`I.reduce(x)`

returning the normal form of elements $x \in R$. In other words, it is required that`I.reduce(x)==I.reduce(y)`

$\iff x-y \in I$, and`x-I.reduce(x) in I`

, for all $x,y \in R$.

That is, elements of a `QuotientRing`

are represented by normal forms (usually obtained by polynomial division).

We can see that $(2) \subset \mathbf{Z}[x]$ in Sage does not possess such a method:

```
R.<x> = ZZ[]
I = R.ideal(2)
I.reduce??
```

This shows the source code of `I.reduce`

which is the default implementation `lambda f: return f`

, which doesn't satisfy the property that `QuotientRing`

assumes: e.g. `I.reduce(2) != I.reduce(0)`

but $2 \in I$.

The implementation of `I.reduce`

is the same for `I = R.ideal(2,x)`

which explains your last result.

Note that $\mathbf{Z}[x]$ is not a Euclidean ring because not every ideal is principal (e.g. the ideal $(2,x)$ is a non-principal), so it is impossible to have a normal form for elements in a quotient via polynomial division in $\mathbf{Z}[x]$ in general. There is a theory of Groebner bases for univariate polynomial rings over PIDs which would apply to $\mathbf{Z}[x]$, but it doesn't seem to be implemented in Sage.

Of course not all is lost, because the ideals you consider are nice enough, e.g. $\mathbf{Z}[x]/(2) \cong \mathbf{F}_2[x]$ and $\mathbf{Z}[x]/(2,x) \cong \mathbf{F}_2[x]/(x) \cong \mathbf{F}_2$ and the objects on the right-hand sides *can* be represented easily in Sage:

```
sage: (2*t1 + a*t2).change_ring(GF(2)[a])
a*t2
sage: (2*t1 + a*t2).change_ring(GF(2)[a].quotient(a))
0
```

Or, if you prefer the name `abar`

for the image of `a`

in the quotient:

```
sage: S.<abar> = GF(2)[]
sage: (2*t1 + a*t2).change_ring(S)
abar*t2
sage: (2*t1 + a*t2).change_ring(S.quotient(abar))
0
```

4 | No.4 Revision |

The explanation can be found in the documentation for `QuotientRing`

:

ASSUMPTION:

`I`

has a method`I.reduce(x)`

returning the normal form of elements $x \in R$. In other words, it is required that`I.reduce(x)==I.reduce(y)`

$\iff x-y \in I$, and`x-I.reduce(x) in I`

, for all $x,y \in R$.

`QuotientRing`

are represented by normal forms (usually obtained by polynomial division).

We can see that $(2) \subset \mathbf{Z}[x]$ in Sage does not possess such a method:

```
R.<x> = ZZ[]
I = R.ideal(2)
I.reduce??
```

`I.reduce`

which is the default implementation `lambda f: return f`

, which doesn't satisfy the property that `QuotientRing`

assumes: e.g. `I.reduce(2) != I.reduce(0)`

but $2 \in I$.

The implementation of `I.reduce`

is the same for `I = R.ideal(2,x)`

which explains your last result.

Note that $\mathbf{Z}[x]$ is not a Euclidean ring because not every ideal is principal (e.g. the ideal $(2,x)$ is a non-principal), so it is impossible to have a normal form for elements in a quotient via naive polynomial division in ~~$\mathbf{Z}[x]$ ~~$\mathbf{Z}[x]$, in general. There is a theory of Groebner bases for univariate polynomial rings over PIDs which would apply to $\mathbf{Z}[x]$, but it doesn't seem to be implemented in Sage.

*can* be represented easily in Sage:

```
sage: (2*t1 + a*t2).change_ring(GF(2)[a])
a*t2
sage: (2*t1 + a*t2).change_ring(GF(2)[a].quotient(a))
0
```

Or, if you prefer the name `abar`

for the image of `a`

in the quotient:

```
sage: S.<abar> = GF(2)[]
sage: (2*t1 + a*t2).change_ring(S)
abar*t2
sage: (2*t1 + a*t2).change_ring(S.quotient(abar))
0
```

Copyright Sage, 2010. Some rights reserved under creative commons license. Content on this site is licensed under a Creative Commons Attribution Share Alike 3.0 license.