]> Addition


After counting, pretty much the first piece of mathematics most folk learn – if they're fortunate enough to get even this much education – is how to add the counting numbers (formalised as the natural numbers). Later, we may move on to learn how to add other kinds of values (lengths of lines, which need not be whole multiples of any common unit, for example; or displacements in space); conceptually, each such addition is distinct, but all of them have a certain amount in common, so it makes more sense to describe them using common language and notation than to have special names for each flavour of addition, depending on whether the things added are discrete or continuous, scalar or vector and so on.

In fact, most of the useful and interesting properties of addition flow from a few simple properties, that can be formalised as saying it's a cancellable, abelian (a.k.a. commutative), flat, closed, associative binary operator. If that's just a bunch of jargon to you, don't worry: I'll explain the details later (and link to where you can find even more detail, if you want) but what it means is that

There are some things that we commonly expect from addition that these basics don't imply (most obviously, that adding something (other than zero) to itself repeatedly always gets a new answer, without ever suddenly coming back and repeating an earlier answer), but the things these simple assumptions do imply are broadly applicable in lots of contexts – including some that don't behave as we commonly expect, but do behave enough like it that it still makes more sense to think of what we're doing as addition rather than inventing some other terminology and notation for describing it, only to duplicate most of what we learned about addition, restated for this other operation.

So, formally, this page is about an arbitrary cancellable abelian flat combiner; that I write this binary operator as + and use terms familiar from basic arithmetic needn't mean the operands are necessarily simple numbers, or lengths along a line, or any such familiar thing; but most of what I'll say should make sense if you do think in terms of such simple values, except for: the occasional need to consider cases like adding angles, where adding several angles may wrap round a full turn and bring you back to a total that's smaller than the angles being added; and, in some cases, the need to consider that the things being added might be like displacements on a flat surface, where you can add two things and get something that isn't the result of scaling either up or down by a simple number, because the parts were in different directions and the sum is in yet another.

While I'm at it, I'll be taking seriously a lesson that I was first taught and then untaught: that you can't always subtract one value from another – you can't take seven from four, for example. When I was first taught to subtract, this was a rule; later, we were introduced to negative values and it ceased being a rule, you just get a negative answer. In some contexts, that's a perfectly good way to proceed – you can, in some sense, borrow the excess when you subtract too much; or a positive value may simply mean a displacement in one direction while a negative one means a displacement in the opposite direction. However, in other contexts it is actually quite reasonable to restrict subtraction; there are some values a, b for which you can find an x with a +x = b, in which case we can think of x as b −a, but there are also cases where there's no such x, at least for some choices of a and b.

It's always possible to extend an addition (in a coherent and natural manner) to invent such an x, by embedding the things we know how to add in some bigger collection (of formal differences) that includes all the negative (and other) values that can be induced from some given positives, but I prefer to actually deal with the addition we have and see what we can show without going outside it. In particular, when we also have a multiplication, its behaviour on the positive values (where we don't have to worry about whether what we're about to divide by is zero, or whether scaling a comparison might change its direction due to a negative scale) is simpler; so it's good to be able to describe the addition on positives without perpetually resorting to reference to a bigger collection in order to do subtraction.


While some contexts may use the word differently, what I'll here be describing as an addition is:

a combiner, i.e. a closed associative binary operator

This means that it nominally combines values two at a time but that it's not fussy about whether and how you partition a sequence of values added, so (a +b) +c, adding a to b then adding the result to c, gets the same answer as a +(b +c), adding a to the result of adding b to c, so that I can sensibly write the result as a +b +c without needing parentheses to specify which use of + is acting on which pair of values. This leads to similar for arbitrarily long sequences, a +b +c +… +y +z. For that to work, the results of adding things need to be things we can add.

This means that, if a and b are operands of it then it knows how to combine them as a +b; that is, if there are any c, d for which it knows how to combine a +c or c +a and how to combine b +d or d +b, it also knows how to combine a +b.
commutative (a.k.a. abelian)

