This is an exploration.
Presume:
r relates x to yiff
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
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:
closed under composition,
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.
Introduce a mapping
which I'll describe as linear extension
, and from it build
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
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:
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 subsumes G, G unitive for Cimplies 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