# Continuity

This is an exploration.

Presume:

• a list is a mapping, (:f|n), for some natural n = (f|i←i:), known as length(f).
• a binary operator, @, on lists specified by h@g = h&unite;(: g(i) ← i+length(h) :), i.e. the list which starts (at left) as h, appending g to its right; when h is [u,...,v] and g is [w,...,x], the union given is [u,...,v,w,...,x].
• The bulk action of @ is append = (: a@...@z ← [a,...,z] :{lists}), specified by: append([]) = [], append([f]) = f for any list f and append(h@g) = append(h)@append(g) for all lists, h and g, of lists.
• a binary operator, &on;, on relations: r&on;s relates x to z iff r relates x to some y which s relates to z.
• The bulk action of &on; is compose = ({relations}: a&on;...&on;z ← [a,...,z] :{lists of relations}) relates the universal identity to [], each relation f to [f] and compose(h)&on;compose(g) to h@g, for each h and g in (:compose|).
• repeat = (: (: compose({r}:|1+n) ←r :{relations}) ←1+n :{naturals}), in which ({r}:|1+n) is the unique list, of length 1+n, having no entries other than r; so repeat(m,r) = compose({r}:|m) is the result of composing r with itself m times - and using m=1+n insists that m be positive.
• reverse = (: r relates x to y iff s relates y to x; s←r :), which acts on relations [not to be confused with the operation on lists, specified by (: (: i+j+1 = n; h(j) ←i :) ← (:h|n) |{lists}), which performs the [a,...,z] ← [z,...,a] reversal].

Any binary operator, *, can be encoded as a relation (: (: a*b ←b :) ←a :), call it star, which effectively embeds the left operands of * in the collection of relations with right operands of * as right values and compound values, such as a*b, as left values. Composition of such relations will yield relations; if every composite of star's outputs is one of star's outputs, then we'll be able to compose an arbitrary list of star's outputs and apply reverse(star) to the result to pull back those left operands of * which star relates to the composite. Any list of star's left operands may be combined in this way - mapping each entry through star, composing then pulling back through star - to produce a left operand of *, ambiguous in so far as star isn't monic. This gives *'s bulk action as

• bulk(*) = reverse(star)&on;compose&on;(: star&on;h ←(star:h:) :{lists})

