### ∼ The Calculus of Circles and Letters ∼

#### CL expressions

Clara was Algernon's daughter. She played her game, which she called 'the calculus of circles and letters' - or 'CL-calculus' for short - in the universe of 'CL expressions'. These are signs built up of circles and lower-case letters. Most of them are mixtures of circles and letters; but some contain no letters, some contain no circles, and just one contains no letters or circles. (This last we call the empty expression.) Here are some examples: The expressions which contain no letters we term 'arithmetic expressions'. Given any CL expression, one may choose to ignore the letters in it. If one has eyes only for the circles in the expression, what is revealed is the circle-structure or skeleton of the expression. Clearly, the skeleton is an arithmetic expression.

The set of CL expressions is a sort of chaos, into which, following Clara, we aim to introduce an element of order.

#### Upper-case Letters

We keep the upper-case letters in reserve for another purpose. It is often useful, given an expression, to have a name for it. This is how we use the upper-case letters - as names of expressions. For example, 'let A stand for the expression x(y)'. Equally, we may say 'let A be an expression'. This is a typical move or 'transaction' in discussions of the CL-calculus. It means something like 'Think of an expression; let's call it A'. Then I proceed to make statements about A, or do things to A which are described in such a way that they could evidently be applied to any expression, so that the actual expression you come up with never needs to be described. (Usually, in fact, you don't need to actually come up with an expression at all!)

I can now say things like: 'Let A and B be expressions; consider the expression C = (A(B(A)))'. The idea is that you think up - or at least, we all pretend that you think up - expressions which we agree to call A and B; then I combine A and B into the form (A(B(A))) and call this new expression, C.

#### Forms and instances

We may therefore consider an enlarged class of expressions which contain upper-case letters as well as lower-case. Each such generalized expression may be regarded as a form or template for certain others, its instances. Thus each generalized expression G determines a subclass of the universe of CL expressions, whose members are 'expressions of the form G'. How this works is best illustrated by examples:

 Generalized expression G Description of the subclass 'expressions of the form G' X any expression whatsoever (X) O, with any expression you like inserted inside it; nothing in the outer space (outside the circle) (X)(Y) OO with any expression inserted in the first circle, any expression in the second, nothing in the outer space (X)O OO with any expression inserted in the first circle, nothing in the 2nd, nothing in the outer space X((Y)) double circle (O) with any expression inserted in the inner space, any expression in the outer space, nothing in the intermediate space ((X)X) (O) with any expression inserted in the inner space, and with the same expression inserted in the intermediate space, nothing in the outer space O O only O O OO only ((P)(Q)) (OO) with any expression in the first inner circle, any expression in the second inner circle ((PR)(QR)) determines the same subclass as ((P)(Q))(because _ is a possible instance of the form R)

The letters tell us where flesh can be added to the bare bones of the skeleton. The same letter in two or more places means that the same 'flesh' (i.e. the same sub-expression) must be put on in all those places, in order to create an 'instance' of G (which is another way of saying, an expression of the form G). For each upper-case letter one is at liberty to chose as its 'flesh' the empty expression _ .

#### Play Area for CL Expressions

Click anywhere to place a circle. Hold down a letter-key on the keyboard, and click, to place a letter anywhere. Shift-click to remove a letter or an empty circle.

If you're having difficulty making letters, you may need to disable 'hardware acceleration' in the Flash-player that is plumbed in to your browser. To do this, right-click in the play area, select 'Settings', select the left-hand icon along the bottom (for Display), and untick 'Enable hardware acceleration'.

#### Legal moves

Clara laid down certain moves, by which one expression may be transformed into another.

The allowed moves spring from an initial set of six moves. The six moves consist of three matched pairs; in each pair, one move is the reverse of the other. The three pairs (with the names of the moves) are as follows:

 A ↔ ((A)) → wrap ← unwrap O A ↔ O → delete ← undelete A(B) ↔ A(AB) → copy ← uncopy

Here A stands for 'any expression you like', as does B; obviously B can be different from A, although it doesn't have to be.

So wrap says, any expression may be converted into the same expression surrounded by two circles; whereas unwrap says, any expression of the form ((A)) may be converted into A; that is, the two outer circles may be removed. The other two rules are to be interpreted in a similar way.

