Scalars

In what follows, V is a collection on which an addition is defined: I intend to switch to a discussion in which the addition is named V, with (:V|) then being the collection of right operands, which will typically also be the collection of left operands. But I have other transformations to perform first, and intend to give this one some more thought before getting on with it. [Eddy/2001/Jan/6]

Given a linear context V, we obtain {linear (V:|V)} on which we have addition and composition as binary operators. Those linear (V:|V) which commute with all members of {linear (V::V)} are scalings:

• {scalings of V} = {linear (V:g|V): for all linear (V:f:V), f&on;g = g&on;f}

Linearity implies that composition of scalings behaves like multiplication in relation to addition (of scalings); in particular, there are scalings that correspond to repeated addition (i.e. multiplication by a positive integer). Once we need to deal with several linear contexts and linear maps between them, we obtain relationships between the scalings of contexts: each linear (U::V) induces a linear ({scalings of U}: :{scalings of V}) which respects composition; we shall generally be concerned with cases where {scalings of U} and {scalings of V} are isomorphic (as paddocks).

Our addition on V may be construed as an embedding of V in {(V:|V)}, on which we have composition as a binary operator; with add = (: (V: add(v,u) = v+u ←u :V) ←v :V), associativity says add(a)&on;add(b) = add(add(a,b)). A (V:f:V) respects addition iff f(a)+f(b) = f(a+b) for all a, b in V. We can describe positive integer scalings as (V: (1+n).v = repeat(n, add(v), v) ←v |V) ←1+n for natural n. Each respects addition and commutes with anything else which respects addition. This embeds the positive integers in {scalings (V:|V)} and, in doing so, respects addition on the positive integers.

From any embedding scale = ({scalings (V:|V)}: (: a.v ←v |V) ←a |S) which respects addition, we can compose outputs of scale; scale(a)&on;scale(b) is (V: a.(b.v) ←v |V); if (|scale:S) is closed under composition - e.g. if it's all of {scalings (V:|V)} - we can infer a binary operator on S which combines a and b to produce any member of ({scale(a)&on;scale(b)}:scale|). I should then show that this binary operator embeds S in {scalings (S:|S)} and respects addition in doing so; ideally infer a natural isomorphism between {scalings (S:|S)} and {scalings (V:|V)}. Thus whenever {scalings (U:|U)} and {scalings (V:|V)} are isomorphic, we can infer naturality of the isomorphism and treat scalings on U and scalings on V as the same; any (U:f:V) which respects addition can then be said to commute with scalings. We have (U: a.f(v) ← v |V) = scale(a)&on;f and scale(a) is in {scalings (U:|U)}; even though this isn't actually a member of {scalings (V:|V)}, naturality would let us treat it as though it were and write f&on;scale(a) for (U: f(a.v) ←v |V) in order to ask whether f&on;scale(a) and scale(a)&on;f are equal (and, asking, get the answer yes).

But that all presumes the notion of scaling, and all I know how to define is the real scalings - these are (V:z|V) which respect addition and commute with all (V:|V) which respect addition.

A second flavour of scaling springs to mind: relations (V:r:V) which respect addition and commute with all (V::V) which respect addition. For any such r we can identify (r:v←v:), the collection of r's right values (called inputs when r is a mapping), which is subsumed by V. Since r respects addition, u, v in (:r|) implies u+v is also in (:r|), so that r(u)+r(v) can be equal to r(u+v); so (r:v←v:) is closed under addition which is to say it's a collection and respects addition. for any (V:f:V) which respects addition, we have f&on;r = r&on;f so

Polynomials

