The rationals are easy to construct, in utmost algebraic generality, as
scalings. However, the familiar world of physics gives a seductive feel of
continuity which has taught mathematics to study continua, for which the
available scalings include a great deal more than just the rationals, yet the
rationals' embedding in these real

scalings characterizes much of
it. But first we must consider what things are due to be scaled.

This page has sat unfinished for many years. There may be better treatment of kindred material elsewhere.

Once addition is construed, via (: x+y ←y :) ←x, as an embedding
of the addable things in {relations}, we can employ repetition to induce a
scaling: repeatedly adding x to a given input, n times, yields something we can
construe as n.x+y, for any positive natural n. We can also ask whether a
mapping respects addition

, in the sense f(x)+f(y) = f(x+y), in which case
it must also respect natural scalings, in the sense f(n.x) = n.f(x). The
(positive) natural scalings all respect addition and natural scaling. If a
mapping is monic, its reverse is also a mapping; if the mapping respects
addition and natural scaling, so does its reverse.

For a monic cancellable abelian addition V = ({monic mappings}: (V: x+y ←y |(:V|)) ←x :), I'll describe V's right values as vectors and left values as translations. [Abelian means V = transpose(V) = (: (V: x+y ←x :) ←y :), whence x+y = y+x for each vector y, x.] As V is monic, we can pull back mappings among translations to mappings among vectors; however, some things built out of translations might surprise us by not being translations, in which case this won't always work; in particular, I shan't presume that the identity translation, {vectors}, is in (|V:), i.e. that there's a zero vector for V to map it to; so I'll mainly work with interaction among the displacements, not the vectors; hence mappings among V's left values will arise, of form ((|V:): |V) or ({displacements}: |{displacements}); a displacement is a mapping ({vectors}: |{vectors}), i.e. (V: |(:V|)). Now, {relations} subsumes (|V:) = {displacements} and we have

- repeat = ({mappings}: (: compose({r}:|n) ←r :{relations}) :{naturals})

so we can apply repeat(1+n) to any displacement. Now, ({r}:|n) is the unique relation which has all members of n as right values and no left value but r; this is trivially a mapping hence, when n is natural, a list. For n=0={}=empty, however, this list is the empty list, [] = empty, regardless of r. In order to ensure r = compose([r]) for every relation r, compose([]) has to be the universal identity, making repeat(0) constant, which isn't monic; so I avoid involving it. I shall thus deal with (:repeat:successor), of which a typical output is repeat(1+n), with n implicitly natural.

V may be finite; in which case we shouldn't be surprised if there is some n for which (: repeat(1+n) :V) is the identity {displacements}, in which case (:repeat(2+n):V) will be equal to (:repeat(1):V). I'm not interested in the finite case, so I'm going to presume that (: (:repeat(1+n):V) ←n :{naturals}) is monic – i.e. no two of its outputs agree.

That alone doesn't rule out V being finite: it might only give us one dimension stretching to infinity, combined with several finite ones, in which case there will be some displacements for which repeat(2+n) and repeat(1) agree, for some natural n. Since outputs of repeat commute with one another – repeat(n)&on;repeat(m) is, indeed, repeat(n.m) = repeat(m.n) – this will be apt to make repeat(1+n) map several displacements one (which will be the identity {vectors}), making repeat(1+n) not monic. Thus I'll also presume that each (:repeat(1+n):V) is monic. This makes reverse(:repeat(1+n)|V) a mapping ({displacements}|:V), though not necessarily (:|V).

V may likewise be discrete; in which case we can expect that (|repeat(1+n):V) doesn't give us all of {displacements}, only some. I'm interested in continua, so I'll presume that every ({displacements}| repeat(1+n) :V), i.e. every displacement can be shrunk by any whole positive scaling. In this case, we can use reverse(repeat(1+n)) as a mapping ({displacements}: |V) and compose it with outputs of repeat; the results will behave as rational scalings on displacements, which we can expect to pull back, via V, to rational scalings on vectors, reverse(V)&on;s&on;V ←({displacements}:s|V).

Having accumulated presumptions, I'll now define: a monic cancellable
abelian addition ({monic mappings ((:V|)||V)}:V:) forms
a

precisely if: **vector** context

- (: ({monic ((|V:)|:V)}: repeat(1+n) |V) ←n |{naturals}) is monic

By the above or similar means, one may infer rational scalings in any vector context. Later, once I've tied down their addition and shown it cancellable, we'll be able to construct the rationals as differences between positive rationals; but for now we have:

