Ok so what is this.

I've been toying around lately (for a very long time actually) with HYDRAS. HYDRAS and ORDINALS (more on that later).

Aand i came up with all sorts of stuff.

Expect me to explain all of my work in the following blog posts (if i ever finish them)

And this is the first one in the series, and I'm gonna talk about one of my favourite things: Incompositons!

## So to clear things out

Think about HYDRAS as ORDINALS.

An ordinal can be broken up into various terms that can be separated by plus signs. (e.g ω^{ωω}+ω^{2ω}+ω^{2})

A hydra can be broken up into various terms that can be joined or can be separated by some sign. (e.g {}[[]()](([]))[])

Ordinals can be either SEQUENCE or LIMIT. Hydras can also be either SEQUENCE or LIMIT.

Limit ordinals have fundamental sequences (e.g ω = sup(0,1,2,...)), while sequence ordinals are only the member of one.

Limit hydras ALSO HAVE fundamental sequences (e.g [] = sup((),(()),((())),...)), while sequence hydras ALSO ARE only the member of one.

## Decompositions

Hydras can be decomposed like this:

First, pick a number n.

1. Find the last term in the hydra.

2. Delete it.

3. If the last term was a sequence hydra, do nothing. If the last term was a limit hydra, replace it with the nth hydra of it's fundamental sequence.

4. This is a step. Do more steps until the hydra has no terms left.

Ordinals can ALSO BE decomposed, but we would need them expressed as hydras (or we would need to use the Rdc function)

Decompositions can have STRATEGIES, which tell us what number n to pick at each step. For example, the BASE STRATEGY, which has the same number n for each step.

## Incompositions

Short explanation: A flipped decomposition.

Long explanation: We need the Base Hydra.

The Base Hydra is the smallest sequence hydra: and is the only term in a hydra that can be a sequence hydra. When you decompose it, you don't replace it, you just delete it and no more.

So, now that we have defined stuff, how do we make the incomposition up to a certain hydra?

Start at the Base Hydra.

1. Now, set the number n to the number it would be on the number of steps it would take to decompose the desired hydra minus the number of steps that have occured before this step. (hardest step)

2. If there exists a hydra that has the current hydra in its nth element of its fundamental sequence and that doesn't contain any other hydras in it's fundamental sequence that contain the current hydra as the nth element, replace the current hydra by that hydra.

3. Else, add the Base Hydra as a term.

4. This is a step. Do more steps until the desired hydra is reached.

Aand thats it.

## Example

I will finish off with an example, since the definition might be awful.

Define a hydra:

Terms are joined.

() is the base hydra.

# is any hydra.

1. (#())=sup((#),(#)(#), (#)(#)(#),...)

Strategy is: n is always 2

Incomposition up to ((())):

()

()()

(())

(())()

(())()()

(())(())

(()())

((()))