But that's not all! The expression A does not need to be standing all alone for wrap to be applicable to it. On the contrary, wrap may be applied to A wherever it occurs in a larger expression. In the same way, unwrap may be applied to an expression of the form ((A)) wherever such an expression occurs within a larger expression.

For example, Here, the expression A to which wrap has been applied is p(q). The whole expression on the left may be converted into the whole expression on the right.

In general, any of the moves may be embedded in a larger context. Thus undelete allows any expression containing an empty circle, to be replaced by the same expression with any expression A inserted into the space which contains the empty circle, alongside the empty circle. Note that there are no restrictions on A whatsoever; so undelete is a sort of template for an extremely wide variety of moves.

Finally, Clara laid down a principle of concatenation: if expression E is transformed into F by a legal move, and F, likewise, into G; then the move that transforms E directly into G is also a legal move.

As with arithmetical expressions we say that E is equivalent to F, or

E = F ,

if E can be transformed into F by a sequence of legal moves (equivalently, thanks to concatenation, by a single legal move).

The three pairs of legal moves give rise to three equations; it will be convenient to refer to them as the three initial equations - from which all other equations are as it were generated. They are:

A = ((A))  wrap
A O = O  delete
A(B) = A(AB)   copy.

In principle, the notion of equivalence determined by the legal steps allows one to classify the universe of CL expressions into 'equivalence classes'. Each equivalence class is a set of CL expressions, such that any two elements of the set are equivalent to each other. Elements belonging to different equivalence classes are not equivalent to one another. Clara set herself the task of finding out as much as she could about these equivalence classes.

#### Copy to any Depth

Copy-ing can be done to any depth. That is to say, besides the basic move

A(B) = A(AB)

the following moves are all valid:

A(B(C)) = A(B(AC))
A(B(C(D(E)))) = A(B(C(D(AE))))

— and so on.

This is not hard to see; the proof of the first of these new moves goes like this:

A(B(C)) = A(AB(C)) [copy from space of depth 0 to space of depth 1]
= A(AB(AC)) [copy from space of depth 1 to space of depth 2]
= A(B(AC)) [uncopy from space of depth 1 to space of depth 0]

The proof of the second goes like this:

A(B(C(D))) = A(AB(C(D))) [copy from space of depth 0 to space of depth 1]
= A(AB(AC(D))) [copy from space of depth 1 to space of depth 2]
= A(AB(AC(AD))) [copy from space of depth 2 to space of depth 3]
= A(AB(C(AD))) [uncopy from space of depth 2 to space of depth 1]
= A(B(C(AD))) [uncopy from space of depth 1 to space of depth 0]

The principle should now be clear. I think of it as letting down a rope ladder, rung by rung, from the outer space. Once the expression A has been copied to the innermost space, you pull the rope ladder up again, rung by rung.

In fact, copying to depth 0 is also valid; but to see this, we need to make use of wrap/unwrap, as well as copy:

A = A (O) [wrap]
= A ((A)) [copy to depth 2]
= A A [unwrap]

#### The Principle of Generalization

Suppose that an equivalence of two CL expressions has been established. For example, we shall see below that it can be shown that

p((q)(r)) = ((pr)(qr)).

Then we can immediately turn the equivalence into a general rule:

P((Q)(R)) = ((PR)(QR)).

In other words, given any expressions P, Q and R, the two larger expressions made by combining these expressions, as given in the above equation, are equivalent to one another. How can we see that this is the case? It is just a matter of observing that whatever sequence of moves was applied to the expression p((q)(r)), in order to turn it into ((pr)(pq)), can be applied instead to the expression P((Q)(R)), turning it into ((PR)(QR)): whatever we did, before, to the letter p, we now do to the expression P (and so on with the other letters).

#### Compatibility with the Arithmetic of the Mark

The initial moves apply to any expressions A and B; in particular, they apply when A and B are chosen to be arithmetical expressions. It is not difficult to show that all such moves are value-preserving, where we use 'value' in the sense established by Valerie.

For, the value of A is either _ or O, which agrees with the value of ((A)); the value of A O is always O, as is the value of the expression O. For the third rule, we consider two cases; suppose firstly, that the value of A is _; then the values of both A(B) and A(AB) equate to the value of (B); while if the value of A is O, then the values of A(B) and A(AB) both equate to O. So none of the initial moves has any effect on value, and in this sense the the calculus of circles and letters is compatible with Arthur's arithmetic of the mark.