This means it also doesn't care if we shuffle the order of the values it's adding, or even reverse it: a +b +c +… +y +z = z +y +… +c +b +a. It's actually, given associativity, sufficient just to say that a +b = b +a for any a, b that our addition knows how to combine but it's important to remember that what this means in practice is that the order of the values added doesn't matter.


This means that adding the same thing only gets the same answer if the things it was added to were the same: a +b = a +c implies b = c, cancelling the shared a. This is a bit like saying you can subtract one value from another and there's only one answer that can give you, but allowing that it only works where you can do the subtraction; it gives you as much subtraction as your available values can.

As addition is commutative, its collections of left and right operands are equal; I'll refer to operands of the addition as simply values. Any result of adding values is known as the sum of those values; sum is also the usual name for the bulk action of addition, sum([a, …, z]) = a +… +z. Every sum is a value but we don't (in general) guarantee that every value is a sum (for example, the addition on positive whole numbers has no way to produce 1 as a sum). In principle, the collection of values (and thus our addition) may be empty; but this is not usually an interesting case, so usually our addition shall know how to add some values and {values} won't be empty.

When relevant, we characterise properties of addition as additive to distinguish them from the corresponding properties of any other binary operator that context may introduce with corresponding properties; thus, for example, we'll discuss an identity and inverses for addition below; in discourses involving a multiplication, it is commonly necessary to refer to an additive identity or to additive inverses, to distinguish them from the identity and inverses of multiplication.

Wrinkles and complications

Feel free to skip this subsection and skip straight ahead to subtraction.

Although each addition, on a particular collection of values, is flat, a given context may have cause to discuss several additions, each on its own collection of values, using the same notation for all of them – as long as it takes care to avoid adding operands of distinct additions. This may require interpreting names like 0 and zero with care, as they stand for distinct operands of distinct additions. This makes addition a polymorphic binary operator, whose associated (: (: a +b ←b :) ←a :) is the union of the equivalents for the diverse separate additions; the resulting addition is no longer flat.

None the less, for any given a, the available b that we know how to add to a, either as a +b or as b +a, all lie in some collection of operands, of which a is also a member, for which the restriction of addition to this collection is flat. One may thus think of the united binary operator as layered flat, in the sense that each value is in a layer on which the addition is flat and cannot be added to values in other layers. In any case, what matters is that each of the additions of which the polymorphic addition is made up is itself flat, so behaves as described here; likewise, the negation and subtraction induced from each thus behave as described here, each on its addition's layer.

There are also cases that genuinely complicate this story: for example, one way to describe a Euclidean space allows us to take differences (see below) between positions in the space but does not allow us to add positions in the space. A difference of positions is called a displacement: we can add displacements to one another and take differences between them; we can also add displacements to a position, to get a position. One can chose any position in the Euclidean space to use as origin and associate each position with its difference from this origin, thereby identifying positions with displacements, but this is not entirely natural to the Euclidean space. (In some sense, this foreshadows the distinction between smooth manifolds and their charts.) Such split-and-mixed additions are a matter for a separate discussion; but most of what matters about them does fit with the cases described below, subject to only allowing one position (along with arbitrarily many displacements) in any given sum.

Pointwise addition of mappings

Whenever we have an addition on some collection V of values, we can induce one on mappings to V from within any given collection I; this is the pointwise addition on mappings (V: :I) for which f +g maps each i in I that's a right value of both f and g to f(i) +g(i), each that's only a right value of f to f(i) and each that's only a right value of g to g(i). Thus any member of I that's not a right value of a given function (V: f :I) is treated as if f(i) were an additive identity. As a result, even if the addition on V has no additive identity, the addition on (V: :I) does have one, namely the empty mapping; however, to let this be cancellable when the addition on V does have an additive identity, we also necessarily treat mappings as equivalent if they map the same inputs to the same non-zero outputs, ignoring any difference where one maps an input to zero that the other does not accept as an input.

