## #Bea's dimensions

Next day at the array races for the people, where linear Beaf rivals Btrix multiple dimensions.

### # Second row

Construction of a multidimensional Btrix matrix in a few examples. Comparison with Bird's linear array of Beaf and its simplification to Eaf (our Easy Array Function). Both systems were defined by a rule list for the linear array in the previous chapter.

Array rows in Btrix are separated by `,` commas. Dimensions in general are constructed by placing indexed separators `,[s]` between subordinate dimensions `s` inside the matrix. Bowers starts with the same dimension index `` between rows, but Bird assigns `≡,` to the single comma. We write Bird's row separators as `,` in Eaf essentials.

Choose to clean up trailing `a,b,{k},Z` left commas, or keep and add them `,{kb}` to the next expansion (as Bowers suggested). Then `b` will obviously be much larger than `k`, so the resulting Big numbers (comma drop versus keep) won't differ so much.

• a,b1,1 = a,a,{b1}1 = a,{b1}a = a*{b}a {b>0} = a^{b}2 = Eaf(a,a,b1) = Eaf(a,b1,1,2) = Beaf(a,2,b)
• a,b,2 = a,a,{b}1,1 == a,(a,{b}a),1 = Eaf(a,a,(a,a,b)) = Eaf(a,(a,b,1,2),1,2) Eaf(b,3,2,2) {ab} ~> Beaf(b,2,1,2)
• a,b,1c = a,{b}a,c == a,(a,{b}a),c == Eaf(a,..b..,1,2) :c1: Eaf(b,c2,2,2) {ab} ~> Beaf(b,c1,1,2)

The new rule `6.` of system Btrix applied above on the 1st entry in her 2nd row to expand the 1st row. It assumes trailing commas `,, ≡ ,` are mopped up. We also could have kept trailing dimension separators for reuse, as argued above the difference is not significant.
Extended rules for upload etc. are listed in the coming section on higher (multiple) dimensions.

• 6.0 a,b,1Z = a,,{b}2,Z = a,a,{b}1,Z = a,{b}a,,Z = a,{b}a,Z == a,(a,{b}a),Z

Further construction with comparisons. The next row of Btrix is appended, which in total adds just `1` to the 4th entry in Eaf (and similarly in Beaf). All variables must be put `{a≥3}` in context.

• a,b1,,1 = a,,b1, = a,a,b = Eaf(a,b1,2,2)
• a,b1,,2 = a,a,b,1 == a,(a,a,b),,1 = Eaf(a,(a,b1,2,2),2,2) ≈ Eaf(b1,3,3,2) {ab1}
• a,b1,,1d = a,a,b,d == a,(a,a,b),,d = Eaf(a,..b1..,2,2) :d1: Eaf(b1,d2,3,2) {ab1} ~> Beaf(b,d2,2,2)
• a,b1,,,1 = a,a,,b, = Eaf(a,b1,3,2)
• a,b1,,,2 = a,a,,b,1 == a,(a,a,,b),,,1 = Eaf(a,(a,b1,3,2),3,2) ≈ Eaf(b1,3,4,2) {ab1}
• a,b1,,,1e = a,a,,b,e == a,(a,a,,b),,,e = Eaf(a,..b1..,3,2) :e1: Eaf(b1,e2,4,2) {ab1} ~> Beaf(b,e2,3,2)
• a,b1,,{r1}1q = a,a,,{r}b,q == a,(a,a,,{r}b),,{r1}q = Eaf(a,..b1..,r2,2) :q1: Eaf(b1,q2,r3,2) {ab1} ~> Beaf(b,q2,r2,2)

Next rows in Btrix will have a seemingly negligible impact compared to Eaf with its fast motor rule which nests predecessor expressions. It is only slowly our queen matrix creeps near…

### # On the plane

We adapt the row upsize rule `6.` for the plane matrix (over multiple rows) of Btrix. Supply the upload rules for entries over multiple dimensions in the next section.

On the plane the rightmost empty row (of a `,..` sequence) has its size expanded (by `b`) and only its top entry gets filled (by `a`). Repeat rule `4.` and `5.` in tandem to fill the rest of the top row (with entries `a-`) and then rule `6.` will expand earlier rows (to sizes `a`).
Considering the size of the top structure is dominant, Bird's angle brackets algorithm to explode multidimensional arrays is not significantly faster than ours. After the top entry is counted down, lower structures have been uploaded from much Bigger baskets `b'` many times.
So the upsize (by `b`) of an expression `a,b,[X]1Z` in Btrix matches the upsize (by `b`) of `a,b[X]1Z` in Beaf, even after all Bird's angle brackets `a<X'>b` are worked out!

