# Equation SΒΆ

- S: Type

Equations as mathematical objects. All properties of the basis domain, e.g. being an abelian group are carried over the equation domain, by performing the structural operations on the left and on the right hand side.

- 0: % if S has AbelianGroup
- from AbelianMonoid
- 1: % if S has Monoid
- from MagmaWithUnit
- *: (%, %) -> % if S has SemiGroup
- from Magma

- *: (%, S) -> % if S has SemiGroup
`eqn*x`

produces a new equation by multiplying both sides of equation eqn by`x`

.- *: (Integer, %) -> % if S has AbelianGroup
- from AbelianGroup
- *: (NonNegativeInteger, %) -> % if S has AbelianGroup
- from AbelianMonoid
- *: (PositiveInteger, %) -> % if S has AbelianSemiGroup
- from AbelianSemiGroup

- *: (S, %) -> % if S has SemiGroup
`x*eqn`

produces a new equation by multiplying both sides of equation eqn by`x`

.- +: (%, %) -> % if S has AbelianSemiGroup
- from AbelianSemiGroup

- +: (%, S) -> % if S has AbelianSemiGroup
`eqn+x`

produces a new equation by adding`x`

to both sides of equation eqn.

- +: (S, %) -> % if S has AbelianSemiGroup
`x+eqn`

produces a new equation by adding`x`

to both sides of equation eqn.- -: % -> % if S has AbelianGroup
- from AbelianGroup
- -: (%, %) -> % if S has AbelianGroup
- from AbelianGroup

- -: (%, S) -> % if S has AbelianGroup
`eqn-x`

produces a new equation by subtracting`x`

from both sides of equation eqn.

- -: (S, %) -> % if S has AbelianGroup
`x-eqn`

produces a new equation by subtracting both sides of equation eqn from`x`

.

- /: (%, %) -> % if S has Group or S has Field
`e1/e2`

produces a new equation by dividing the left and right hand sides of equations`e1`

and`e2`

.- /: (%, S) -> % if S has Field
- from VectorSpace S
- =: (%, %) -> Boolean if S has SetCategory
- from BasicType

- =: (S, S) -> %
`a=b`

