This page is one of several that treat this topic, with much overlap; I'm working to collapse them all down to few. Most of this page is now accounted for by newer pages; only some scraps remain, in an old notation.

In general, a binary operator, say *, takes two values, say a and b, which
it combines to give b * a. [Note: not to be confused with binary predicates

,
e.g. <, =, > and sometimes ~, which are relations denoted by infix
operators.] Mathematics commonly deals with situations where z * ... * a

makes equally good sense, which turns the binary operator into a way of reducing
a list of values, [z, ..., a], to a single value. This is equally something
that integration will do to a suitable mapping (I| f :{values}), which leads to
discussion of binary operators in terms which reduce a function to a value,
typically of the same kind as

the values the function produced as outputs.
The list [z, ..., a] is just a special kind of function (it's inputs are the
indexes into the list, each producing the appropriate entry as output: it maps 0
to a, for instance, and 25 to z if the list really has 26 entries).

We can also write { star(c*b) } as ({b}: star&on;star(c) |); and note that the natural way to extract a mapping from a relation, r, at least when all final values are relations, is ((|r): b-> unite({b}: r |) :), so we can express associativity as (: b-> star(c)&on;star(b) :) is the mapping to which star&on;star(c) naturally reduces (which will be itself if it is a mapping, given that we know its outputs are relations).

The discussion of list-reduction needs to be separated off from that of the
binary operator (cancellability, completeness, identities, inverses,
distributivity) with associativity as the pivot. This is in line with a general
revolution needed: foundation

needs to become the ground with the naturals and
lists split off as the first structure - the skeleton. I shall, of course, need
to cross-refer between that skeleton and the discussion of binary operators, at
least in so far as list-append is a binary operator if vital importance to the
study both of lists and of binary operators (and how they beget bulk action).

Associativity:

- rats
pulls composition back through

star iff,- (|star:) = (|rats:) subsumes (:rats|), call the former A;
- for every a, b in A, star(a)&on;star(b) = star(rats(a,b)), iff
- for every list (n|f:A), bulk(&on;, star&on;f) = star(bulk(rats, f))

- star is associative iff it pulls composition back through itself bulk(&on;, star&on;f) = star(bulk(rats, f))

Look at the sub-relation of composition defined by restricting the inputs to S = (:star|), namely (S: s-> (S: r-> s&on;r :):). If all composites of members of S are, in turn, members of S we can take any composite star(a)&on;star(b) and know that there is some c in A for which star(c) is the given composite; so we can define rats = (A| a -> (A: star(a)&on;star(b) = star(c), b -> c :A) :). As defined, rats is a mapping and its outputs are relations (A::A). It will be interesting to study the conditions under which they, or their reverses, are mappings; and when (:rats(a)|) or (|rats(a):) is all of A.

We can perform this construction even when star's outputs aren't (A|:A), just so long as they are relations (or mappings, or collections, of course) and S is closed under composition. subsumes is a central structure within unite and intersect.

Given topologies on A, B, C we can infer one on {continuous (B|:C)} and thus
obtain the notion of continuity for mappings (A| :{continuous (B|:C)}). I'll
describe a binary operator (A| :{(B|:C)}) as continuous if it is, indeed,
continuous (A| :{continuous (B|:C)}). To what extent could we use a binary
operator's associated mapping to *define* a topology, by declaring the
mapping and its outputs continuous ?

Elsewhere binary operators are central players in discussions of associativity (whence groups) and distributivity, both of which show up when we come to consider scalars and vectors. Binary operators are themselves fore-shadowed in the discussion of arrow worlds and categories, in which composition appears as a binary operator on arrows or morphisms.

Written by Eddy.