We can also use pointwise addition on the partial cartesian product of some mapping whose outputs are all collections on which we have additions defined. If (: F |I) maps each i in I to some F(i) on which we have an addition, the partial cartesian product of F is the collection of mappings (: f :I) for which f(i) is in F(i) for each i that is a right value of f; as before, we can use pointwise addition between such mappings. (An example of this shall be the addition on the space of sections of the tangent bundles, or any tensor rank derived therefrom, of open neighbourhoods in any smooth manifold.)

When we have a mapping whose outputs are all in spaces on which we have additions, the collection of inputs at which the mapping's output is not an additive identity (for the relevant space) is known as the support of the mapping; the pointwise addition treats two mappings as equal precisely if they have the same support and are equal on it, ignoring any inputs that the mappings either don't accept or map to zero.


Since addition is commutative, there is no need to distinguish between its left- and right-completions; as it is also cancellable, its completions are unique. A completion for a pair b←a of values is known as the difference between a and b (in this order) and is denoted b −a (pronounced: b minus a). Two differences, b −a and d −c, are equal precisely if b +c = d +a (as you might expect). When used as a binary operator in this way, is known as subtraction; uniqueness of completions (i.e. differences) makes it unambiguous.

Subtraction isn't necessarily flat (we aren't guaranteed completions for all pairs of values; e.g., among positive whole numbers, you can't subtract 7 from 4), abelian (when you can do both subtractions, 4 −7 isn't 7 −4) or associative, as (7 −4) −3 isn't 7 −(4 −3). When a completion exists for b←a, I'll say that we can subtract a from b or that there is a b −a. Conversely, absent a completion, I'll say we can't subtract a from b or that there is no b −a. By specification, addition is complete precisely when every pair of values has a completion, i.e. we can subtract any value from any value; but not every addition is complete.

Whenever there is a b −a, we can subtract it from b since our b −a is some x for which b = a +x = x +a, making a complete b←x; so b −(b −a) = a. In particular, this makes every difference a right operand of subtraction, hence subtraction is closed.

Given a +x = b, for any c we get a +x +c = b +c; thus, if we can subtract a from b then we can also subtract a from c +b (for any c), with (c +b) −a = c +x = c +(b −a). Either end of this chain can thus be written as c +b −a, but note that this is only meaningful when b −a is; and you do need parentheses if you shuffle the order to get (b +c) −a, since we have no assurance that there's a c −a.

Suppose there is a b −a and we can subtract it from some c; with x = b −a, so a +x = b, we have some y for which x +y = c. Adding a to each side, we get a +c = a +x +y = b +y, so we can subtract b from a +c, with (a +c) −b = y = c −x = c −(b −a). Note that, in this case, we do need the parentheses: we can subtract b from a +c but can't necessarily subtract b (from a or) from c, as would be needed for a +c −b. Still, with this proviso, c −(b −a) = (a +c) −b whenever there is a b −a and we can subtract it from c.

In some cases we'll have an addition satisfying: for distinct values a, b, precisely one of them can be subtracted from the other. For example, the counting numbers (or just the positive ones) satisfy this – subtraction works one way round but (for distinct operands) not the other. In such a case, we can define an ordering on our values by a < b precisely if a and b are distinct and we can subtract a from b. Usually, when this happens, the same ordering arises naturally from other (albeit related) causes, so I have litte more to say about it here (while the interaction of similar orderings with arithmetic is worthy of a page of its own); but it can be a useful limitation of subtraction, i.e. of not having inverses. Speaking of which…

Identity and inverses

When an addition has an identity, cancellability necessarily makes it unique; and, if there is an a −a for any value a, then this is indeed an identity. (As addition commutes, any left-identity is also a right-identity, and vice versa, so there is no need to distinguish the two.) It is usual to denote an identity as 0 and name it zero, unless there is some strong reason to distinguish it from the identity of some other addition. Given an identity, for every b = b +0, we are able to subtract b from b, to get b −b = 0, and to subtract 0 from b, to get b −0 = b. Regardless of whether an addition has an identity, I'll describe values that aren't additive identities as non-zero.

