## nullary

*posted on 11 Nov 2019*

Nullary is a base-less numeric encoding. Unlike unary, which requires `O(n)`

symbols to encode the number `n`

, nullary encoding still requires just `O(log(n))`

symbols.

Nullary is the foundation of real numerology.

Nullary is a variant of the ‘xenotation’ described by Nick Land in his essays The Tic Xenotation and TX2.

### why not use the xenotation

Tic Xenotation has an unnecessary base case.

```
Xenotation
----------
: -> 2
xy -> x * y
(x) -> the x'th prime
```

Nullary fixes this with a natural base case.

```
Nullary
-------
-> 1
xy -> x * y
(x) -> the x'th prime
```

### canonical form

The expressions `()(())`

and `(())()`

encode the same value.
The number of ways to encode a value is a key property of numbers.
Nevertheless, it is useful to have a canonical encoding. The canonical encoding is defined to be the one which places the largest factors first. This means `(())()`

is the canonical form of `()(())`

. Another way to express this is to say that the canonical form is the first item in a lexical sort if `'(' < ')'`

.

### forecast

Mr Land mentions an extension to identify 0 and 1:

```
((-P)): -> 0
(-P): -> 1
: -> 2
```

The idea is that ‘`(-P)`

’ is an operator that unwraps an expression. In this case, it is applied to ‘`:`

’. This formulation is unsatisfactory for a number of reasons…

For now, work some examples to get familiar with nullary. How do you encode your favorite number?

`(()())(())()`