This is a brief guideline on how to define a recursive notation without repeating the common failues.

## General Setting

Before studying how to define a recursive notation, you need to understand how to define a new object such as a constant, a (possibly uncomputable) function, and a (possibly uncomputable) relation.

- Define the
**domain**when it is a function or a relation. - Define the
**value**only using the following objects:- Objects given as the
**inputs**when it is a function or a relation. - Objects which have been
**already defined**or are**simultaneously defined**. - Objects which are
**quantified**.

- Objects given as the

Otherwise, the new object is just ill-defined, and hence meaningless. Listing finitely many examples without a full definition? Intuition-based description? Ambiguous use of ellipses? Explanation including undefined objects? Computation using non-unique unquantified expressions? Multiple expansion rules applicable to a single common expression in non-unique ways? The resulting object is just ill-defined. If you skip the definition of the domain, then the function is ill-defined unless it explicitly works as a function formula, which cannot be quantified. If you are not familiar with formal logic on a function formula, then you are probably unable to appropriately deal with it, and hence you should clarify the domain of a function. If you use a function \(f\) itself in the definition of its domain, then it is a typical circular logic. If you can read Japanese, more detailed proposals on how to avoid the ill-definedness are available here.

## Recursive Notation

If you understand the previous section, what you should do is quite simple.

- Clarify the countable set \(\Sigma\) of all symbols which you want to use in the notation.
- Define the set \(OT\) of valid expressions as a subset of the set \(\Sigma^*\) of finite strings in \(\Sigma\).
- If the recursiveness of \(OT\) is not obvious with respect to a natural enumeration of \(\Sigma\), clarify a precise algorithm to determine whether to determine \(t \in OT\) for
**any**\(t \in \Sigma^*\). - Define the structures of \(OT\).
- If you want to define an ordinal notation, then define a well-ordering \(<\) on \(OT\), and clarify a precise algorithm to determine \(s < t\) for
**any**\((s,t) \in OT^2\). - If you want to define a recursive system of fundamental sequences, then define clarify a set of computable expansion rules such that
**precisely one**rule is applicable to**each**\(t \in OT\). - If you want to define a computable map \(f \colon OT \times \mathbb{N} \to \mathbb{N}\), then clarify an algorithm to compute \(f(t,n)\) for
**any**\((t,n) \in OT \times \mathbb{N}\).

- If you want to define an ordinal notation, then define a well-ordering \(<\) on \(OT\), and clarify a precise algorithm to determine \(s < t\) for

You can simultaneously define \(OT\) and the structures by clarifying mutual recursion. In this case, please be careful not to confound mutual recursion and circular logic.

In an algorithm, you are not allowed to use set theoretic objects such as transfinite ordinals, because inputs and outputs of Turing machines are finite numbers by definition. You are only allowed to deal with methods on finite numbers and formal strings which can be imitated by a Turing complete computation model. Beginners should be very careful that googologists tend to comfound an ordinal and its expression, i.e. formal strings which they use to express an ordinal, and to state "This is an algorithm!" by just showing a transfinite induction on ordinals. No way, ordinals are not formal strings, and hence set theoretic operations directly referring to transfinite ordinals are not methods on finite numbers and formal strings.