When any value has an inverse, cancellability necessarily makes it unique, which makes the is an inverse of relation a mapping. As addition is commutative, we don't have to distinguish u +v = 0 as making u a left-inverse for v and v a right-inverse for u; u +v = v +u so the two relations are ntaurally equal; this also makes is an inverse of symmetric and, hence, a monic mapping that's self-inverse; this mapping is named negation.

Given u +v = 0, for any value b, we have b = b +0 = b +(v +u) = (b +v) +u so we can subtract u from b, with b −u = b +v; conversely, we can subtract v from b, with b −v = b +u. Indeed, given that u +v = 0, we have v = 0 −u; in such a case it is usual to write, simply, −u for 0 −u = v, so that b −u = b +(−u). As noted above for subtraction generally, when we can subtract u from 0, u = 0 −(0 −u) = −(−u); this encodes the fact that negation is self-inverse. Note that 0 = 0 −0 = −0 always has an inverse: if we have an identity, it is fatuously self-inverse. When a value has an inverse, we can subtract that value from any value by the simple expedient of adding its inverse. When is used as a unary operator in this way, it shares the name negation with the self-inverse mapping (: −x ←x :) that is an inverse of proves to be.

If we hadn't specified that addition is cancellable, the combination of an identity and an inverse for every value would, in fact, have sufficed to make the addition cancellable (and complete). It remains that cancellation is useful (and can be available) even when we have no inverses, nor even an identity, as happens for the addition on positive whole numbers.

An addition is complete precisely if it can subtract any value from any value; i.e. there is always a b −a for all a, b. When a non-empty addition is complete, it necessarily has an identity 0 (the completion of x←x for some x) and, for every value v, an additive inverse −v (the completion of 0←v).

When an addition has an identity and some values (not necessarily all) have inverses, those that do are operands of negation and each is itself an inverse. We can thus refer to the collection of these as {inverses}; which is necessarily closed under addition since (−u) +(−v) +(u +v) = 0 so (−u) +(−v) = −(u +v) and every sum of values with inverses does have an inverse, namely the matching sum of inverses. Further, when u, v are inverses, {operands} does have completions for u←v and v←u, namely u +(−v) and v +(−u), and the sum of these two is 0, so these two are also inverses (of one another), so {inverses} is closed within {operands}. In particular, the addition on {inverses} forms a sub-addition, which is necessarily complete. When we use the standard formal differences construction to embed our addition in a complete one, our addition's image in that is likewise a sub-addition of the extended addition.

As long as no such template is applicable to values that are amenable to both negation and subtraction, no ambiguity should arise from their use of the same symbol, , as one is a unary operator while the other is a binary operator. However, a template which juxtapose values without any punctuation between them can, when those values are amenable to both subtraction and negation, lead to ambiguity, as a −b could be read as the difference or as a juxtaposition of a with the negation of b. The closest I can think of to this is the superscript/subscript notation for tensors in which (for example) Ti j kh juxtaposes three subscripts; were we to use arithmetic within the subscripts, this could lead to such ambiguities; however, the indices are usualy naturals, among which only 0 is amenable to negation, so the template for this tensor notation can stipulate that the negation template is not applicable to the indices. The constraints of tensor rank would, in any case, render one of the ambiguous readings invalid (through having the wrong number of indices).


The definitions of closure and restriction for general binary operators apply equally to addition. Addition is closed on some collection S of its operands precisely if S subsumes {r +s: r, s in S}; i.e. r +s is in S whenever r and s are in S. Thus, for example, the even numbers (twice any whole number) are closed under addition; in contrast, the odd numbers (non-even whole numbers) aren't, since adding two of them gives you an even number. Any intersection of collections closed under addition is itself closed under addition; and the closure of any collection S of values is just the intersection of all collections of values that are closed under addition and subsume S. The specification of addition as a combiner says that its collection of operands of our addition is closed under addition, so closure never requires us to contemplate intersect({}). When we have a collection of values that's closed under addition, we can think of our addition's restriction to these values as a sub-addition of the original.

Completing as much as possible

