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

- we have a bunch of values we know how to add together;
- you can pick as many (as long as you can count how many) of these values as you want, with no restriction among the given values as to which you can pick, and we still know how to add them all up;
- it doesn't matter what order we add them in or whether we split the values into a few smaller bunches, add up each bunch, then add the answers from the several bunches, we still get the same answer;
- the answer is always one of the values we know how to add to other values; and,
- if adding some value u to each of two other values, x and y, gets the
same answer, x +u = y +u, then the two other values were actually equal, x = y
– we can
cancel

the u from the original equation.

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.

- flat
- 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.- cancellable
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.

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.

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…

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

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). _{i j k}^{h}

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.

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.

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.

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

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

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.

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.

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