Is it conceivable that a CL-equivalence, when generalized as explained above, could result in an arithmetic untruth (of which there is, essentially, only one, namely, _ = O ) when arithmetic expressions were substituted for the letters? No, because the equivalence of CL expressions could be broken down into a series of legal moves; then the same moves could be applied to the expressions with the arithmetic expressions substituted, and each such move would preserve value.

When the CL-calculus is restricted to arithmetic expressions, the third initial equation is superfluous. For when _ is substituted for A in the first equation, we obtain

_ = (O)  ;

and when O is substituted for A in the second equation, we obtain

O O = O  .

So we already have the two axioms of Arthur's arithmetic without using the third equation. In the full calculus, however, with expressions that involve letters as well as circles, the third equation does make a difference; it is not a consequence of the first two equations. This is explained, and proved, in 'There is no redundancy in the set of Initial Equations'.

#### New Play Area

The new play area, or 'Circle-and-letter expression transformer', below, has the three 'initial equations' built into it. It has two modes, 'construct' and 'transform' (change between them by clicking on the radio-buttons at bottom right, or else just press the space bar). In construct-mode you can build up an arbitrary CL expression as before; once you're in transform-mode only legal moves are allowed. To see how the legal moves work, let's go through the six initial moves.

Note: in case you find the written instructions rather hard work, go instead to my YouTube video 'Markability: transforming circle-and-letter expressions'.

• wrap A → ((A))
Here A stands for any expression. To perform the action of wrapping, we need first to define A. We do this by 'selecting' the expression. An expression is either 'prime', consisting either of a circle together with its contents, or of a single letter; or 'composite', meaning that it is the product of several primes all lying in the same space. There is just one other possibility which is that A is the empty expression; then wrapping A simply means writing in a double circle (O); but we still have to tell the program where we want the double circle to go.
To select a prime expression, click just inside its bounding circle; it will change colour to indicate that it has been selected. To select a letter, just click on it. To select a composite expression, first select one of its factors, then add to the selection by holding down the Control key as you click. To clear the selection, click in the empty space surrounding the whole expression.
To wrap a selected expression, double-click somewhere on the selection. If no expression is selected, and you double-click in a bit of empty space, a double circle (O) will be created in that place.
• unwrap ((A)) → A
First select a doubly-wrapped expression by clicking just inside the outer circle; then press the Escape key (Esc). If an expression is selected that is not doubly-wrapped, nothing happens when you press Esc.
• delete O A → O
In any space which contains an empty circle, select an expression (prime or composite). To delete it, press the Delete key.
• undelete O → O A
Holding down the Insert key, click in any space which contains an empty circle. A 'construction space', surrounded by a dotted circle, will be created. You may now construct any expression, as if in free construction mode, within the construction space (using click, click with letter pressed; or shift-click to undo mistakes). But if you click outside the dotted boundary of the construction space, the dotted boundary will vanish and the operation will terminate. (It can also be terminated by pressing the Enter key.) The expression that you have constructed will be incorporated into the space alongside the empty circle.
• copy A(B) → A(AB)
In any space, select an expression. To copy it into a deeper space, drag the selected expression into that space with the mouse. (Explicitly, move the cursor so that it is over the selected expression, press down the mouse button and hold it down while you move the mouse so that the cursor moves into the deeper space. When the cursor has got there, release the mouse button.) Dragging the expression into its own space will create a copy in the same space (i.e. will convert A into AA).
• uncopy A(AB) → A(B)
To uncopy, select the expression A in the deeper space; drag it into the outer space, where the 'original' of A should already be. If successful, the 'copy' of A will disappear. If the 'original' of A is not present in the outer space, nothing will happen.
To uncopy at depth zero - that is, to reduce AA to A - press the Shift key as you drag A into its own space. (Without the Shift key, you will just turn AA into AAA.)

If you're having difficulty making letters, you may need to disable 'hardware acceleration' in the Flash-player that is plumbed in to your browser. To do this, right-click in the play area, select 'Settings', select the left-hand icon along the bottom (for Display), and untick 'Enable hardware acceleration'.