- {positive rationals} = {reverse(repeat(1+q))&on;repeat(1+p): natural p, q}

for which every positive rational s gives ({displacements}| s |V) as a
monic mapping, yielding (V| reverse(V)&on;s&on;V |{vectors}) as its action on
vectors, which I'll write (: s.v ←v :) using a dot
for multiplication

. A typical positive rational's action on vectors is
thus (V: (1+p).v←(1+q).v :).

Now, consider any mapping (U:f|(:V|)), with U and V vector contexts, which respects addition; i.e. f(v+w) = f(v)+f(w) for each vectors v, w of V. This suffices to imply that f((1+p).v) = (1+p).f(v) for every natural p and vector v of V. Now every vector v of V is (1+q).w for some vector w of V, for each natural q, giving (1+p).f(w.(1+q)) = f((1+p).w).(1+q), whence:

- (: (1+p).u←(1+q).u :)&on;f&on;(: (1+q).w←(1+p).w :) = f, implying
- (: (1+p).u←(1+q).u :)&on;f = f&on;(: (1+p).u←(1+q).u :)

for all naturals p, q; i.e. f commutes with every rational
scaling. Thus respecting addition suffices to imply commutes with every
rational scaling

.

However,

respectingaddition is not as strong a constraint as might at first appear – for instance (looking ahead a bit), the mapping

- ({reals}: sum(: h.r :) ← sum(: h(i).i ←i :); mapping ({positive rationals}:h|(:r|)) :)
for any finite mapping ({reals}: r :{reals}), none of whose inputs, i, are rationally commensurate (to make (:r|) a basis for {reals} as a vector space over {rationals}), respects addition, yet may be made hideously discontinuous by suitable choice of r (quite apart from only being defined on a rational sub-space of {reals}). Such a mapping will only be continuous if r is, indeed, a restriction of some real scaling.

In so far as there are more scalings of V available than just the rationals, there are mappings kindred to the above which

respect additionon V, yet which won't respect those other scalings; so if we ask forall mappings which respect addition and commute with all mappings which respect additionwe'll get back only the rational scalings, even if there were others available to us. On the other hand, if we restrict to continuous mappings which respect addition, any of these that commutes with all of these will serve nicely as real scalings. The only fly in the ointment is the need to identify what continuity means.

Multiplication of positive rationals is now easy: they respect addition and commute with everything that respects addition, notably one another; so composition is abelian among positive rationals; in particular, since

- reverse(repeat(1+q))&on;repeat(1+p)&on;reverse(repeat(1+m))&on;repeat(1+n)
- = reverse(repeat(1+m)&on;repeat(1+q))&on;repeat(1+p)&on;repeat(1+n)
- = reverse(repeat((1+m).(1+q)))&on;repeat((1+p).(1+n)),

any composite of positive rationals is a positive rational; and it is clear that composition is giving the answers we're used to from multiplication.

Now, (: repeat(n,f)&on;repeat(m,f) ←f :{relations}) is repeat(n+m) so define, for positive rational s, r, s+r = (: s(f)&on;r(f) ←f :). The inputs we'll be giving this are displacements; among which addition is composition; so scaling a displacement by each rational and adding the results gives a natural displacement to think of as the result of applying the sum of the two scalings to the displacement.

Consider any relation f. Now, with s = reverse(repeat(1+q))&on;repeat(1+p) and r = reverse(repeat(1+m))&on;repeat(1+n), (s+r)(f) is s(f)&on;r(f). We have x = s(f) for which repeat(1+q,x) = repeat(1+p,f) and y = r(f) for which repeat(1+m,y) = repeat(1+n,f). Thus repeat((1+q).(1+m),y) = repeat((1+q).(1+n),f) and repeat((1+q).(1+m),x) = repeat((1+p).(1+m),f). Thus, with H = repeat((1+q).(1+m)), if x and y commute (e.g. because they're displacements), H(x&on;y) will equal H(x)&on;H(y), which is given to be repeat((1+p).(1+m),f)&on;repeat((1+q).(1+n),f), which is just repeat((1+p).(1+m)+(1+q).(1+n),f) = H((s+r)(f)), yielding s+r as reverse(repeat((1+q).(1+m))&on;repeat((1+p).(1+m)+(1+q).(1+n)), which is just what we're used to for rational addition: (1+p)/(1+q) + (1+n)/(1+m) is ((1+p).(1+m) + (1+q).(1+n))/((1+q).(1+m)).

This addition on the rationals is cancellable.

Some vector contexts come equipped with a family of scalars

which
induce scalings. I need to characterize the positive reals

among those.