# notations

Florent Becker florent.becker at ens-lyon.org
Mon May 4 08:35:25 EDT 2009

``` > Hi Everyone.

Hi Daniel, after having worked a fair bit with camp's theory, I
appreciate your initiative to make
up some new notations. However, I have a big problem with your
proposal, which is that your operators all have connotations for
mathematicians which are the wrong ones. Hence, i'd advise choosing
other ascii notations.

>1) The first one I already discussed with Mannix and Ian, but I
include
>it for the benefit of other list members:

>Mannix proposed an operator for moving a patch over another. I propose
>using the "/" opertor. So that "P/Q" is read "P over Q" and is the
>action of moving patch P over patch Q:
>
>           P
>     +------------->
>     |
>   Q |
>      |
>     V
>     +------------->
>          P/Q

(sorry if i butchered the ascii art)

Please use another ascii notation for this, such that it doesn't get
read "P divided by Q".
I'd suggest P\Q, which looks a bit like exponentiation, see later why
i think it should. Even if I like the idea of having a notation for
this operation, I still think that commutation should be the primary
operation, see the end of this mail for why.

> 2) This one is new: I propose using ">" to denote patch
composition. So
> that "X > Y" is read as "X then Y". The ">" is intended to look
like an
> arrow, so it indicates direction.

I think that this operation is so common that it should be denoted by
juxtaposition. Otherwise,
use '.' or ':' or '+' . In any case, not something that reads "greater
than", especially since dependencies are a partial order on patches.

>3) Mannix proposed using "-P" to denote the inverse of patch P. On top
>of that, I propose using the number "0 to denote the empty patch.

I'd suggest keeping either an additive syntax or a multiplicative
syntax that is :
-either patch composition is +, inverse is - and 0 is the empty patch/
sequence
-or patch composition is . (or juxtaposition), inverse is ^ (or ^{-1}
in latex) and 1 (or id) is the empty patch/sequence

I'd advocate the second one:
- Using + for a non-commutative operation is a big no-no
- Using . or juxtaposition for sequence is lighter in notation
- It looks very much like function composition, which is what is
really happening (except that we can only manipulate representations
of functions).
-It's also the notation of category theory, of which patches are an
instances, with objects being the "repository states" and morphisms
the patches.

The properties become:

A) Basic properties:

- P.1 = 1.P = P

- P.P^ = 1

- (P.Q)^  = Q^.P^

This looks similar to the traditional use of "." and "^" in algebra,
in non-commutative groups, and in category theory.

B) "Quasi-associative" property:  R / (X > Y) = (R / X) / Y

R\(X.Y) = (R\X)\Y

\ looks a bit like exponentiation, which makes this law natural. (it
is the same as p^(q.r) = (p^q)^r in algebra).

C) Merging:  P > Q/P = Q > P/Q

P.(Q\P) = Q.(P\Q)

Note:  I like commutation as the primary operation because it makes
sense from an algebraic/topologic point of view. Picture the
repository states as dots, patches as arrows between the dots, as you
do in the ascii diagrams. Then you can represent the commutation:
<P,Q> <~> <Q',P'> (or equivalently Q = Q'\P and P' = P\Q') as the
patch sequence (commute(P,Q)=Q^.P^.Q'.P') so that PQ.commute(PQ) =
Q'P'. This way, the sequence commute(PQ) is going around the square
whose sides are P, Q, P', Q', in the counterclockwise direction. So we
can say that this square is "full" if P and Q commute into Q' and
P' (ie, there is a small surface between the four patches). Then two
longer sequences are the same modulo commutation if you can deform one
into the other without leaving the surface defined by all the
commutation squares. This is called being homolog in topology, and it
could be a very useful tool.

Sorry to bike-shed, but a good notation is very important.

Florent

```