When you've tried out the various moves, try the following exercise: prove that complements is valid in the calculus of circles and letters, by starting from the empty expression, and converting it by legal moves into the expression (p(p)).

Solution: The first step is to convert _ into a double circle (O). To do this, make sure the area is clear, and that you are in Transform mode. Then double-click somewhere in the space. Now click on the inner, empty circle and press the Insert key. This will enable you to create a letter p in the intermediate space (between the circles). Get out of insert-mode by pressing the Enter key. Finally, copy p into the inner space (by dragging it there).

Exercise: Prove that distribute is valid in the calculus of circles and letters; that is, find the steps that convert the expression p((q)(r)) into ((pq)(pr)).

Solution: the first step is

p((q)(r)) = p ((pq)(pr)) [copy, to depth 2, twice].

The problem now is to get rid of that p in the outer space. We proceed by wrapping the letter p, and copying the other part of the expression into the space between the two circles surrounding p:

= ((p)) ((pq)(pr)) [wrap]
= ((p) ((pq)(pr)) ) ((pq)(pr)) [copy].

Now the expression (p) is copied from depth 1 to depth 3, twice

= ((p) ((p(p)q)(p(p)r)) ) ((pq)(pr)) [copy, twice]
= ((p) ((p O q)(p O r)) ) ((pq)(pr)) [uncopy, twice]
= ((p) ((O)(O)) ) ((pq)(pr)) [delete, twice, applied to the expressions pq and pr]
= ((p) O ) ((pq)(pr)) [unwrap, twice]
= ( O ) ((pq)(pr)) [delete]
= ((pq)(pr)) [unwrap].

It is highly instructive to 'enact' this sequence of steps in the play area. In fact, it is worth repeating the enaction a few times, until it becomes fluent.

Moreover: the scope of distribute can be expanded to more than two factors. For example,

p ((q)(r)(s)(t)) = ((pq)(pr)(ps)(pt)).

The proof is essentially the same as when there were only two inner factors (q) and (r).

Exercise: show that all the remaining General Rules, discovered by Algernon, are in fact legal moves in Clara's sense. What is needed is to find the steps that make up the following transformations:

( (a)(b) ) ( (a)b ) = a   each way

( ( (a)b )c ) = (ac) ((b)c)   reduce-depth

( a (b) (c) ) ( a(r) ) = ( a (br) (cr) )   modified distribute/collect

( (a(r)) (br) ) = ( (a)(r ) ) ( (b)r )   flip

See if you can find the steps that prove each of these equivalences; remember that you can now use distribute or collect as if it were a single step; if you like, you can think of either of these names as simply a shorthand notation for the sequence of simple (initial) steps into which the operation may be broken down (as we proved above). Solutions will be given in the next chapter.

#### Appendix: Alternative sets of Initial Equations

The three initial equations (or pairs of legal moves) out of which we have developed the CL-calculus are known as the Bricken initials after their discoverer William Bricken. In Laws of Form the calculus was developed out of two initial equations, namely

(P(P)) = _    complements
P((Q)(R)) = ((PQ)(PR))    distribute/collect.

Surprisingly, it is also possible to develop the calculus out of just one initial equation

A = ((A)B) ((A)(B))    each way.

This possibility is a consequence of Huntington's 1934 derivation  of the axioms of Boolean Algebra from a single equation, equivalent to the above, which is sometimes known as Huntington's equation. (However, Laws of Form notation and attitude allow a much better derivation of Huntington's result: see Huntington's Axiom.)

We already know that all of these alternative initial equations follow from the Bricken initials. To show that the systems which they generate are mutually equivalent we need to show that the Bricken initials can be derived from the initial pair of Laws of Form; or from the single Huntington initial.

Both problems are left as exercises for the reader. If the reader gets stuck and needs the answer to the first problem he or she should look in Laws of Form or else in Kauffman's Laws of Form - an exploration in mathematics and foundations (the most difficult bit is to derive wrap/unwrap from the two initials); for the second problem refer to Huntington's Axiom.

##### Notes

 See E.V.Huntington, New sets of independent postulates for the algebra of logic, with special reference to Whitehead and Russell’s Principia mathematica
Trans. Amer. Math. Soc. 35 (1933), 274-304
and Boolean Algebra. A Correction,
Trans. Amer. Math. Soc. 35 (1933), 557-558