• 6.1 a,b1.,..1Z :k1 = a,a.,..,{b1}1,Z :k 5.= a,.,..,{b}a,,Z :k 8·4.= a,a.,..,{b}a-,Z :k == a,f.,..Z :k1 & f = a,a.,..,{b}a- :k

Our minus unit `-` subtracts `1`. Use the sign `≈` when two expressions are approximately equal, use `~` if an insignificant variable is lost. In a comparison `X``~>``Y` the number `X` is next larger than `Y` (so `X` comes after in Big succession).
From the royal `3` row matrix onwards we only compare Btrix and Eaf approximately.

• a,b1,,1 = a,a,,{b}a- = Eaf(a,a,b2,2)
• a,b1,,2 = a,(a,a,,{b}a-),,1 ≈> Eaf(a,a,(a,a,b2,2),2) ~> Eaf(b1,3,2,3)
• a,b1,,1c = a,(a,a,,{b}a-),,c ≈> Eaf(a,a,..b2..,2) :c1: ~> Eaf(b1,c2,2,3)
• a,b1,,,2 = a,(a,a,,b),,,1 ≈> Eaf(a,(a2,b1,2,3),2,3) ~> Eaf(b,3,3,3)
• a,b1,,,1d = a,a,,b,d ~> Eaf(b,d2,3,3)
• a,b1,,,{r1}1q = a,a,,,{r}b,q ~> Eaf(b,q2,r3,3) ~> Beaf(b,q2,r2,3)

Continuing this comparison over the Btrix matrix, where linear size (the number of entries of her top row) runs on a par with the `3`d entry in Eaf. Appending a next row on (the top plane of) her `2`nd dimension is like incrementing the `4`th entry of Eaf (or Beaf) by `1`.

• a,b,,,1 ~> Eaf(a,a,b1,3) ~> Eaf(b,2,2,4)
• a,b,,,1c == a,(a,a,,,{b-}a-),,,c Eaf(a,a,..b..1,3) :c1: ~> Eaf(b,c2,2,4)
• a,b.,..1 :e ~> Eaf(a,a,b1,e) ~> Eaf(b,2,2,e1)
• a,b.,..,{d}c :e ~> Eaf(b,c1,d2,e1)

We've nested subexpressions in Btrix basket `b` in exchange for decrementing her right parameter. Now we like to take a broader view. The number of rows `e1` of Btrix plane is reflected in the `4th` entry in Eaf, and the number of entries `d1` on Btrix top row reflects the `3d` entry of Eaf. We expect a similar reflection between both systems as we move to higher dimensions.

In the next section the concept of multiple dimensions will follow from linear, plane and cubic dimensions. All such structures get a class norm `Ñ` via system Nix, explained at ~0 above.

```n,.. :n = n*n  (row)
n**2,.. :n = n**3  (plane)
n**3,.. :n = n**4  (cubic)
n**n,[n-].. :n = n**n1  (dimensional)```

