I'll characterize a category by a mapping, C, for which:

- C is a mapping, so (|C:) is a collection - its members are C's
morphisms

- C's right values (i.e. inputs) are lists of C's morphisms; f in (:C|) implies f is ((|C:): f |n) for some natural n.
- C's right-restriction to lists of length greater than n yields all of (|C:) as left values, for any natural n (though n = 1 will suffice to imply all greater n; and n = 0 is about to be rendered fatuous)
- a in (|C:) implies C([a]) = a
- [a,…,f], [f,g] and [g,…,z] are all in (:C|) iff
[a,…,f,g,…,z] is in (:C|); and, when this arises,
C([a,…,f,g,…,z]) = C([ C([a,…,f]), C([g,…,z])
]).
*In extremis*, [a,…,f] may be [f] or [g,…,z] may be [g]; though applying both produces a fatuous statement.

and if we really want we can insist that, for each f in (|C:) there are an e and an i in (|C:) for which C([f,e]) = f = C([i,f]) = C([i,f,e]); i.e. that each morphism is composable between a pair of identities. Note that nothing is said about the empty list: it is not expected to be a member of (:C|), but a category with a global identity can use this as C([]).

Note that we can use the final characteristic to join lists and to split
them (it's also our guarantee of associativity). Furthermore, it tells us
that a list ((|C:):f|1+n) will be in (:C|) precisely if, for each i in n,
[f(i),f(1+i)] is in (:C|) - i.e., all C's right values can be inferred from
its right values of length two. This gives C an associated
relation, composability

for which: f is composable to the left
of

g iff [f,g] is in (:C|) iff g is composable to the right of

f. Then C's right values are the lists for which adjacent entries are
composable in the order in which they appear.

Define two useful tools, mappings from categories to (effectively) an encoding of composability:

- Left = (: (: {g: [g,h] in (:C|)} ←h :C) ←C :{categories})
- Right = (: (: {g: [h,g] in (:C|)} ←h :C) ←C :{categories})

and we can generally expect that if Right(C,f) and Right(C,g) have non-empty intersection one of them subsumes the other (they may well be equal); and likewise for Left.

Now consider two categories, C and D, as above, in the light of some
mapping ((|D:):t|C). For any h in (:C|), t&on;h is a list of D's morphisms:
if it's in (:D|), we can compare D(t&on;h) with t(C(h)). Any t for which the
two are equal for all h in (:C|) is described as a functor

from C to
D.

Somewhat more fiddly, now consider a mapping ((|D:): t |C) for
which: Left(C, y) subsumes Left(C, x)

implies Left(D, t(y)) subsumes
Left(D, t(x))

and likewise for Right in place of Left; I'll call t
a transformation

in this case.

Describe two parallel transformations, ((|D:): s |C) and ((|D:): t |C),
as conjoinable

, in the given order, iff: [f,g] in (:C|) implies
[s(f),t(g)] in (:D|) and; C([f,g]) = C([u,v]) implies D([s(f),t(g)]) =
D([s(u),t(v)]). In such a case, the conjoint, ((|D:): s*t |C) is induced from
D([s(f),t(g)]) ← C([f,g]). One may rephrase the definition as: [s,t] is
conjoinable iff (: D([s(f),t(g)]) ← C([f,g]) :) is a mapping (: s*t
|C).

I'll say that a functor, ((|D:): F |C), begins

a transformation
((|D:): T |C) precisely if [T,F] is conjoinable, with T*F = T; or that
F ends

T iff [F,T] is conjoinable, with F*T = T. If functors F and G
begin and end (respectively) a transform T, I'll say that T transforms F
into G

.

I have older writings, differently expressed, but on a related topic.

Valid CSS ? Valid HTML ? Written by Eddy.