Context may introduce various kinds of operation which it may chose to
describe as addition, subtraction, multiplication and division, along with
assorted combiners related to these. A given context may have several distinct
collections of values on each of which it uses different combiners in these
diverse rôles. Different contexts may, on some specific collection of
values, give meaning to different combiners as addition
; to some degree
this shall control what combiners it makes sense to construe in the other
rôles, but (see below) as many as three combiners may be involved
as multiplication
of one kind or another. I leave it to context to make
clear which combiners fill which rôles: in the following, I only set out
what is generally true, with illustrations drawn from linear algebra (the
principal form of arithmetic).
In all contexts, I presume that addition is Abelian (a.k.a. commutative) – so a+b and b+a shall be equal – and associative – so a+(b+c) and (a+b)+c shall be equal (whenever meaningful; and, if either is meaningful, so is the other). Two of the multiplications shall also be associative (as noted where I introduce them) and associate with one another, in the sense: when (a.b)&tensor;c and a.(b&tensor;c) are both meaningful (which requires a to be scalar), they are equal; likewise for a×(b.c) and (a×b).c (where c must be scalar for both to be meaningful). Some analogous conditions are often true for the third multiplication, contraction, but it has complications.
For the most part, I shall shadow the orthodox denotations for
arithmetic. In particular, enclosures bound
the parsing of arithmetic expressions – i.e. no matter what text
surrounds (a+b)
, that text merely sees this
as (expression)
, with no possibility of combining a or b
with something outside the (…)
to obtain things to subsequently
combine using the + seen here;
likewise, a−(expression)×b makes sense of
the expression as an atom
to be combined
with a and b in the manner indicated by the text outside
the (…).
I'll also (as described under + below) use the
usual precedence
rules, in which multiplicative operations (including
division) are done first
(after enclosure), then additive ones (including
subtraction), before finally applying other patterns. For these purposes,
negation (the use of − as a unary operator) is treated as a multiplicative
operator (so it's treated as multiply by −1
even when there's no
multiplication involved or might not even by a 1, much less a −1, by which
to multiply anything); albeit I usually include the (formally unnecessary)
parentheses in that case for clarity's sake.
Aside from the unary form of the additive operators (see below), all the
arithmetic operators are binary operators
– they combine two
values, known as the operands
of the binary operator; see the definition
of operand, below.
I first introduce some terminology. The definitions here build on those for operators and, like them, merely formalise what anyone familiar with English usage of the words already understands by them.
In general, a sub-type of operator; in any given context, a particular
operator of this type. (Usually, I shall reserve use of this
for flat, commutative, cancellable
combiners; if I use it for anything else, I hope I shall remember to make
clear how the use departs from that usual case.) Introducing an operator of
this type – e.g. as an addition
or simply as addition
– implicitly declares (except in so far as the introduction explicitly
says otherwise) that:
Note, however, that the division by non-zero whole numbers (and
consequent multiplication by ratios) that arises from cancellation of natural
scaling (induced by repeated addition) may be ambiguous unless scaling by
positive naturals is cancellable; for example, the addition of angles, when
understood modulo whole turns, only supports ambiguous subdivision; scaling two
angles by positive natural n, when the angles differ by a multiple of turn/n,
gives the same
answer, so subdivision by n is ambiguous modulo
turn/n. (Angles are not always understood modulo the turn – when winding
a clock, for example, each whole turn makes a material difference – but
many contexts, thanks to trigonometry, do so.)
An adjectival type qualifier. Describing an operator as additive asserts the presence of a suitable addition and declares the operator to be: that addition, its associated cancellation or an associated ± operator (see below).
This ultimately does no more than announce how the reader is to interpret
the operator's relationship to context; it says that the operator shall be
interepreted as addition, the cancellation associated with that addition
(a.k.a. subtraction) or the equivalent of (some reading of) the ±
operator, below. Introducing a symbol, not normally interpreted as a name or
number, with the assertion that it is (simply) additive implicitly asserts (by
default) that it is also an operator (i.e. if this qualifier is used without
overtly qualifying something else, the type operator
is implicit).
Where a generic type (e.g. identity or inverse) is specified in terms of an
operator, qualifying it with additive specifies
that it is to be understood in terms of context's addition. Thus, in a context
involving several operators: declaring some value z to be an additive
identity
asserts that, for all relevant x, z+x = x = x+z; declaring some
value y to be an additive left-inverse for
some value x asserts that y+x
is an additive identity; declaring some collection, S, of values to form an
additive group
asserts that the restriction, to S, of context's addition
constitutes a group.
In general, a sub-type of operator; in any given context, a particular
operator of this type. Asserting that an operator is of this type does not
assert that it is associative (so (a×(b×c) and (a×b)×c
need not be equal), commutative (so a×b and b×a need not be equal)
or cancellable (so a×b = a×c
need not imply b = c
);
nor does it assert, where an addition is defined, that the multiplication
distributes over it (i.e. a×(b +c) = a×b +a×c) or that the
multiplication commutes with scaling (by naturals, integers, rationals and the
like, as inferred from repeated addition), albeit these (especially
distributivity) are among the properties I commonly shall establish for
an operator after asserting that it is a multiplication. Introducing an
operator of this type, e.g. as a multiplication
or simply
as multiplication
, implicitly declares that:
Note that scalar and tensor multiplications typically are cancellable, whereas contraction generally isn't (except in the one-dimensional case).
An adjectival type qualifier. Describing an operator as multiplicative asserts the presence of some suitable addition over which the operator distributes. (Consequently, negation and other homomorphisms of an addition can be described as multiplicative, even when no actual multiplication is involved.)
As for additive
, this does little more than tell the reader how to
think about the operator, in the context that so describes it. Introducing a
symbol, not normally interpreted as a name or number, with the assertion that it
is (simply) multiplicative implicitly asserts (by default) that it is also an
operator (i.e. if this qualifier is used without overtly qualifying something
else, the type operator
is implicit).
When a generic type (e.g. identity or inverse) is specified in terms of an
operator, qualifying it with multiplicative
specifies that it is to be understood in terms of some multiplication pertinent
to the context. Where several multiplications are involved, this type qualifier
usually relates to those denoted with . rather than · or × (see
below), although context may apply it to any pertinent multiplication by making
clear which it relates to. Thus, in linear algebra, the scalar 1 serves as a
multiplicative identity for scaling; one could construe the identity linear map
on a space as a multiplicative identity for various contractions, but this
identity map is synonymous with scaling by 1, making this a superfluous
construction. Likewise, half is a multiplicative inverse for 2 (as scalars) and
it is usual to deal with linear spaces in which non-zero scalings form a group,
hence each non-zero scalar has a multiplicative inverse; whereas, when a linear
map has an inverse, this is typically exceptional enough to be worth
some other introduction than simply terming it a multiplicative inverse for
contraction (for all that it is, indeed, this). None the less, in the case of a
one-dimensional space over a field, each non-zero value v does indeed have a
multiplicative inverse under contraction (that, by contraction, can even be used
to invert
v&tensor;x ←x) and it does make sense to denote this as
left- or right- division by v, exactly as for scalars.
addition: denotes the result of
adding left
and right
together. Both left
and right must be expressions denoting values;
context must have supplied a meaning for addition of such values as these
expressions may take. Applying this operator is described by the verb to
add
and the operator itself is pronounced plus
when reading a text
using it; so a text that adds x to y
is written x +y
and
pronounced x plus y
.
The type of the operands shall dictate what meaning add
has. Since
overlapping contexts may define different meanings for add
, it is
important to note what kind of values the expressions have. Usually, the two
operands shall be of the same kind
(e.g. both members of some given
vector space) but they may be of some closely related kind (e.g. a position in
some Euclidean space and a displacment within that space; or a scalar and a
linear endomorphism).
subtraction: denotes that which, if added
to right, shall
yield left. Asserts that there is some
value meeting this criterion. Applying this operator is described by the
verb to subtract
and the operator itself is pronounced minus
when
reading a text using it.
The addition implicated by an expression of this form depends on the type of the operands. For example, when left and right are positions in some Euclidean space (or, for that matter, addresses in the memory-space of a computer program), left−right is a displacement within the Euclidean space (or address space); crucially, it might not be of the same kind as left and right, but adding it to anything of the same kind as right shall usually yield something of the same kind as left (though a finite computer might run into out-of-range problems dealing with the result; and some displacements within a bounded Euclidean region might step outside the space if added to a position near the boundary).
the plus-or-minus
operator: provides for ambiguous
denotations. Asserts that the types of left
and right allow for expressions of
both left+right
and left−right
forms, for at least some values of the respective types, even if no such value
actually exists for the particular values given (e.g. 3 ±5 is a valid
expression even within the naturals, where 3 −5 is not; see below for how
this is handled). Also asserts that there is some value satisfying the
relevant conditions for the meaning below.
In algebraic, and most other non-statistical mathematical contexts, this
(ambiguously)
denotes either left−right
or left+right
;
that is, one of a quite specific pair of values. However, in statistics and
other practical sciences, it denotes a value which differs
from left by an amount constrained
by right; the constraint generally takes one of
two forms:
standard deviationof some (probability or likelihood) distribution on the difference between the denoted value and left; or
Note that the standard deviation form is often treated as a special case of the last form, with the threshold being approximately 0.318 (the probability that a Gaussian random variate lies more than one standard deviation from its mean), at least when the distribution of the variate involved is reasonably symmetric about its relevant average.
When there is no value x for which left = x +right, context has no meaning for left−right. In such a case, absent constraints on addition, the algebraic reading of left±right reduces simply to left+right, the one extant value matching the specification. For algebraic use in cases where the addition is also limited (e.g. a bounded Euclidean region and the displacements within it) either or both of the denoted expressions may be unrealisable in this way; the denotation then stands for either of them if both exists or for the one that exists; and asserts that at least one does. A statistical reading, in contrast, is not affected by such a lack: its range of values, that differ from left by at most right, can be characterised (in any case) as all those values x for which x ≤ left +right and left ≤ x +right. The lack of any value attaining one of these bounds presents no problems for this specification of a range; all x that meet the specification are in the range.
Some contexts support unary
forms of these additive operators
– which are honorary multiplicative operators (for the sake
of precedence
rules). These take the form of an additive expression, as
above, with left omitted; their meaning is
equivalent to what would be obtained by (enclosing and) providing, as a
default left, a suitable additive identity
(i.e. zero). Consequently, −(a−b)
shall generally be
synonymous with (b−a)
; and note that −a−b
means (−a)−b
, rather than −(a−b)
, because
the first −
in −a−b
is unary, hence denotes
negation, so binds more tightly than
the (additive) subtraction
operator. Likewise, −a±b or −a+b means (−a)±b
or (−a)+b.
Note that I deliberately don't define subtraction in terms of additive
inverses; on the natural numbers, we have an addition which is cancellable,
which means we can define subtraction as above, despite lacking inverses. In
such a case, the unary form of subtraction, known as negation
, is not
available for use in defining the binary form. Likewise, 3 ±5 can (in a
statistical reading) comfortably denotes any natural up to 8.
Where several values are combined using additive operators, the expression may be decomposed by the implicit insertion of parentheses around any portion of the expression
Any valid reading of the expression in this manner gives a valid order
in which to evaluate the expression as a whole; as long as the addition is
associative, the result should not depend on which such decomposition is
used. Note that this requires reading of a −b −c
as (a
−b) −c
and precludes reading it as a −(b −c)
;
however, a +−b −c
(in which −b exercises − as
negation, rather than subtraction; I would normally parenthesis this
sub-expression for clarity) can be read as a +(−b −c)
.
There's rather more multiplicative operators than one might at first
realise. The characteristic property of multiplication is that it (is
an associative binary operator which) distributes over
addition
(i.e. (a+b)×c = a×c + b×c); however, various kinds of kindred
combiner meet this criterion with some variation on their details.
scaling: the simplest kinds of multiplication. Always associative,
usually commutative. Usually at least one operand is required to be of
some scalar
type that is archetypically numeric
.
Repeated addition provides a natural formalism for multiplication by
positive integers
which can, in many contexts, be extended (by construing
its reverse as division by positive integers) to more general scaling
which interacts very cleanly with addition; where the things being added
have direction
as well as size
, scaling only changes the
latter. Scaling also interacts very cleanly with itself; notably, it
is abelian (so swapping left
and right does not change the value
denoted). Since scaling is the least complex form of multiplication, it gets
the most light-weight denotation: a mere full-stop (in en-GB:
a.k.a. period
in USAish or point
in
French). Some contexts may warrant the use of this simple form for other
multiplication-like operators: but I shall only use it thus when the operator
really is very simple and well-behaved.
Asserts that one of left
and right is a scalar (i.e. a number
) or a
scaling (which is just the result of multiplying a scalar by an identity
mapping) and the other is a value which is amenable to such scaling; denotes the
result of applying the scaling. Note that scalars (and scalings) are always
amenable to scaling, so both left
and right may be scalings, in which case
scaling left
by right should normally produce the same answer
as scaling right
by left.
multiplicative combiners properly construed as [analogous to] the
application or composition of relations or functions; most notably, linear
contraction
.
Where scaling
, above, produces a value of the same type as
the
thing scaled, · produces something of a type no more complicated
than
its operands, albeit possibly of a different type than either operand.
When discussing the abstract theory of binary operators, e.g. group theory, I
migth use · for the combiner of the group: but my main use of · is
in linear algebra.
In the presence of scalings, mappings which respect addition
in a
sense analogous to distributing over it – i.e. a mapping f for which
f(a+b) = f(a) + f(b) – come to be particularly important; and applying
such a mapping to its input, or composing two such mappings, behaves very much
like multiplication. Formally, we also have to require that the mappings
respect scaling – i.e. f(n.x) = n.f(x) for any scalar n – as well as
addition; such mappings are called linear
(and I'll allow that
linearity's definition can be extended to relations in general, not just
mappings).
In the case of linear contraction
, use of this denotational form
asserts that [at least] one of the following holds true, and gives it the
meaning indicated:
Officially, the second of these can be construed as a variant on the
first, via interpretation of any linear space V as {linear (V:|{scalars})},
using the isomorphism (: (V: v.s ←s :{scalars}) ←v :V); the third can
likewise be construed as a variant on the second, via the double-dual
interpretation of a linear space, using the isomorphism (: ({scalars}: w(v)
←w |{linear ({scalars}: |V)}) ←v |V); and the last can be construed as
an appropriate one of the others via either the first isomorphism just given or
interpretation of a scalar as a scaling. These and a few further structural
isomorphisms
lead to tensor algebra (see next combiner).
Note that I emphatically do not employ · to denote
the usual inner product
of vector algebra – this combines two
vectors to produce a scalar (if the two vectors are equal, this scalar is
construed as the square of their length). This is invariably mediated by
a metric, which is an isomorphism between the space of vectors and a
dual space of covectors
: I always mention such metrics
explicitly. If the metric is called g and it is used to combine two vectors, x
and y, the result may be written as g(x,y), as y·g·x or, indeed,
as g(x)·y; but I do not write it as x·y
. [As for
xTy: I spit on the stupidity of this misconstruction
of transposition
– just for the record.] In rare cases, where I
really want to resemble orthodoxy, I might write x*y for such an inner product,
but that's the closest it gets.
more complex multiplications, most notably the tensor product (as applied to members of linear spaces, not to the spaces themselves). Synonymous with . when either operand is a scalar. Always associative (modulo certain standard isomorphisms of tensor algebra), seldom commutative.
Orthodoxy commonly uses &tensor; both where I'm here using × and for
the related combiner on linear spaces; I'll reserve it for only the latter,
U&tensor;V = {u×v: u in U, v in V}, so that I can distinguish the two.
Tensor products over both real and complex scalars arise, sometimes in the same
context; when this happens, it is sometimes necessary to make clear which uses
of × and &tensor; are over which scalars. Orthodoxy does this by putting
a subscript on (or under) the operator, which is (ugly and) rather clumsy to do
in HTML, so I contemplate making that distinction using a title attribute on the
operator, as x×y, naming the relevant type
where I've used scalar
here; it is necessary to hover the operator to
discover which type is uses, but at least it avoids clutter in the immediately
visible text.
Various other operators are built from these operators by linear
algebra. Where mathematics uses ^ or ∧ (which should appear as two
slightly different symbols) as a binary operator other than
logical and
, it generally uses it as a multiplicative operator; the two
commonest are the 3-d vector product
and the more
general antisymmetric tensor
product. I intend to use ^ for the latter applied to vectors and tensors,
with ∧ serving for the associated combiner on linear spaces, U∧V =
{u^v: u in U, v in V}; I may have been less than consistent about such use in
the (pre-2015) past, though.
The limits on associativity imply that it is often necessary to include parentheses when mixing these multiplicative operators. Where scalar multiplication is mixed with the others, absent explicit parentheses, it should be deemed to bind more tightly, so that a×b.c is read as a×(b.c); when c is a scalar, this shall be equal to (a×b).c but, when c isn't (implying b is) the latter isn't even a well-formed expression, unless a is also scalr (making the × merely a . in disguise), since a×b is then of a's (non-scalar) type, so neither it nor c is scalar, so we can't use scalar multiplication between them.
When contraction is read as composition of linear maps (or relations): if the left values of its left operand aren't scalars then it is usually unproblematic to have some other multiplicative operator to its left; and where the right values of the right operand aren't scalars it is likewise usually unproblematic to have some other multiplicative operator on its right. The excluded cases are exactly the ones that arise when contraction construed as application is rearranged as composition by treating the input v in V as (: v.t ←t :{scalars}) if on the right or as ({scalars}: w(v) ←w :dual(V)) if on the left; but these exclusions can apply also in cases that naturally are composition. (See below for a discussion of the distinction between syntactic and semantic rules; these rules for contraction depend on the values acted on, so are semantic rules.) If in doubt as to whether mixing multiplications might be problematic, it is advisable to use explicit parentheses, if only as a kindness to the reader. If the author isn't sure what's going on, what chance has anyone else ?
Many computer programming languages use * as the multiplication operator;
where (and if ever) I use it other than as a dummy
operator for
discussion of general binary operators, I'll respect this tendency (i.e. it
shall take precedence over additive ones, and shall usually also distribute over
them).
My greatest deviation (as to denoting arithmetic) is in the area of
division, where I prefer denotations for ratios rather than multiplication by
multiplicative inverses: i.e. I would sooner say a/b than
a·(b−1). This is analogous to my specification of
subtraction without reference to additive inverses. At the same time, the
limitations of plain text militate against any attempt to draw a horizontal line
with one expression centred on top of it and another centred beneath (which, in
any case, fails to address the following). Although I shall presume symmetry in
addition (i.e. a+b = b+a for all a, b) I shall not presume the same for
multiplication: thus a·(b−1) and
(b−1)·a need not be equal, so that I need to distinguish
between a/b (the former: a over b
) and b\a (the latter: b under
a
). Officially,
multiplication via an inverse;
denotes left&on;reverse(denom)&on;right
but wants this to be thought of
as left·(denom−1)·right. Pronounced: left over
denom under
right.
Relates x to y precisely if there exist u and v for which:
In linear algebra, the standard isomorphisms (see · above) enable us to extend this slightly:
When right is a left value of denom, we can read it as (: right.s ←s |{scalars}). This requires y to be a scalar (but it may be any scalar) with v = right.y; linearity then insists that if mid relates v to some u and left relates x to the same u, there should be a z, notionally z=x/y, which left/denom\(: right.y ←y :{scalars}) relates to the scalar 1; this then makes the composite equal to (: z.y ←y :{scalars}) which is synonymous with z. In such a case, left/denom\right is identified with the given z.
When left is a linear map from the right values of denom to scalars, i.e. a member of dual(:denom|), left/denom\right shall be a linear map from (:right|) to scalars, so may be construed as a member of dual(:right|). If (:right|) is itself the dual of some finite-dimensional linear space V, its dual shall be V, so it shall make sense to interpret left/denom\right as a member of V.
For example, given a metric (dual(V): g |V) on some linear space V, we can combine two members x, y of dual(V) via g's inverse to get x/g\y, as long as there is some v in V for which g(v) = y; when we read y as (: t.y ←t |{scalars}), we get x/g\y = (: t.x(v) ← t |{scalars}) which we can simply interpret as x(v), for any v satisfying g(v) = y. This is apt to be ambiguous when g is singular; even then, if Kernel(x) subsumes Kernel(g) then the ambiguity goes away.
synonym
for numer/denom\(:v←v|denom),
so denotes numer&on;reverse(denom). Pronounced: numer over
denom.
As above, linear algebra allows some extensions of this by interpreting vectors as linear maps. In particular, given linear (U: h |V) and linear (W: x :V), we get x/h = (W: x(v) ←h(v) :U), in which v varies over V; so this won't be (W: |U) unless h is (U| h |V); and won't be a mapping unless Kernel(x) subsumes Kernel(h). When those conditions are met, though, (x/h)·h = x/h\h = x. When W is just {scalars}, so x is in dual(V), this makes x/h denote an arbitrary member w of dual(U) for which w·h = x, if there are any.
synonym for
(denom|u←u:)/denom\numer,
so denotes
reverse(denom)&on;numer. Pronounced: denom under
numer.
As above, linear algebra allows some extensions of this by interpreting vectors as linear maps. In particular, given linear (U: h |V) and u in U, h\u denotes any v in V for which h(v) = u (via interpreting u as (: t.u ←t |{scalars}) and then reading (: t.v ←t |{scalars}) as v). Thus h·(h\u) = h/h\u = u.
I do not use the ÷ operator which I was taught to use for division – at least some cultures (e.g. Norwegian) use it for subtraction (and its glyph can, in some fonts, be confusable with +). Note that the above allows me to deal with a/b even when b is singular: the result is a relation rather than a mapping (supposing a and b to be mappings) unless a's kernel subsumes b's (i.e. b(x) = 0 implies a(x) = 0). For contrast, b\a is a relation whenever b is singular (left values are ambiguous by members of b's kernel); and its collection of right values (inputs) may be restricted to a sub-space of those of a, namely the subspace on which a's output is an output of b.
The division operators are not associative; so complex expressions involving them (especially the last two) commonly need parentheses. However, as long as each denom
these forms can be used in conjunction with the multiplicative operators, subject to the same limitations as arise from their limited associativity. For these purposes, the division operators count as contraction; their non-denom operands can be combined multiplicatively on their outer side under the same conditions as apply for contraction, above. Evaluation by insertion of implicit parentheses proceeds in the usual manner, subject to the two rules just given, which effectively just preclude opening a parenthesis immediately before, or closing one immediately after, any denom unless it is already at the relevant end of the expression. As for the multiplications, if in doubt about whether explicit parentheses are needed, it is usually best to include them, if only as a kindness to the reader.
Note that most of these rules governing the implicit insertion
of parentheses to determine evaluation order are syntactic rules, about
how the text may be rearranged in the process of determining what it
means. Once the meaing, also called semantics
, has been determined there
may be rules that admit other rearrangements, to express structural facts about
the values represented, such as the many cases where a/b\c can be legitimately
rearranged as (a/b)·c or as a·(b\c); however, these
are semantic rules, that depend on the actual values involved, not just
the form of the text. The rules governing when contraction can do without
parentheses are in fact semantic rules in this sense, which is why it's often
best to use explicit parentheses for those cases.
Where some or all of the binary operators discussed here are defined for
values of some kind, it is natural to induce meaning for those binary operators
on mappings whose outputs are of those kinds; for example, if the left values of
(:f|I) and (:g|I) are amenable to addition, it makes sense to define f+g to be
(: f(i)+g(i) ←i |I). Likewise, when the outputs of f and g are amenable to
multiplication, it makes sense for f.g to be (: f(i).g(i) ←i |I). This is
known as applying the binary operator pointwise
(i.e. at each input).
For the sake of generality, I'll actually work with relations and avoid
requiring that (:f|) and (:g|) are equal – additive operators shall be be
defined on their union, while multiplicative operators shall only get the
intersection. (This corresponds, in each case, to treating is not a right
value of
a function as is mapped to zero by
that function, without
requiring there to actually be a zero to map such non-inputs to.)
When * is a multiplication or either division (i.e. \ or /), and context gives meaning to x*y whenever there is an i for which f relates x to i and g relates y to i, I define f*g to relate each such x*y to i in exactly this case. If context gives meaning to x/u\z whenever f relates x to i, h relates u to i and g relates z to i, I define f/h\g to relate x/u\z to i in exactly this case.
When * is an additive operator (so both a binary operator and the associated unary operator) and context gives meaning to
I define f*g to relate
and nothing else to anything else, otherwise. Note that when * is
±, f*g relates x*y to i
means f±g relates x+y to i and
relates x−y to i
(as opposed to f±g relates at least one of
x+y and x−y to i
), in the discrete (mathematical, except for
statistics) sense of ±.
In each case (both additive and multiplicative), if at least one operand is
a relation, as above, any operand which is simply a value (of a kind which the
operator combines suitably with the relation's left values) is promoted
to the constant mapping which relates the given value to each right value of
each relation involved.
Written by Eddy.