We can classify the next higher separator `,[,1]` in Btrix (or equivalently `[1,2]` in Bird's Beaf) with norm `Ñ = n***2` (where Bird jumps to level `ω` of separator spaces).

### # Cubic and Dimensional

Watch the number of planes in cubic Btrix match the `5th` entry in Eaf.

• a,b,1 = a,a.,..1 :b = a,a.,..,..1 :b- :a ≈> Eaf(a,2,2,b1) Eaf(b,2,2,1,2) {ab}
• a,b,2 = a,(a,b,1),1 ~ Eaf(b,3,2,1,2)
• a,b,c ~ Eaf(b,c1,2,1,2)
• a,b,,1 ≈> Eaf(a,b,2,1,2) ~ Eaf(b,2,3,1,2)
• a,b,,c ~ Eaf(b,c1,3,1,2)
• a,b,,1 = a,a,,{b}1 = a,a,,{b-}a- ≈> Eaf(a,a,b1,1,2) ~> Eaf(b,2,2,2,2)
• a,b,,c ~> Eaf(b,c1,2,2,2)
• a,b,,c ~> Eaf(b,c1,2,1,3)
• a,b.,..,..,..c :f :e :d ~> Eaf(b,c1,d2,e1,f1)
• a,b,1 = a,a.,..1 :b ≈> Eaf(a,2,2,1,b1)

We extend the rules of Btrix to expressions in a multidimensional matrix.
Variables have values `v>0` as determined by context (sound use & rule order).
Rule `5.` can be presented as a combined rule to upload `b` and put `a` in place.
Rule `6.` expands previous dimension sizes, with `,[]` a regular comma between entries.

• 1.3 a,b.,[si].. :k = b
• 2.2 a,Y,[s] = a,Y
• 3.2 a,b,1Z = a,ab,Z
• 4.2 a,.,[si]..1Z :k1 = a,a.,[si]..Z :k1
• 5.2 a,b1.,[si]..,1Z :k1 = a,.,[si]..b1,Z :k1 4.= a,a.,[si]..b,Z :k1
• 6.2 a,b1\$,[t1]1Z where \$ ≡ ,[si].. :k by 8. {skt1} = a,a\$.,[t]..1,[t1]Z :b1 6·8.= a,a\$.,[t]..,[t-]..1,[t1]Z :b :a etc.
• 7.1 ,[] ≡ , (make `,[-] ≡ 1` sense?)
• 8.0 ,[s<t],[t] ≡ ,[t]

The optional rules `2.` and `8.` discard of trailing outer and inner separators.
Bird clears away smaller left separators to clarify the use of other rules, but Bowers suggests we can keep them. We can choose either strategy – for the Bigness of numbers to either keep or drop these superfluous commas is mostly insignificant.

Every next dimension of Btrix is equivalent to an extra entry in the linear array of Eaf (and likewise Bird's Beaf), until our multiple `Dim` and his first `Row` meet.

• a,b,1 = a,a.,..1 :b ≈> Eaf(a,2,2,1,1,b1)
• a,b,[m1]1 = a,a.,[m]..1 :b ≈> Eaf(a,a.,1..,b1) :m

Our Btrix matrix barely catches up with Bird's linear array, whose size equals her separator index `,[m]` for multiple dimensions. However, this is no big deal in the hyperdimensional realm we are about to enter.

Rules specific for multidimensional arrays in Eaf (to rival Btrix hyper-row in next chapter).
Count down entries to `1` (nowhere `0` void). Apply rule precedence by list order.
Rule `4'` can be seen as an initial case of rule `6` with the same second entry `b` if we put `t=0` to rely on Eaf's trivial separator cases as follows.

1. let , ≡ , & ,[]0
2. Eaf(a,X,[S]1) = Eaf(a,X) (drop trailing end)
3. use \$ ,[si]1.. :r {r0 s>0}
4. Eaf(a,b,1,2Z) = Eaf(a,a,b,1Z) &' {r>1 or s0>1} Eaf(a,b\$,2Z) = Eaf(a,a\$b,1Z) (upload `1b`)
5. Eaf(a,b1\$,[1t]2Z) {t>0} = Eaf(a,a\$.,[t]1..1,[1t]1Z) :b (upsize)

The growth rate of our Eaf system differs not significantly from Bird's multidimensional arrays. Below is explained why.
For example against `Beaf(a,212)` `= Beaf(a,aa,a)` the next larger `<~` is about `Eaf(a,3,1,2)` `= Eaf(a,a,1,1,2,)` `= Eaf(a,a,a1,a)` and so forth.

Eaf adopts Bowers plan to leave trailing separators in between `,[S]1,[T]` if `{S<T}` and so we don't need Bird's complex subsystem for comparing separator arrays at all. Any extra structure that was left behind is eventually reused, but only after its parent space has been upsized anew by much bigger `b` than before. This dwarfs the extra upload of older remnants in Eaf time after time.

Convince yourself the basket `b` grows bigger before each particular upsize. When the right side is `1` smaller since last time, and the middle part is counted down fully, the bigness of the former expression is transferred to the left side. The right stuff must then be concentrated in the number `b` (and a small part in trailing middle structures, until these are dropped in the end).

Our view of Bowers & Bird's <bracketed arrays> is that these explosions don't contribute much to the greater good. The upsize `b` of the highest free structure is most significant. In Eaf all other free structures are upsized by `a` and in Beaf by `b`, but such secondary differences don't matter.
For suppose our upsize is by `b1` instead, then the direct penultimate upsize is by `a`, but once the highest structure is counted off (effectively) to size `b`, the subsequent upsize of Eaf's penultimate structure will be unimaginably bigger (though still insignificant) compared to that of Beaf from `b`.

Taking the upload of a predecessor expression in Beaf versus value `b` in Eaf into account, we can wrap up all their algorithmic differences as insignificant. Just write `Eaf(a,b,2,[S]Z)` to compete against `Beaf(a,b[S]Z)` and the former expression is destined to beat the latter.

## by Giga Gerard mathematical artist ↑

People can read this article plain or choose the `hard` & fast & open version.