]> Arithmetic Notation

Arithmetic Notation

Context may introduce various kinds of operation which it may chose to describe as addition, subtraction, multiplication and division, along with assorted combinators related to these. A given context may have several distinct collections of values on each of which it uses different combinators in these diverse rôles. Different contexts may, on some specific collection of values, give meaning to different combinators as addition; to some degree this shall control what combinators it makes sense to construe in the other rôles, but (see below) as many as three combinators may be involved as multiplication of one kind or another. I leave it to context to make clear which combinators 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.

Polymorphic assertions

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.

addition

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 (i.e. (a+b)+c and a+(b+c) are reliably equal), commutative (i.e., a+b and b+a are reliably equal) or cancellable (i.e., a+b = a+c implies b = c), but one of the first things I shall generally do after asserting that an operator is an addition is prove that it, indeed, has these properties. 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.)

additive

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.

multiplication

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

multiplicative

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

The Additive Operators

left + right

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 map from some linear space to itself).

left right

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), leftright 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).

left ± right

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

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 leftright. 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).

The Multiplication Operators

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 combinator meet this criterion with some variation on their details.

left . right

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.

left · right

multiplicative combinators 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 combinator 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 combinator).

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.

left × right

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 combinator 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 combinator 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).

The Division Operators

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

left / denom \ right

multiplication via an inverse; denotes left&on;reverse(denom)&on;right but wants this to be thought of as left·(denom−1right. 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:

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 Kenel(g) then the ambiguity goes away.

numer / denom

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 varyies 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 the member w of dual(U) for which w·h = x, if there is one.

denom \ numer

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, aslo 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.

Pointwise Extension

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). 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 – for additive operators, (:f+g|) shall be the union of (:f|) and (:g|), while multiplicative operators shall only get the intersection.

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

x*y to i
whenever f relates x to i and g relates y to i
x to i
whenever f relates x to i and i is not a right value of g
*y to i
whenever g relates x to i and i is not a right value of f

and nothing else to anything else, otherwise. This implicitly extends f and g to each map right values of only the other to an additive identity (i.e. zero). 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 ±.

When * is a multiplication or either / 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.

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. We could, in principle, work strictly with the naturals, without introducing the rationals or even integers, by using the induced automorphisms of our module in their place; these would serve as integera snd rationals without needing to explicitly construct collections of specific entities, divorced from any particular module, to represent them.


Valid CSSValid XHTML 1.1 Written by Eddy.