# Equation S¶

equation1.spad line 48

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

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 Ring or S has Group

VectorSpace S if S has Field