Now, going back to the example of even numbers, every difference of even numbers is itself even, so the even numbers aren't just closed under addition; even when we only have positive numbers, the even numbers are also closed under differences, in so far as such differences exist. Contrast this with the counting numbers greater than five; these are closed under addition (any sum of them is greater than eleven, in fact, hence also greater than five); but some differences between them are not greater than five. Seen as a subset of {naturals}, the counting numbers, this {natural n: n > 5} thus lacks some differences that are available in its context.

For a general flat binary operator, I characterise this by the subset (e.g. even numbers) being closed under completions within its context. Since it plays a significant rôle for addition, I'll use the shorter phrase closed within to describe it; this is just a short-hand for saying that one collection of values is closed under addition and under such differences as there are in another.

Thus, if we have a collection W of values we know how to add (this needn't be all of {values}, although that'll be the usual case) and W subsumes C (so C is a collection whose members are all in W, so we know how to add them), I describe C as closed within W, under addition, precisely if C is closed under addition (in the usual sense) and, whenever c in C and w in W have c +w in C, we also have w in C (i.e. if W has an a −c, for some a, c in C, then this a −c is also in C).

As for any flat binary operator, an intersection of collections closed within some given W is likewise closed within W, enabling us to form a closure within W from an arbitrary collection S of values by intersecting all collections that subsume S and are closed within W.


The homomorphisms of additions are simply their homomorphisms as flat binary operators; given additions on U and on V, a homomorphic mapping from the latter to the former is just a mapping (U: f |V) which respects the additive structure; i.e. for which f(v +w) = f(v) +f(w). Since a homomorphism of flat binary operators maps completions to completions, we also get f(w −v) = f(w) −f(v) and we can subtract f(v) from f(w) whenever we can subtract v from w.

Mapping completions to completions also ensures that, if the addition on V is complete, then so is U's addition, when restricted to the outputs of a homomorphism (U: |V) – even if U's addition, on the whole of U, isn't. It also (as for any flat cancellable binary operator) ensures that homomorphic mappings map identities to identities and inverses to inverses; thus f(0) = 0 and f(−v) = −f(v). As ever for a homomorphic mapping (U: f |V) of flat binary operators, applied to additions on U and V: any W subsumed by V and closed under addition gives a homomorphism (U: f |W) from W's addition to U's; any T subsumed by U yields a restriction (T: f :) for which (T&on;f: x←x :) is closed if T is and closed within V if T is closed within U. So homomorphisms push forward closure and pull back both closure and closure within.

The kernel and image of a homomorphism (U: f |V) of additions are defined as usual for a flat binary operator. This gives Image(f) = {f(v): v in V} in the obvious way, closed under addition in U because V is. When U (hence V) has no additive identity, Ker(f) is necessarily empty; otherwise, Ker(f) = ({0}&on;f: x←x :V); either way, it is closed within V. The image need not, in contrast, be closed within U; for example, the identity embedding of {naturals} in {integers} lacks all the negative differences the latter provides between outputs.

Composing homomorphisms

