## `Cat::IntegralDomain` -- the category of integral domains

#### Introduction

`Cat::IntegralDomain` represents the category of integral domains.

#### Generating the category

`Cat::IntegralDomain()`

#### Categories

`Cat::EntireRing`

, `Cat::CommutativeRing`, `Cat::Algebra(dom)`

#### Details

- An `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.
- Use the axiom `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.
- Use the axiom `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.
- These two axioms are not implizitly valid for an `Cat::IntegralDomain` because there are integral domains for which one can't compute a canonical unit normal for each element.

#### Method _divide: returns quotient

- `_divide(dom x, dom y)`
- - Must return the quotient `d` such that `x` = `d * y` or `FAIL` if such a quotient does not exist. The quotient is unique if it exists.
  - The result must be unique:
    1. the product `y * dom::_divide(x,y)` must be equal to `x` provided that `y` is not zero and `y` divides `x`,
    2. if `x` is equal to `y * z` then `y` must divide `x`.
  - It is an error if `y` is zero.

#### Method isUnit: tests if element is a unit

- `isUnit(dom x)`
- - Must return `TRUE` if `x` is an unit of the ring.

#### Method unitNormal: returns an associate

- `unitNormal(dom x)`
- - Must return an associate of `x`.
  - If the ring has the axiom `Ax::canonicalUnitNormal` the method must return the unique unit normal of `x`.
  - An implementation is provided if the ring has not the axiom `Ax::canonicalUnitNormal`: In this case simply `x` is returned.

#### Method associates: tests if elements are associates

- `associates(dom x, dom y)`
- - Returns `TRUE` if `x` and `y` are associates. The implementation provided here uses the method `"divides"` to test if each argument divides the other.

#### Method divides: tests if elements divides another

- `divides(dom x, dom y)`
- - Returns `TRUE` if `x` divides `y`. The implementation uses the method `"_divide"` to test if `x` divides `y`.

#### Method unitNormalRep: returns the unit normal representation

- `unitNormalRep(dom x)`
- - Returns a list `[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`.
  - If the ring has the axiom `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.
  - If the ring dos not have the axiom `Ax::canonicalUnitNormal` the method simply returns `[x, dom::one, dom::one]`.

#### Changes

- no changes

Do you have questions or comments?
Copyright © SciFace Software GmbH & Co. KG 2000