# Equation SΒΆ

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`.

=: (%, %) -> 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
associator: (%, %, %) -> % if S has Ring
characteristic: () -> NonNegativeInteger if S has Ring
coerce: % -> Boolean if S has SetCategory
coerce: % -> OutputForm if S has SetCategory
coerce: Integer -> % if S has Ring
commutator: (%, %) -> % if S has Group or S has Ring
conjugate: (%, %) -> % if S has Group

from Group

convert: % -> InputForm if S has ConvertibleTo InputForm
D: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol
D: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
D: (%, Symbol) -> % if S has PartialDifferentialRing Symbol
D: (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
differentiate: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol
differentiate: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
differentiate: (%, Symbol) -> % if S has PartialDifferentialRing Symbol
differentiate: (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
equation: (S, S) -> %

`equation(a, b)` creates an equation.

eval: (%, %) -> % if S has SetCategory and S has Evalable S

`eval(eqn, x=f)` replaces `x` by `f` in equation `eqn`.

eval: (%, List %) -> % if S has SetCategory and S has Evalable S

`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.

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
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

BiModule(%, %) if S has Ring

BiModule(S, S) if S has Ring

CoercibleTo Boolean if S has SetCategory

CoercibleTo OutputForm if S has SetCategory

Group if S has Group

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

LeftModule % if S has Ring

LeftModule S if S has Ring

Magma if S has SemiGroup

MagmaWithUnit if S has Monoid

Module S if S has CommutativeRing

Monoid if S has Monoid

NonAssociativeRing if S has Ring

NonAssociativeRng if S has Ring

NonAssociativeSemiRing if S has Ring

NonAssociativeSemiRng if S has Ring

RightModule % if S has Ring

RightModule S if S has Ring

Ring if S has Ring

Rng if S has Ring

SemiGroup if S has SemiGroup

SemiRing if S has Ring

SemiRng if S has Ring

SetCategory if S has SetCategory

TwoSidedRecip if S has Group

unitsKnown if S has Group or S has Ring