Cat::IntegralDomain
--
the category of integral domainsCat::IntegralDomain
represents the category of integral
domains.
Cat::IntegralDomain()
Cat::EntireRing
, Cat::CommutativeRing
, Cat::Algebra(dom)
Cat::IntegralDomain
is a commutative and entire
ring which has a ``partial'' division method "_divide"
: If
b
divides a
then
dom::_divide(a,b)
must return the quotient, otherwise
FAIL
. The result of the
method "_divide"
must be unique.Ax::canonicalUnitNormal
to
state in addition that there exists a canonical unit normal form for
each element of the ring. If a ring has the axiom Ax::canonicalUnitNormal
the
method "unitNormal"
must return the unique unit normal for
a ring element. If the axiom is not valid the method may return any
associate.Ax::closedUnitNormals
in
addition to state that the unit normals which are computed by the
method "unitNormal"
are closed under multiplication, i.e.
that the product of two unit normals returns a unit normal.Cat::IntegralDomain
because there are integral domains for
which one can't compute a canonical unit normal for each element._divide(dom x, dom
y)
d
such that x
=
d * y
or FAIL
if such a quotient does not exist.
The quotient is unique if it exists.y * dom::_divide(x,y)
must be equal to
x
provided that y
is not zero and
y
divides x
,x
is equal to y * z
then
y
must divide x
.y
is zero.isUnit(dom x)
TRUE
if
x
is an unit of the ring.unitNormal(dom x)
x
.Ax::canonicalUnitNormal
the
method must return the unique unit normal of x
.Ax::canonicalUnitNormal
: In
this case simply x
is returned.associates(dom x, dom
y)
TRUE
if
x
and y
are associates. The implementation
provided here uses the method "divides"
to test if each
argument divides the other.divides(dom x, dom
y)
TRUE
if
x
divides y
. The implementation uses the
method "_divide"
to test if x
divides
y
.unitNormalRep(dom x)
[n, u, v]
where n
is a
unit normal form of x
, u
is a unit such that
n
= u * x
and v
is the inverse
of u
.Ax::canonicalUnitNormal
the
method must return the unique unit normal of x
. The
default implementation uses the method "unitNormal"
to
compute the unit normal n
in this case.Ax::canonicalUnitNormal
the
method simply returns [x, dom::one, dom::one]
.