creates an equation.- ^: (%, Integer) -> % if S has Group
- from Group
- ^: (%, NonNegativeInteger) -> % if S has Monoid
- from MagmaWithUnit
- ^: (%, PositiveInteger) -> % if S has SemiGroup
- from Magma
- ~=: (%, %) -> Boolean if S has SetCategory
- from BasicType
- annihilate?: (%, %) -> Boolean if S has Ring
- from Rng
- antiCommutator: (%, %) -> % if S has Ring
- from NonAssociativeSemiRng
- associator: (%, %, %) -> % if S has Ring
- from NonAssociativeRng
- characteristic: () -> NonNegativeInteger if S has Ring
- from NonAssociativeRing
- coerce: % -> Boolean if S has SetCategory
- from CoercibleTo Boolean
- coerce: % -> OutputForm if S has SetCategory
- from CoercibleTo OutputForm
- coerce: Integer -> % if S has Ring
- from NonAssociativeRing
- commutator: (%, %) -> % if S has Ring or S has Group
- from NonAssociativeRng
- conjugate: (%, %) -> % if S has Group
- from Group
- D: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- D: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- D: (%, Symbol) -> % if S has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- D: (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: (%, Symbol) -> % if S has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- dimension: () -> CardinalNumber if S has Field
- from VectorSpace S

- equation: (S, S) -> %
`equation(a, b)`

creates an equation.

- eval: (%, %) -> % if S has Evalable S and S has SetCategory
`eval(eqn, x=f)`

replaces`x`

by`f`

in equation`eqn`

.

- eval: (%, List %) -> % if S has Evalable S and S has SetCategory
`eval(eqn, [x1=v1, ... xn=vn])`

replaces`xi`

by`vi`

in equation`eqn`

.- eval: (%, List Symbol, List S) -> % if S has InnerEvalable(Symbol, S)
- from InnerEvalable(Symbol, S)
- eval: (%, Symbol, S) -> % if S has InnerEvalable(Symbol, S)
- from InnerEvalable(Symbol, S)

- factorAndSplit: % -> List % if S has IntegralDomain
`factorAndSplit(eq)`

make the right hand side 0 and factors the new left hand side. Each factor is equated to 0 and put into the resulting list without repetitions.- hash: % -> SingleInteger if S has SetCategory
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState if S has SetCategory
- from SetCategory

- inv: % -> % if S has Group or S has Field
`inv(x)`

returns the multiplicative inverse of`x`

.- latex: % -> String if S has SetCategory
- from SetCategory

- leftOne: % -> Union(%, failed) if S has Monoid
`leftOne(eq)`

divides by the left hand side, if possible.- leftPower: (%, NonNegativeInteger) -> % if S has Monoid
- from MagmaWithUnit
- leftPower: (%, PositiveInteger) -> % if S has SemiGroup
- from Magma
- leftRecip: % -> Union(%, failed) if S has Monoid
- from MagmaWithUnit

- leftZero: % -> % if S has AbelianGroup
`leftZero(eq)`

subtracts the left hand side.

- lhs: % -> S
`lhs(eqn)`

returns the left hand side of equation`eqn`

.

- map: (S -> S, %) -> %
`map(f, eqn)`

constructs a new equation by applying`f`

to both sides of eqn.- one?: % -> Boolean if S has Monoid
- from MagmaWithUnit
- opposite?: (%, %) -> Boolean if S has AbelianGroup
- from AbelianMonoid
- recip: % -> Union(%, failed) if S has Monoid
- from MagmaWithUnit

- rhs: % -> S
`rhs(eqn)`

returns the right hand side of equation`eqn`

.

- rightOne: % -> Union(%, failed) if S has Monoid
`rightOne(eq)`

divides by the right hand side, if possible.- rightPower: (%, NonNegativeInteger) -> % if S has Monoid
- from MagmaWithUnit
- rightPower: (%, PositiveInteger) -> % if S has SemiGroup
- from Magma
- rightRecip: % -> Union(%, failed) if S has Monoid
- from MagmaWithUnit

- rightZero: % -> % if S has AbelianGroup
`rightZero(eq)`

subtracts the right hand side.- sample: % if S has Monoid or S has AbelianGroup
- from AbelianMonoid

- subst: (%, %) -> % if S has ExpressionSpace
`subst(eq1, eq2)`

substitutes`eq2`

into both sides of`eq1`

the`lhs`

of`eq2`

should be a kernel- subtractIfCan: (%, %) -> Union(%, failed) if S has AbelianGroup
- from CancellationAbelianMonoid

- swap: % -> %
`swap(eq)`

interchanges left and right hand side of equation`eq`

.- zero?: % -> Boolean if S has AbelianGroup
- from AbelianMonoid

AbelianGroup if S has AbelianGroup

AbelianMonoid if S has AbelianGroup

AbelianSemiGroup if S has AbelianSemiGroup

BasicType if S has SetCategory

CancellationAbelianMonoid if S has AbelianGroup

CoercibleTo Boolean if S has SetCategory

CoercibleTo OutputForm if S has SetCategory

InnerEvalable(Symbol, S) if S has InnerEvalable(Symbol, S)

LeftModule % if S has Ring

LeftModule S if S has Ring

MagmaWithUnit if S has Monoid

Module S if S has CommutativeRing

NonAssociativeRing if S has Ring

NonAssociativeRng if S has Ring

NonAssociativeSemiRing if S has Ring

NonAssociativeSemiRng if S has Ring

PartialDifferentialRing Symbol if S has PartialDifferentialRing Symbol

RightModule % if S has Ring

RightModule S if S has Ring

SetCategory if S has SetCategory

unitsKnown if S has Ring or S has Group

VectorSpace S if S has Field