# 1+/Minimalization

Back to 1+

This page contains attempts on minimizing the number of 1+ instructions, similar to BF instruction minimalization. We also uses the same restrictions that is, there exists a simple translation from X to 1+ and from 1+ to X. A secondary goal is to golf the sum of the number of commands in the submission to which each 1+ command translates for every number of instructions.

If you're to add a submission try your best to explain it.

## Minimalization

### Combining + and * (Reduced 1 instruction)

Starting with combining `+` and `*`. Let's add an `&` instruction that can do both addition and multiplication:

```intermediate   1+
------------------
&              +*
```

Since a + 0 = a and a * 1 = a it's easy to disable both addition and multiplication:

```1+   intermediate
------------------
+    //1\\&
*    111&1<&
```

### Combine Harvester (Reduced 2 instructions)

Now throw `"` into the mix. Combine it with the `&` instruction:

```CH   intermediate
------------------
@    &"
```

Disabling `"` is not as trivial since you need to decrease the length of stack and you can't use `@` since it gives you another pair of identical items to get rid of. The only choice is `<`:

```intermediate   CH
------------------
&              @111@1<<^@
"              1111@1<<@
```

### The Lyxal command (Reduced 3 instructions)

The Lyxal command, `L`, is the 1+ equivalent of the BitChanger command, and it combines `\` with `^`.

```Lyxal   CH
------------------
L       \^
```
```CH   Lyxal
------------------
\    L/L
^    /L
```

## Properties

These are the properties that a 1+ minimalization language must have.

### Property I

There exists an instruction that increases the length of the stack and an instruction that decreases it that does not affect I/O.

If you only have instructions that increases the length of the stack you'll get stuck on translating `1` and `"` and if you only have decreasers then you cannot do any of `+*<`.