Repeat and compose suffice to describe polynomials. For an orthodox polynomial, we need an additive context V (so sums of V's members make sense) and a field, S, of scalars, so multiplying by S's members makes sense, hence multiplying by powers of S's members also. We can then define a mapping from lists (V::) to polynomial mappings (V:|S) by ({polynomials}: (V: sum(V: power(i,x).h(i) ←i |n) ←x |S) ←(V:h|n) :{lists (V::)}) with power and sum defined suitably. Representing V's members by the translations on V, using (V: u+v ←v :V) ←u, and S's by the scalings of V defined by (V: x.v ←v :V) ←x, I can re-cast the above as:

• polynomial = (: (: compose(: repeat(i,x,h(i)) ←i :n) ←x :{relations}) ←h :{mappings ({relations}::n): n is natural})

and describe any left value (output) of polynomial as a polynomial; though I'll write (|polynomial:) - which is (:x←x:polynomial) because polynomial is a mapping - by preference to {polynomials}. All orthodox polynomials are then, indeed, polynomials; albeit orthodoxy builds them from different components, related to the x and (|h:) used here by a representation of the kind just described - entries in h will be translations, each x will be a linear map from translations to translations, archetypically a scaling, so that we can read the entries in h as coefficients of the various powers of the input, x, in the sum which forms the polynomial.

Now, on (|polynomial:) we can define differentiation, entirely algebraically, by

• derivative = (: polynomial(: repeat(1+i,h(1+i)) ←i :) ← polynomial(h) :)

which will then naturally behave orthodoxly, at least when h's members represent an orthodox context in the manner indicated above - each h(i) is a translation, so repeating it corresponds to scaling it by a natural; combined with shifting down the list, by using h(1+i) in the entry at position i, this achieves the decrease the exponent by 1 needed. Note that derivative naturally pulls back, via polynomial, to the mapping (: repeat(1+i,h(1+i)) ←i :) ←h on lists of relations, which has certain naturalities of its own.

Sequences and convergence

We have the positive rationals as Q = {reverse(repeat(1+q))&on;repeat(1+p): p, q are naturals}. A sequence is a mapping (:|N) for which N is either {naturals} or a natural; when N is a natural, the sequence is also known as a list; {sequences} subsumes {lists}. The members of the (|:) of a sequence (or list) are known as its entries; the members of N are known as its indices. On rationals we have addition and multiplication; from the former we may construct summation of lists.

Now, a sequence may be infinite, in which case sum isn't defined on it: but its restriction to any positive natural is a non-empty list, so can be summed. We can thus induce a mapping, partialSum = ({sequences (Q::)}: (Q: sum(:h:1+n) ←n :) ←h :{non-empty sequences (Q::)}) yielding a sequence of partial sums from any given sequence. If h is a list, in the formula given for partialSum, then every n > (:h|) has (:h:n) = h so partialSum(h,n) = sum(h); a list's partialSum is a sequence, s, for which s&on;repeat(n,successor) is constant for some n.

So the way we can make infinite sums behave themselves is to have their composites after repeat(n,successor) become progressively more like constant as the natural n increases. I can package the orthodox notion of convergence using:

Positive rational sequences h and g are mutually convergent iff

for every positive rational r, there is some natural n for which n in naturals i, j implies r+h(i) > g(j) and r+g(j) > h(i); which may be read as h-g converges to 0, though it's a stronger condition since h-g only considers the cases with i=j.

in which > is the ordering on positive rationals induced from a>b iff a = b+c for some positive rational c. I'll describe each fixed point of mutual convergence as a convergent sequence. Every value of mutual convergence is a convergent sequence, so mutual convergence is reflexive; that it's symmetric is trivial from its specification; that it is transitive takes a moment's thought to verify; so it specifies an equivalence on convergent positive rational sequences. It also respects addition, hence scaling, and has an equivalence class whose members serve as additive identities; addition is cancellable modulo the equivalence and, given sequences h and g we can always find a sequence k for which either h+k is equivalent to g or g+k is equivalent to h, so we obtain a form of partial completeness whose either/or gives us an order on sequences; if k is an additive identity, h and g are equivalent (i.e. h=g); otherwise, we can say h>g if h=g+k or g>h if g=h+k and, because k isn't an additive identity, we know there's some positive rational r for which partialSum(k)&on;repeat(n,successor) has some output not <r, for every natural n, from which we can infer that only one of h>g and g>h will hold true.

Now, for any natural n, (:successor:n) is the list [1,...,n] or, if n is empty, []. We can define product = reverse(repeat)&on;compose&on;(: repeat&on;h ←h :{lists of naturals}) and use it to obtain factorial = ({naturals}: product(:successor:n) ←n :{naturals}) whence the sequence ({positive rationals}: reverse&on;repeat&on;factorial :{naturals}). Writing n! for factorial(n), we have (1+n)! = n!.(1+n) and the given sequence is [1,1,1/2,1/6,...,1/n!,...] whose sum is the transcendental number e which is the base of the flavour of logarithm for which log' = (: 1/x ←x :). The sequence's entries are all positive rationals and it's a fixed point of (:repeat(1+i,h(1+i)) ←i :) ←h. That it is an additive identity for the convergent positive rational sequences is trivial - it decreases monotonically (and for ever faster) and: for each natural n there is some natural i for which factorial(i) > n, so every rational r (being > 1/n for some positive natural n) allows some natural n for which n in m implies m.r>1.

Note that reverse&on;repeat&on;factorial is reverse&on;repeat&on;product&on;(: (:successor:n) ← n :) a.k.a. (: reverse(repeat(product(:successor:n))) ← n :), and repeat&on;product is compose&on;(: repeat&on;h ←h :{lists of naturals}), giving us reverse&on;compose&on;(: repeat&on;h ←h :{lists of naturals})&on;(: (:successor:n) ← n :) in which the two formulae compose to give repeat&on;(: successor :n) ←n; and (:successor:n) is successor&on;n since n is a collection; so we get our sequence (summing to e) as reverse&on;compose&on;(: repeat&on;successor&on;n ←n :{naturals}) as (: 1/n! ←n :), a sequence converging towards an additive identity.

the outputs of (:repeat&on;successor:{naturals}) commute with one another. Now, reverse&on;compose maps h = [h(0),...,h(n)] to reverse(h(n))&on;...&on;reverse(h(0)) = compose(: reverse&on;h&on;(: i+j+1=n; i←j :n); when, h's entries commute with one another, the permutation (: i+j+1=n; i←j :n) has no effect, so we get compose(: reverse&on;h :) in place of (reverse&on;compose)(h). The above has h = repeat&on;successor&on;n for some natural n; h's entries are outputs of repeat, so commute with one another; so reverse&on;compose&on;(: repeat&on;successor&on;n ←n :{naturals}) is just compose&on;(: reverse&on;repeat&on;successor;&on;n ←n :{naturals}).