When (T: g |U) and (U: f |V) are homomorphisms of additions, the composition g&on;f is proper precisely if, whenever the addition on U to which f morphs allows a value for a+b, for any a, b in U, the addition on U from which g morphs also allows this value for a+b, for the same a, b in U. Usually we'll simply be using the same addition on U in both cases; or f shall morph to an addition that's a restriction of the one from which g morphs. The result of proper composition of homomorphisms of additions is necessarily a homomorphism of additions, since (W: f |V)&on;(V: g |U) maps u+t to (f&on;g)(u +t) f(g(u +t) = f(g(u) +g(t)) = f(g(u)) +f(g(t)) = (f&on;g)(u) +(f&on;g)(t).

If we have homomorphisms (: f |A) and (B: g :) with A and B not necessarily the same (they were both V, previously), but using the same addition for the two homomorphisms, we none the less have each of A and B closed under the common addition; the intersection of these, call it C, is also closed under that addition. Composing f&on;g has the effect of composing the restriction (: f |C) with the restriction (C: g :), so we'll still get a homomorphism, albeit the composite might not have all the right values of g (it might even be empty), so it's a homomorphism between sub-additions, from one subsumed by where g morphs from to one subsumed by where f morphs to. So composing homomorphisms, as long as each understands its outputs in terms of the same addition as the next uses to understand its inputs, always gives a homomorphism as composite. Usually, the way we'll ensure consistency of the additions shall be to have the composition clean, so that every left value of one homomorphism is a right value of the next, which makes the composition proper.

Automorphism ringlet

Given an addition on some collection U of values, consider its automorphisms; these are mappings (U: f |U) that respect the addition, so f(u+v) = f(u) +f(v). Applying point-wise addition to two of these, f and g, gives (f+g)(u+v) = f(u+v) +g(u+v) = f(u) +f(v) +g(u) +g(v) = f(u) +g(u) +f(v) +g(v) = (f+g)(u) +(f+g)(v), so a sum of automorphisms is an automorphism. Composing two automorphisms, we get (h&on;f)(u+v) = h(f(u+v)) = h(f(u) +f(v)) = h(f(u)) +h(f(v)) = (h&on;f)(u) +(h&on;f)(v) so any composite of automorphisms is an automorphism. Composing with a sum, we get h&on;(f+g) = (: h(f(u)) +h(g(u)) = h(f(u) +g(u)) ←u |U) = (h&on;f) +(h&on;g); likewise, (f+g)&on;h = (f&on;h) +(g&on;h); so composition distributes over addition.

If we have f +g = h +g then, for each u in U, we have f(u) +g(u) = h(u) +g(u) and cancellability of our underlying addition on U implies f(u) = h(u); this being true for each u in U, we have f = h and our addition on automorphisms is cancellable. The identity U on our collection of values composes with every automorphism, on either side, to give that automorphism, so serves as an identity for composition. Consequently, the automorphisms of an addition, using pointwise addition and interpreting composition as multiplication (that need not be commutative), constitute a a ringlet. When our addition is complete, so is the pointwise addition in this ringlet, making it a ring.


When an addition on U has an identity 0, for any addition on V we have a rather boring homomorphism (U: 0 ←v |V), even if V lacks an identity; the image of this is just {0} while the kernel is all of V. When V has an inverse for every member, its negation mapping (V: −v ←v |V) is a homomorphism. For any restriction of an addition on V, to some U that V subsumes, the identity embedding of U in V (V: u ←u |U) is a homomorphism. For both negation and identity embeddings, the kernel is just {0} or {} (for the identity embedding when there is no additive identity) and the image is the collection of inputs.

When an addition on V has inverses for at least some members, consider the collection U of members of V that do have inverses; it is the collection of left or right values of the negation mapping (: −v ←v :V). Since we have inverses, we necessarily have an identity, 0, which is necessarily in U since it's self-inverse. For any u, v in U, we have 0 = 0 +0 = u +(−u) +v +(−v) = (u +v) +(−u) +(−v), whence u +v has an inverse, −(u +v) = −u −v. So U is closed under addition. Furthermore, since u and v have additive inverses, we can subtract each from anything, in particular from the other; and we can rewrite the earlier equation as 0 = u +(−u) +v +(−v) = (u −v) +(v −u), so the two differences are mutually inverse, hence each is in U and U is closed under taking differences; it is thus additively complete (and, in particular, closed within V). The identity embedding of U in V is, as ever, a homomorphism; as is the negation mapping, construed as an embedding (V: −u ←u |U).

Repeated addition as natural scaling

As noted when introducing 0 as name for the identity, it is sometimes necessary to distinguish the identities of two different additions. In this section, we'll be dealing with naturals (a.k.a. counting numbers), on which there is a standard addition, as well as some general addition of values that need not be naturals. So I'll distinguish the natural 0 (which is indeed the identity for natural addition) from the identity, z, of our more general addition, when it has an identity.

Any binary operator allows repeated combination of a single value; when we do this for an addition, we get a scaling by naturals. For any value v and any natural n, we can form the list ({v}: |n) whose n entries are all v; at least when n is positive, we can apply the bulk action of addition to this list to get v.n = bulk(+, ({v}: |n)). Since our binary operator is flat, its bulk action accepts ({v}: |n) for every positive natural n. When we have an additive identity, z, our bulk action can use bulk(+, []) = z consistently, so we get v.0 = z for every value v; and scaling z maps it to itself, so z.n = z for every natural n. As our addition is given to be abelian, scaling by any given natural is an automorphism of our addition.

I shall follow orthodoxy in reading expressions, that mix this multiplication with addition, as having the multiplication bind more tightly than the addition, so that w +u.m +v.n means w +(u.m) +(v.n), thus saving some parenthetical clutter. When a value to be multiplied is a sum, however, it still needs parentheses, as v.(n +m) or (u +v).n, to avoid confusion.

Let every positive natural be deemed a count and allow that 0 is also a count (only) when our generic addition has an identity; so we now have a multiplication between values and counts. I refer to this multiplication as scaling a value by a count; and to each (: v.n ←v :) as a natural scaling. (Elsewhere, I'll discuss other possible scalings by other numbers than naturals.) When considered in conjunction with the ringlet structure on {counts}, induced from that on {naturals}, this scaling turns any addition into a a module over {counts}.

Homomorphic scaling

Given values u, v and a count n for which (u +v).n = u.n +v.n, we have (u +v).(1 +n) = u +v +u.n +v.n = u +u.n +v +v.n = u.(1 +n) +v.(1 +n); since the given condition holds fatuously for n = 1 (and, where relevant, for n = 0) we can now induce that it holds for every count n. Thus (: v.n ←v :) is an automorphism of our addition, for each count n. Consequently, whenever we can subtract u from v, we can also subtract u.n from v.n, with v.n −u.n = (v −u).n, for every count n; and, when v has an additive inverse, so does v.n, with −(v.n) = (−v).n, again for every count n. The attentive reader may now see why my natural multiplier is always on the right; we escape the need for parentheses in the last and can simply write −v.n for both the additive inverse of v.n and the result of scaling −v by n.

Now, given a homomorphism (U: f |V) of additions, observe that f(v.1) = f(v).1 and, when V has an additive identity, f(v.0) = f(v).0 for every v in V. For any natural n and value v with f(v.n) = f(v).n, we obtain f(v.(1 +n)) = f(v +v.n) = f(v) +f(v.n) = f(v) +f(v).n = f(v).(1 +n) and so, inductively, f(v.n) = f(v).n for every value v and count n (of V). It's possible that U has an additive identity when V doesn't, in which case 0 is a count of U but not of V; but every count of V is necessarily a count of U and f commutes with natural scaling by the counts of V (albeit the natural scalings of V and of U aren't actually the same relations, we merely represent them identically because they do essentially the same thing).

In particular, when U is V and the two natural scalings really are the same, natural scaling does indeed actually commute with automorphisms. Given that natural scalings are themselves automorphisms, this tells us that natural scalings commute with one another.

Interaction with natural arithmetic

Now, I define the multiplication and addition on {naturals} in terms of repeated composition of relations; so let's express our general addition in terms of relations (they'll actually be mappings) that we can repeat, so that we can discover how our natural scaling interacts with the arithmetic on {naturals}. We can encode our general addition as a binary operator add = (: (: v +u ←u :) ←v :) so that, for each value v, add(v) = (: v +u ←u :) and add(v, u) = v +u. The fact that addition is cancellable implies that each add(v) is monic and that add itself is monic; while associativity implies that every composite of outputs of add is an output of add, e.g. add(v)&on;add(u) = (: v +(u +w) = (v +u) +w ←w :) = add(v +u). Now, repeat(1, add(v)) = add(v) = add(1.v) for each value v; and, given a positive natural n for which repeat(n, add(v)) = add(v.n), we have repeat(1+n, add(v)) = add(v)&on;repeat(n, add(v)) = add(v)&on;add(v.n) = add(v +v.n) = add(v.(1 +n)), whence we can induce that the given condition is true for every positive natural n. (Note, however, that repeat(0, anything) is a universal identity, so repeat(0, add(v)) isn't add(v.0) = add(z), which is only the identity on our values.) So repeat(n, add(v)) = add(v.n) for each value v and positive natural n; and add is monic, so add(u) = add(w) precisely when u = w.

Let's add two positive naturals n, m: we get add(v.(n +m)) = repeat(n +m, add(v)) = repeat(n, add(v))&on;repeat(m, add(v)), by the definition of natural addition; and this is just add(v.n)&on;add(v.m) = add(v.n +v.m). Since add is monic, add(v.(n +m)) = add(v.n +v.m) implies v.(n +m) = v.n +v.m, so our natural scaling distributes over positive natural addition. For the product, we get add(v.(n.m)) = repeat(n.m, add(v)) = repeat(n, repeat(m, add(v))) by the definition of natural multiplication; and this is just repeat(n, add(v.m)) = add((v.m).n); as add is monic, add(v.(n.m)) = add((v.m).n) implies v.(n.m) = (v.m).n. Natural multiplication is abelian, so v.(n.m) = v.(m.n), and scalings commute with (homomorphisms, including) one another, so (v.n).m = (v.m).n; so v.(n.m) = (v.n).m = (v.m).n = v.(m.n). Thus natural scaling associates with natural multiplication, so that we can freely write v.m.n without needing parentheses; and v.m.n = v.n.m, regardless of how we would have parenthesised either.

That was all for positive naturals, so sufficient for all counts when 0 isn't a count, i.e. we have no additive identity. Let's see what happens when we do have an additive identity, z = v.0 for every value v, and 0 is also a count. In this case, for any natural n and value v, we have v.(n +0) = v.n = v.n +z = v.n +v.0. For multiplication, we have n.0 = 0 for every natural n, so v.(n.0) = v.0 = z = (v.n).0; likewise, v.(0.n) = v.0 = z = z.n = (v.0).n. So, whether or not 0 is a count, we always have v.(n +m) = v.n +v.m and v.(n.m) = (v.n).m for any value v and all counts n, m.

When each natural scaling is iso (so produces all values among its outputs and only produces each from one given input), we can extend our scaling by naturals to a scaling by rationals. When our collection of values, furthermore, constitutes a continuum in a suitable sense, we can extend to reals. However, this a topic for another discourse.

Cyclic or endless

For any value v, consider (: v.n ←n |{counts}). Either this is monic (in which case it has infinitely many distinct outputs, each of which is a value of our addition) or there is some value to which it maps two distinct inputs, n and n +p for some positive natural p. In this last case, we have v.n = v.(n +p) = v.n +v.p, so we can subtract v.n from v.n, making v.p = v.n −v.n an additive identity, i.e. v.p = z for some positive natural p. Thus, if ever there is a repeated entry in (: v.n ←n |{counts}), there is in fact an additive identity, 0 is a count, and the additive identity appears at some positive index (as well as at index 0) in (: v.n ←n |{naturals}), which is a sequence. In this case, the sequence repeats itself cyclically, since v.(n +i.p) = v.n for natural i, n.

For any value v, if any positive natural n makes v.n an additive identity, the least such n is known as the additive order of v; if there is no such positive natural, which implies that (: v.n ←n |{counts}) is monic, v is said to have order 0 (serving as a token for infinity, in effect). Any additive identity has order 1, fatuously. When there is no additive identity, every value has order 0. If any value has order 0, so do infinitely many other values, obtained by applying a positive natural scaling to it, and our addition acts on infinitely many values. So every addition on finitely many values has an additive identity.

If any value of our addition has order 0, the addition as a whole is said to have characteristic 0; otherwise, the characteristic of the addition is the maximum of the additive orders of its values. (It is usual to ignore the additive identity, when present; but this doesn't actually make any difference, since its order is 1; as we only take maximum order when no value has order 0, all other values have positive order, so 1 is not greater than any other value's order.)

Valid CSSValid XHTML 1.1 Written by Eddy.