Thus all important discussion of binary operators is embraced by discussion of composition; and most places where I mention compose below could as readilly use any bulk action. [Note that star is a mapping, making star&on;h a list for any list (star:h:). If it weren't, we'd have to substitute (: star&on;h subsumes list (:f|n); f ←(:h|n) :{lists}) in place of (: star&on;h ←h :), since star&on;h might now have several left values (candidate entries) for each (index in the list) right value of h; this will potentially allow us many lists, of h's length, subsumed by star&on;h, each of which it makes sense to use as a left value related to h.] We can employ reverse(star)&on;repeat(n)&on;star as scaling by positive natural n.

Describe a collection, C, of relations as a rational compost iff:

• (C: compose |{lists (C::)}), i.e. C is closed under composition,
• n in naturals implies (C|repeat(1+n):C), i.e. every member of C can be divided by 1+n

Why compost ? (Aside from lack of a better word) It's got nice relationships with compose. Why rational ? Because the first constraint enables us to treat repeat as a multiplication between positive naturals and members of C; and the second lets us extend this to a multiplication between positive rationals and members of C by considering (C: reverse(repeat(1+n)) |C) which, though not a mapping, behaves like the scaling 1/(1+n).

Now, for any rational compost C, we have the non-abelian binary operator &on; in the role of an addition, inducing repetition to give scaling by the positive naturals, and we have reverses of these scalings to use as inverses. Then composing a list of p instances of 1/q's outputs gives scaling by the arbitrary rational p/q, albeit we have to take some account of reverse(repeat(q)) not being a mapping: this gives us repeat(p)&on;reverse(repeat(q)) as p/q.

If p and q have a common factor, n, this composite can be re-arranged to have repeat(n)&on;reverse(repeat(n)) in the middle; now repeat(n) is a mapping and, for any mapping f, f&on;reverse(f) = (:f(c)←c:)&on;(:c←f(c):) = (:f(c)←f(c):) = (|f:) with f(c) unambiguous for each c, this is just the collection of f's left values; so repeat(n)&on;reverse(repeat(n)) is simply the collection of outputs of repeat(n), which is C (for positive n), rendered invisible by composing it between a pair of mappings (C::C). Thus (n.p)/(n.q) = p/q for positive naturals n, p and q.

Note that (C: reverse(repeat(q))&on;repeat(p) :C) is the subtly different mapping which repeats a member of C p times, then cuts the composite into q equal pieces; as opposed to cutting the input apart then repeating the pieces. When we eliminate a common factor, n, from q and p, we now get reverse(repeat(n))&on;repeat(n) which is the equivalence relation, on members of C, described by repeating these n times gives the same answer. This gets to be composed between reverse(repeat(q)) and repeat(p) with the common factor stripped from each of q and p, so a rational this way round would subsume, and not necessarily be equal to, its coprime form.

## Linearity

Introduce a mapping

• expan = (:
(C:
(C:h|n) is a list, r&on;h subsumes list (:f|n);
compose(f) ← compose(h)
:C) ←(C:r:C)
:{relations}),

which I'll describe as linear extension, and from it build

• span = (: m natural, expan(r) relates repeat(1+m,a) to repeat(1+m,b); a←b :)

I'll describe span's fixed points as linear. Consider any relation (C:r:C); if r relates a to b, then r&on;[b] subsumes [a], so span(r) relates (via m = 0) compose([a]) = a to compose([b]) = b; thus span(r) always subsumes r; thus a relation (C:r:C) is linear precisely if it subsumes its linear completion, span(r).

Now, span(r) is a union of: for each natural m, T(r,m) = (: expan(r) relates repeat(1+m,a) to repeat(1+m,b); a←b :) = reverse(repeat(1+m))&on;expan(r)&on;repeat(1+m). If lists f and h satisfy expan's constraints, r&on;h subsumes f and (:h|) = (:f|), so that expan(r) relates compose(f) to compose(h), then appending 1+n copies of each list gives append({f}:|1+n) and append({h}:|1+n), for any natural n, which must also satisfy expan's constraint. Applying compose to each of these yields repeat(1+n)'s output when given compose(f) or compose(h) as input, respectively. Thus expan(r) also relates repeat(1+n,compose(f)) to repeat(1+n,compose(h)), whence T(r,n) relates compose(f) to compose(h). Thus each T(r,n) subsumes expan(r).

When 1+n = (1+k).(1+m), T(r,k) relates a to b iff expan(r) relates repeat(1+k,a) to repeat(1+k,b); in which case there are lists f, h satisfying expan's constraints, whose composites are repeat(1+k,a) and repeat(1+k,b); we can append 1+m copies of those lists, as before, to obtain lists satisfying expan's constraints, whose composites are repeat(1+m) applied to the composites of f and h, so expan(r) relates repeat((1+m).(1+k),a) to repeat((1+m).(1+k),b), and T(r,n) relates a to b. Thus T(r,n) subsumes T(r,k) whenever 1+n is a multiple of 1+k; that each T(r,n) subsumes expan(r) = T(r,0) is then just the special case k=0.

In particular, for each natural n, each T(r,m) is subsumed by reverse(repeat(1+n))&on;T(r,m)&on;repeat(1+m) = T(r,n+m+nm). Now, span(r) = unite({ T(r,m): natural m}) inescapably subsumes unite({ T(r,k): n is a factor of natural k}) = unite({ T(r,n+m+nm): natural m}) yet the latter equally subsumes the former, so must be equal to span(r). The latter is equally reverse(repeat(1+n))&on;unite({ T(m): natural m })&on;repeat(1+n), so we obtain span(r) = reverse(repeat(1+n))&on;span(r)&on;repeat(1+n). Now, repeat(1+n) is a mapping, so repeat(1+n)&on;reverse(repeat(1+n)) is the collection of outputs of repeat(1+n), and we're restricting to C anyway, on which (C|repeat(1+n):C), so the collection is just C, which subsumes (:span(r)|) and (|span(r):), so we obtain

• repeat(1+n)&on;span(r) = repeat(1+n)&on;reverse(repeat(1+n))&on;span(r)&on;repeat(1+n) = span(r)&on;repeat(1+n)
• span(r)&on;reverse(repeat(1+n)) = reverse(repeat(1+n))&on;span(r)&on;repeat(1+n)&on;reverse(repeat(1+n)) = reverse(repeat(1+n))&on;span(r), and

Thus repeat(1+n) and its reverse commute with every linear (C:r:C). I'll describe a linear (C:f:C) as a real scaling for C iff it commutes (i.e. f&on;r = r&on;f) with every linear (C:r:C); we have just seen that repeat's outputs and their reverses are real scalings.

Clearly any composite of linears is linear and any composite of real scalings is a real scaling. Hence every rational, repeat(1+p)&on;reverse(repeat(1+q)), is a real scaling of every rational compost.

Given an equivalence, M, describe a rational compost, C, as a rational facade for M iff:

• M = unite({(|f:): f in C}), i.e. M relates x to y iff some f in C relates x and y to the same values, ({x}:f|) = ({y}:f|).
• f in C implies
• M subsumes (|f:), implied by M being the given union,
• (|f:) = (|M&on;f:) and
• (:f|) = (:f&on;M|), from which we can infer M&on;f&on;M = f.
• (C:reverse|C), i.e. the reverse of any member of C is a member of C
• (C: (:f|) ←f |C), (C: (|f:) ←f |C), i.e. likewise, pre- and post-equivalences of C's members are also in C

I think I can talk C into telling me that M is a continuum, at least up to rationals. Note, however, that there may be several suitable g, in the latter case, for any given f. The f in C conditions (aside from populating C with some equivalences, subsumed by M, to treat as identities) tell us that we can treat C's members as if they were monic mappings and M were a collection.

I also want to introduce D = (|unite:{G: C subsumes G and f, g in G implies M subsumes f&on;reverse(g) and reverse(g)&on;f}), so as to get unions while still letting each e = (:e|) in C be small enough that repeat's outputs are well-behaved on {(e:f:e): f in C} - see below.

Now I'm going to treat T = {f in D: M subsumes f} as if it were an open topology, in classical terms. It contains any union of its members, by construction of D. Composition of its members (which are, in effect, identities) is synonymous with intersection (when each identity is read as its collection of fixed points), so the first constraint on C makes any finite intersection of T's members another member of T.

Now, what is this unassuming little definition trying to say ? That I can get something that feels like a star-shaped domain around any member of C. I can then exploit the linearity structure induced from using composition as addition to tangle this up with rational scaling - by use of repeat's left values and their reverses, subject to care about clipping to within a neighbourhood. How do I get hold of that star-shaped domain ?

I believe I need each e = (|e:) in C to be small enough in some way that makes ({non-empty}: repeat(n) :{(e:f:e): f in C}) well-behaved for each natural n ... in what sense ? I want to identify some A subsumed by D, closed under &on; with (: (: f&on;g ←g :A) :A) abelian and (A| repeat(n) :A) monic - enabling us to sub-divide each member of A arbitrarily and uniquely (so A leaves out messy things like rotations: I'm trying to make it feel like (a neighbourhood of the origin in) a group of translations); for each e = (|e:) I want such an A with e subsumed by each (:f|) with f in A.

Take any (|e:) = e = (:e|) in C and look at E = {(e:f:e): f in D}, which is probably going to have empty as a member - resulting from all the f in D for which (|f:) or (:f|) doesn't have any intersection with e. Each f in E is equal to e&on;f&on;e. [A more sophisticated version will consider parallel(e) = {((|e:):f:(:e|)): f in D} for unconstrained e in C; combining f, g to give f&on;reverse(e)&on;g.] Within E, consider some collection F (to be construed as a neighbourhood of the identity, e) for which:

• F is a facade for e
• f, g in F with non-empty intersection implies unite([f,g]) in F
• F subsumes G, G unitive for C implies unite(G) in F

To build myself (something that feels like a neighbourhood in) a vector space, what I need is: C subsumes V, V is closed under &on; for any natural n, (V|repeat(1+n):V) is monic (: (V: u&on;v ←v |V) ←u |V) is abelian so that repeat(m, u&on;v) = repeat(m,u)&on;repeat(m,v) construe &on; as an addition on V repeat as a multiplication between positive naturals and members of V The mess is going to happen with closed under &on;, which will force empty in V, with ugly results I don't want so: V really wants to be an equivalence on some sub-collection of C; indeed, V wants to be (:s|) for some transitive sub-relation s of (C:subsumes:C) for which (|s:) = s&on;reverse(s), or something similar specify real linearity by: (V:f:V) is real linear for V iff f relates g to u, h to v implies f relates g&on;h to u&on;v a.k.a. f(u+v) = f(u)+f(v), though f is not obliged to be a mapping whence we can infer that f(repeat(m,u)) = repeat(m,f(u)), i.e. f&on;repeat(m) = repeat(m)&on;f in so far as V is bounded, repeat(m,u) may have fallen off the edge even when repeat(m,f(u)) hasn't; falling off the edge ends up being encoded as repeat(m,u) = empty, so a linear (V:f:V) is apt to relate many values to empty (i.e. even if it's a mapping on most of V, it's multi-valued on some of it) in particular, repeat(m) is real linear for every positive natural m; and reverse(f) is real linear iff f is real linear We can define an addition on {relations (V::V)} by f+g is the union of: (:f:{x not in (:g|)}), (:g:{x not in (:f|)}) and (V: f relates u to y, g relates v to y; u&on;v ←y :V) implicitly treating g(y) as M (serving as the universal identity) when y isn't in (:g|) but is in (:f|); likewise with f, g swapped. Whenever f, g are real linear (V::V), so is f+g: (f+g)(u&on;v) = f(u&on;v) &on; g(u&on;v) = f(u)&on;g(u)&on;f(v)&on;g(v) = (f+g)(u) &on; (f+g)(v) and all the mess with implicit identities does the right thing ? we need to verify that: f+g relates a to u, b to v implies f+g relates a&on;b to u&on;v so: given: f+g relates a to u, b to v one of the following holds: a = i&on;k, f relates i to u, g relates k to u f relates a to u, u isn't in (:g|); take i = a, k = M g relates a to u, u isn't in (:f|); take k = a, i = M either way, a = i&on;k and u in (:f|) implies f relates i to u; else i is M u in (:g|) implies g relates k to u; else k is M likewise, b = j&on;h, each related by f or g to v then a&on;b = i&on;k&on;j&on;h = i&on;j&on;k&on;h because M commutes with any member of C, hence any member of V, and each of i, j, k, h is either M or in V, on which &on; is abelian and f relates i to u, j to v will imply f relates i&on;j to u&on;v, when true; otherwise, one of i, j is M, i&on;j is then equal to the other; Then for any linear (V:f:V) we can induce ({(V::V)}: f&on;g ←g |{(V::V)}) and observe f&on;(g+h) = f&on;g + f&on;h because it's essentially (V: f(g(y)&on;h(y)) ←y :V) which, by linearity of f, is (V: (f&on;g)(y)&on;(f&on;h)(y) ←y :V), which is what f&on;g + f&on;h is specified to mean so (: f&on;g ←g :) is linear ({(V::V)}: |{(V::V)}) for every linear (V:f:V) Furthermore, specify real scalings by: linear (V:f:V) is a real scaling of V if, for every linear (V:g:V), f&on;g = g&on;f. Trivially, the reverse of a real scaling is always a real scaling; and every repeat(1+n) is a real scaling

Written by Eddy.