Geometric Algebra Space-Time

Sources

https://www.physi.uni-heidelberg.de/~vhollmeier/ga4p/materials/ga_lecture_notes.pdf - Hollmeier, Leidel, Sapir Lecture Notes

https://arxiv.org/pdf/2404.19682 Pablo Banon Perez and Maarten DeKieviet - General Relativity: New insights from a Geometric Algebra approach

Format

Basis Axes

γ₀ is time and squares to -1

γ₁ is space x, squares to 1
γ₂ is space y, squares to 1
γ₃ is space z, squares to 1

So that's Cl(3,1). THE ONLY TRUE DEFINITION. jk, some seem to do Cl(1,3) but ill stay with what is taught.

Bivectors

Now the planes are

γ₂₃ all space thus ² = -1
γ₃₁ all space thus ² = -1
γ₁₂ all space thus ² = -1
γ₀₁ time and space ² = +1
γ₀₂ time and space ² = +1
γ₀₃ time and space ² = +1

unsure why?

Lets see γ₂₃² = γ₂₃₂₃ = -γ₂₂₃₃ so -1(γ₂² = +1 γ₃² = +1) + -1 * +1 * +1 = -1

Lets see γ₀₁² = γ₀₁₀₁ = -γ₀₀₁₁ so -1(γ₀² = -1 γ₁² = +1) + -1 * -1 * +1 = +1

No shame, i was certain it's still -1 once .... but it's 1.

Trivectors

When we form trivectors here we will NOT get 4 positive, 4 negative ones like in 4,0 4D.

there are 4 3 2 * 1 = 24 possible permutations of 4 bases. BUT we only want 3 of them. So thats 4! / 3! = 4 basis trivectors.

Because all have positive and negative possible values thats 8 "cubes". But lets stay with the 4 basis trivectors.

Now ask to define them: What axis is left out? And there it makes sense to go 0,1,2,3 is left out

Then we check what happens when we wedge this trivector with the missing axis. We know (you can check below at Quadvector) that I² = -1 in STA.

γ₁: γ₀₂₃ ∧ γ₁ = γ₀₂₃₁ (2 swaps) = +γ₀₁₂₃ = +I (+I² = -1)
γ₂: γ₀₃₁ ∧ γ₂ = γ₀₁₃₂ (2 swaps) = +γ₀₁₂₃ = +I (+I² = -1)    <-- damn!
γ₃: γ₀₁₂ ∧ γ₃ = γ₀₁₂₃ (0 swaps) = +γ₀₁₂₃ = +I (+I² = -1)
γ₀: γ₁₂₃ ∧ γ₀ = γ₁₂₃₀ (3 swaps) = -γ₀₁₂₃ = -I (-I² = +1)

@TBH I THINK this has to do with all 8 cubes needing to be summed to a negative volume. To be checked!!

Quadvector

in normal 4D we had I² = 1.

e₁₂₃₄² = e₁₂₃₄₁₂₃₄ = -e₁₂₃₁₄₂₃₄ = e₁₂₁₃₄₂₃₄ = -e₂₃₄₂₃₄ = e₂₃₂₄₃₄ = -e₃₄₃₄ = 1

NOT THE CASE IN STA!!!

γ₀₁₂₃ is I and I² = -1!

I² = γ₀₁₂₃² = γ₀₁₂₃₀₁₂₃ = -γ₀₁₂₀₃₁₂₃ = γ₀₁₀₂₃₁₂₃ = -γ₀₀₁₂₃₁₂₃ = γ₀₀₁₂₁₃₂₃ = -γ₀₀₁₁₂₃₂₃ = γ₀₀₁₁₂₂₃₃ = 1(-1 1 1 1) = -1

In Algo

Because we build from 2D, 3D to 4D and now STA it makes sense to stay with e₁ to e₄ and vectors v₁ to v₄ adding 4 as the γ0 time.

This is mostly done to switch at will to STA from 4D meshes and both are simple to convert to time as index 0 when needed.

e₁ = γ₁
e₂ = γ₂
e₃ = γ₃
e₄ = γ₀

Easy parts

s = R[0]

p = R[7]

Bivector parts

B₂₃ = R[1]
B₃₁ = R[2]
B₁₂ = R[3]
B₁₄ = R[4]
B₂₄ = R[5]
B₃₄ = R[6]

Squares makes it easier and faster

s_2  = s²
yz_2 = B₂₃²
zx_2 = B₃₁²
xy_2 = B₁₂²
xw_2 = B₁₄²
yw_2 = B₂₄²
zw_2 = B₃₄²
p_2  = I²

(s² - I²)v + 2s(v · B) + 2I(v ∧ B) + 2(v · B)B - vB²

Formula in 4D with |B|² wont work in STA as (s² - I²)v - vB² does not square all planes to -1

B²

(B₂₃e₂₃ + B₃₁e₃₁ + B₁₂e₁₂ + B₁₄e₁₄ + B₂₄e₂₄ + B₃₄e₃₄)²

=

-B₂₃² - B₂₃ B₃₁ e₁₂ + B₂₃ B₁₂ e₃₁ + B₂₃ B₁₄ e₁₂₃₄ - B₂₃ B₂₄ e₃₄ + B₂₃ B₃₄ e₂₄
...

Before you do all 6 lines note there will always be the plane squared part in the diagonals which we already know will be -1 for all space-space and 1 for all space-time planes

-B₂₃² -B₃₁² -B₁₂² + B₁₄² + B₂₄² + B₃₄²

then you know for all terms that are mixed planes that share an axis you will get f.e line 1

B₂₃e₂₃ * B₃₁e₃₁ = - B₂₃ B₃₁ e₁₂

and in line 2

B₃₁e₃₁ * B₂₃e₂₃ = B₃₁ B₂₃ e₃₁ e₂₃ =  B₃₁ B₂₃ -e₁₃ -e₃₂ = B₃₁ B₂₃ e₁₂

so these all cancel out. We never square planes or axes in these terms thus that's true in 4D and STA

That's 4 terms per line, so already 24 terms gone!

What about the terms that share no axes?

B₂₃ e₂₃ * B₁₄ e₁₄ = B₂₃ B₁₄ e₂₃₁₄ (2 swaps) e₁₂₃₄
B₃₁ e₃₁ * B₂₄ e₂₄ = B₃₁ e₂₄ e₃₁₂₄ (2 swaps) e₁₂₃₄
B₁₂ e₁₂ * B₃₄ e₃₄ = B₁₂ e₃₄ e₁₂₃₄ (0 swaps)

B₁₄ e₁₄ * B₂₃ e₂₃ = B₁₄ B₂₃ e₁₄₂₃ (2 swaps) e₁₂₃₄
B₂₄ e₂₄ * B₃₁ e₃₁ = B₂₄ B₃₁ e₂₄₃₁ (4 swaps) = -e₂₃₄₁ = e₂₃₁₄ = -e₂₁₃₄ = e₁₂₃₄
B₃₄ e₃₄ * B₁₂ e₁₂ = B₁₂ B₁₂ e₃₄₁₂ (4 swaps) = -e₃₁₄₂ = e₁₃₄₂ = -e₁₃₂₄ = e₁₂₃₄

so they are all quadvectors.

leaves

B² = -B₂₃² -B₃₁² -B₁₂² + B₁₄² + B₂₄² + B₃₄² + 2(B₂₃ B₁₄ + B₃₁ B₂₄ + B₁₂ B₃₄)I

2(v · B)B

v · B will be grade 1

grade 1 ∧ with B will give grade 1 and some grade 3 when eₘ eₙₐ

so thats the same as in 4D and this means we can just combine again ...

(s² - I² - ⟨B²⟩₀)v + 2s(v · B) + 2I(v ∧ B) + ⟨2(v · B)B⟩₁

Some things i stumbled again on

-BvB == 2(v · B)B - vB²

this means you need to "downgrade" now, THEN move a term maybe.

So 2(v · B) · B - v⟨B²⟩₀ first, THEN you move the now grade 0 / scalar ⟨B²⟩₀

`I²`

in STA to know how to treat the pseudoscalar component (i call it p) notice how I² differs in 4D and STA:

4D I²: e₁₂₃₄²

              1            2           3          4         5        6
= e₁₂₃₄₁₂₃₄ = -e₁₂₃₁₄₂₃₄ = e₁₂₁₃₄₂₃₄ = -e₂₃₄₂₃₄ = e₂₃₂₄₃₄ = -e₃₄₃₄ = 1

STA I²: e₁₂₃₄² (γ₁₂₃₀) where e₄ or γ₀ squares to -1

= e₁₂₃₄₁₂₃₄ = -e₁₂₃₁₄₂₃₄ = e₁₂₁₃₄₂₃₄ = -e₂₃₄₂₃₄ = e₂₃₂₄₃₄ = -e₃₄₃₄ = e₄₄ and that is -1!!!

(or see above at Quadvector)

so it will be

(s² + p² - ⟨B²⟩₀)v + 2s(v · B) + 2I(v ∧ B) + ⟨2(v · B)B⟩₁

or

(s² + p² - ⟨B²⟩₀)v + 2s(v · B) + 2I(v ∧ B) + 2(v · B) · B

v · B

These calculations will be different to 4D so lets do them now as we need these a lot later

(v₁e₁ + v₂e₂ + v₃e₃ + v₄e₄) · (B₂₃e₂₃ + B₃₁e₃₁ + B₁₂e₁₂ + B₁₄e₁₄ + B₂₄e₂₄ + B₃₄e₃₄)

= v₁(           -B₃₁e₃  +B₁₂e₂  +B₁₄e₄                  ) +
  v₂(   +B₂₃e₃          -B₁₂e₁          +B₂₄e₄          ) +
  v₃(   -B₂₃e₂  +B₃₁e₁                          +B₃₄e₄  ) +
  // now ... beware!!!
  v₄(                           +B₁₄e₁  +B₂₄e₂  +B₃₄e₃  )

I did this in 4D to check the trivectors so you can look it up there to verify.

(v · B) · B

For v₁ (-B₃₁e₃ +B₁₂e₂ +B₁₄e₄) · (B₂₃e₂₃ + B₃₁e₃₁ + B₁₂e₁₂ + B₁₄e₁₄ + B₂₄e₂₄ + B₃₄e₃₄)

= v₁ (  +B₃₁B₂₃e₂   -B₃₁²e₁     0           0           0           -B₃₁B₃₄e₄   +
        +B₁₂B₂₃e₃   0           -B₁₂²e₁     0           +B₁₂B₂₄e₄   0           +
        // DANGER ZONE
        0           0           0           +B₁₄²e₁     +B₁₄B₂₄e₂   +B₁₄B₃₄e₃   )

For v₂ (+B₂₃e₃ -B₁₂e₁ +B₂₄e₄) · (B₂₃e₂₃ + B₃₁e₃₁ + B₁₂e₁₂ + B₁₄e₁₄ + B₂₄e₂₄ + B₃₄e₃₄)

= v₂ (  -B₂₃²e₂     +B₂₃B₃₁e₁   0           0           0           +B₂₃B₃₄e₄   +
        0           +B₁₂B₃₁e₃   -B₁₂²e₂     -B₁₂B₁₄e₄   0           0           +
        0           0           0           +B₂₄B₁₄e₁   +B₂₄²e₂     +B₂₄B₃₄e₃   )

For v₃ (-B₂₃e₂ +B₃₁e₁ +B₃₄e₄) · (B₂₃e₂₃ + B₃₁e₃₁ + B₁₂e₁₂ + B₁₄e₁₄ + B₂₄e₂₄ + B₃₄e₃₄)

= v₃ (  -B₂₃²e₃     0           +B₂₃B₁₂e₁   0           -B₂₃B₂₄e₄   0           +
        0           -B₃₁²e₃     +B₃₁B₁₂e₂   +B₃₁B₁₄e₄   0           0           +
        0           0           0           +B₃₄B₁₄e₁   +B₃₄B₂₄e₂   +B₃₄²e₃     )

For v₄ (+B₁₄e₁ +B₂₄e₂ +B₃₄e₃) · (B₂₃e₂₃ + B₃₁e₃₁ + B₁₂e₁₂ + B₁₄e₁₄ + B₂₄e₂₄ + B₃₄e₃₄)

= v₄ (  0           -B₁₄B₃₁e₃   +B₁₄B₁₂e₂   +B₁₄²e₄     0           0           +
        +B₂₄B₂₃e₃   0           -B₂₄B₁₂e₁   0           +B₂₄²e₄     0           +
        -B₃₄B₂₃e₂   +B₃₄B₃₁e₁   0           0           0           +B₃₄²e₄     )

0 mistakes on initial try but thats easy if you can look up 4D

2I(v ∧ B)

note do I first or you need to deal with trivectors see 4D on this

e₁₂₃₄ ((v₁e₁ + v₂e₂ + v₃e₃ + v₄e₄) ∧ (B₂₃e₂₃ + B₃₁e₃₁ + B₁₂e₁₂ + B₁₄e₁₄ + B₂₄e₂₄ + B₃₄e₃₄))

=

// (v₁e₁) 

e₁₂₃₄v₁e₁B₂₃e₂₃ = (...) e₁₂₃₄₁₂₃ = -e₁₂₃₁₄₂₃ = e₁₂₁₃₄₂₃ = -e₂₃₄₂₃ = e₂₃₂₄₃ = -e₃₄₃ = e₄     =  v₁B₂₃e₄
e₁₂₃₄v₁e₁B₃₁e₃₁ = 0
e₁₂₃₄v₁e₁B₁₂e₁₂ = 0
e₁₂₃₄v₁e₁B₁₄e₁₄ = 0
e₁₂₃₄v₁e₁B₂₄e₂₄ = (...) e₁₂₃₄₁₂₄ = -e₁₂₃₁₄₂₄ = (!)-e₁₂₃₁₂ = e₁₂₁₃₂ = -e₂₃₂ = e₃             =  v₁B₂₄e₃
e₁₂₃₄v₁e₁B₃₄e₃₄ = (...) e₁₂₃₄₁₃₄ = -e₁₂₃₁₄₃₄ = (!)-e₁₂₃₁₃ = e₁₂₁ = -e₂                      = -v₁B₃₄e₂

// (v₂e₂)

e₁₂₃₄v₂e₂B₂₃e₂₃ = 0
e₁₂₃₄v₂e₂B₃₁e₃₁ = (...) e₁₂₃₄₂₃₁ = -e₁₂₃₄₃₂₁ = e₁₂₄₂₁ = -e₁₄₁ = e₄                          =  v₂B₃₁e₄
e₁₂₃₄v₂e₂B₁₂e₁₂ = 0
e₁₂₃₄v₂e₂B₁₄e₁₄ = (...) e₁₂₃₄₂₁₄ = -e₁₂₃₂₄₁₄ = e₁₃₄₁₄ = (!)e₁₃₁ = -e₃                       = -v₂B₁₄e₃
e₁₂₃₄v₂e₂B₂₄e₂₄ = 0
e₁₂₃₄v₂e₂B₃₄e₃₄ = (...) e₁₂₃₄₂₃₄ = -e₁₂₃₂₄₃₄ = (!)-e₁₂₃₂₃ = e₁                              =  v₂B₃₄e₁

// (v₃e₃)

e₁₂₃₄v₃e₃B₂₃e₂₃ = 0
e₁₂₃₄v₃e₃B₃₁e₃₁ = 0
e₁₂₃₄v₃e₃B₁₂e₁₂ = (...) e₁₂₃₄₃₁₂ = -e₁₂₄₁₂ = e₁₂₁₄₂ = -e₂₄₂ = e₄                            =  v₃B₁₂e₄
e₁₂₃₄v₃e₃B₁₄e₁₄ = (...) e₁₂₃₄₃₁₄ = -e₁₂₄₁₄ = (!)-e₁₂₁ = e₂                                  =  v₃B₁₄e₂
e₁₂₃₄v₃e₃B₂₄e₂₄ = (...) e₁₂₃₄₃₂₄ = -e₁₂₄₂₄ = (!)-e₁                                         = -v₃B₂₄e₁
e₁₂₃₄v₃e₃B₃₄e₃₄ = 0

// (v₄e₄) - is a bit evil, remember e₁₂₃₄₄₃₁ f.e. has ₄² -1 but ₃² is 1 still so that's -1 but 0 swaps so far

e₁₂₃₄v₄e₄B₂₃e₂₃ = (...) -e₁₂₃₂₃ = e₁                                                        =  v₄B₂₃e₁
e₁₂₃₄v₄e₄B₃₁e₃₁ = (...) -e₁₂₁ = e₂                                                          =  v₄B₃₁e₂
e₁₂₃₄v₄e₄B₁₂e₁₂ = (...) -e₁₂₃₁₂ = e₁₂₁₃₂ = -e₂₃₂ = e₃                                       =  v₄B₁₂e₃
e₁₂₃₄v₄e₄B₁₄e₁₄ = 0
e₁₂₃₄v₄e₄B₂₄e₂₄ = 0
e₁₂₃₄v₄e₄B₃₄e₃₄ = 0

done

2 * p * v₁ (B₂₃e₄ + B₂₄e₃ - B₃₄e₂)
2 * p * v₂ (B₃₁e₄ - B₁₄e₃ + B₃₄e₁)
2 * p * v₃ (B₁₂e₄ + B₁₄e₂ - B₂₄e₁)
2 * p * v₄ (B₂₃e₁ + B₃₁e₂ + B₁₂e₃)

0 mistakes on initial try but thats easy if you can look up 4D

I got hinted on checking you can find the SO(3,1) Lie Group here so the Lorentz-Group which well is not a coincidence as we do spacetime

Putting it all together

(s² + p² - ⟨B²⟩₀)v + 2s(v · B) + 2I(v ∧ B) + 2(v · B) · B

s²

R[0]²

p²

R[7]²

⟨B²⟩₀

-B₂₃² -B₃₁² -B₁₂² + B₁₄² + B₂₄² + B₃₄²

v = e₁

`(s² + p² - ⟨B²⟩₀)v`

v'  = (s² + p² - (-B₂₃² -B₃₁² -B₁₂² + B₁₄² + B₂₄² + B₃₄²)) e₁

`2s(v · B)`

    + 2 * s * (-B₃₁e₃ + B₁₂e₂ + B₁₄e₄)

`2I(v ∧ B)`

    + 2 * p * (B₂₃e₄ + B₂₄e₃ - B₃₄e₂)

`2(v · B) · B`

    + 2 * (+B₃₁B₂₃e₂ -B₃₁²e₁ -B₃₁B₃₄e₄ +B₁₂B₂₃e₃ -B₁₂²e₁ +B₁₂B₂₄e₄ +B₁₄²e₁ +B₁₄B₂₄e₂ +B₁₄B₃₄e₃)

simplify

e₁ Parts

    (s² + p² + B₂₃² + B₃₁² + B₁₂² - B₁₄² - B₂₄² - B₃₄²) e₁ +
    2 * (-B₃₁²e₁ -B₁₂²e₁ +B₁₄²e₁)

    = (s² + p² + B₂₃² - B₃₁² - B₁₂² +B₁₄² - B₂₄² - B₃₄²) e₁

e₂ Parts

    2 * s * B₁₂e₂ +
    2 * p * -B₃₄e₂ +
    2 * (+B₃₁B₂₃e₂ +B₁₄B₂₄e₂)

    = 2 * ((s * B₁₂) + (p * -B₃₄) + B₃₁B₂₃ + B₁₄B₂₄) e₂

e₃ Parts

    2 * s * -B₃₁e₃ +
    2 * p * B₂₄e₃ +
    2 * (+B₁₂B₂₃e₃ +B₁₄B₃₄e₃)

    = 2 * ((s * -B₃₁) + (p * B₂₄) + B₁₂B₂₃ + B₁₄B₃₄) e₃

e₄ Parts

    2 * s * B₁₄e₄ +
    2 * p * B₂₃e₄ +
    2 * (-B₃₁B₃₄e₄ + B₁₂B₂₄e₄)

    = 2 * ((s * B₁₄) + (p * B₂₃) - B₃₁B₃₄ + B₁₂B₂₄) e₄

v = e₂

`(s² + p² - ⟨B²⟩₀)v`

v'  = (s² + p² - (-B₂₃² -B₃₁² -B₁₂² + B₁₄² + B₂₄² + B₃₄²)) e₂

`2s(v · B)`

    + 2 * s * (+B₂₃e₃ - B₁₂e₁ + B₂₄e₄)

`2I(v ∧ B)`

    + 2 * p * (B₃₁e₄ - B₁₄e₃ + B₃₄e₁)

`2(v · B) · B`

    + 2 * (-B₂₃²e₂ +B₂₃B₃₁e₁ +B₂₃B₃₄e₄ +B₁₂B₃₁e₃ -B₁₂²e₂ -B₁₂B₁₄e₄ +B₂₄B₁₄e₁ +B₂₄²e₂ +B₂₄B₃₄e₃)

simplify

M⟨⟩ ₁₂₃¹²³ ⊗⊗⊗××

e₁ Parts

    2 * s * (-B₁₂e₁) +
    2 * p * (B₃₄e₁) +
    2 * (+B₂₃B₃₁e₁ + B₂₄B₁₄e₁)

    = 2 * ((s * -B₁₂) + (p * B₃₄) + B₂₃B₃₁ + B₂₄B₁₄) e₁

e₂ Parts

    (s² + p² + B₂₃² + B₃₁² + B₁₂² - B₁₄² - B₂₄² - B₃₄²) e₂ +
    + 2 * (-B₂₃²e₂ -B₁₂²e₂ +B₂₄²e₂)

    = (s² + p² - B₂₃² + B₃₁² - B₁₂² - B₁₄² + B₂₄² - B₃₄²) e₂

e₃ Parts

    2 * s * (+B₂₃e₃) +
    2 * p * (-B₁₄e₃) +
    2 * (+B₁₂B₃₁e₃ +B₂₄B₃₄e₃)

    = 2 * ((s * B₂₃) + (p * -B₁₄) + B₁₂B₃₁ + B₂₄B₃₄) e₃

e₄ Parts

    2 * s * (B₂₄e₄) +
    2 * p * (B₃₁e₄) +
    2 * (+B₂₃B₃₄e₄ -B₁₂B₁₄e₄)

    = 2 * ((s * B₂₄) + (p * B₃₁) + B₂₃B₃₄ - B₁₂B₁₄) e₄

v = e₃

`(s² + p² - ⟨B²⟩₀)v`

v'  = (s² + p² - (-B₂₃² -B₃₁² -B₁₂² + B₁₄² + B₂₄² + B₃₄²)) e₃

`2s(v · B)`

    + 2 * s * (-B₂₃e₂ + B₃₁e₁ + B₃₄e₄)

`2I(v ∧ B)`

    + 2 * p * (B₁₂e₄ + B₁₄e₂ - B₂₄e₁)

`2(v · B) · B`

    + 2 * (-B₂₃²e₃ +B₂₃B₁₂e₁ -B₂₃B₂₄e₄ -B₃₁²e₃ +B₃₁B₁₂e₂ +B₃₁B₁₄e₄ +B₃₄B₁₄e₁ +B₃₄B₂₄e₂ +B₃₄²e₃)

simplify

e₁ Parts

    2 * s * (B₃₁e₁) +
    2 * p * (-B₂₄e₁) +
    2 * (+B₂₃B₁₂e₁ +B₃₄B₁₄e₁)

    = 2 * ((s * B₃₁) + (p * -B₂₄) + B₂₃B₁₂ + B₃₄B₁₄) e₁

e₂ Parts

    2 * s * (-B₂₃e₂) + 
    2 * p * (B₁₄e₂) +
    2 * (+B₃₁B₁₂e₂ + B₃₄B₂₄e₂)

    = 2 * ((s * -B₂₃) + (p * B₁₄) + B₃₁B₁₂ + B₃₄B₂₄) e₂

e₃ Parts

    (s² + p² + B₂₃² + B₃₁² + B₁₂² - B₁₄² - B₂₄² - B₃₄²) e₃ +
    2 * (-B₂₃²e₃ -B₃₁²e₃  +B₃₄²e₃ )

    = (s² + p² - B₂₃² - B₃₁² + B₁₂² - B₁₄² - B₂₄² + B₃₄²) e₃

e₄ Parts

    2 * s * (B₃₄e₄) +
    2 * p * (B₁₂e₄) +
    2 * (-B₂₃B₂₄e₄ +B₃₁B₁₄e₄)

    = 2 * ((s * B₃₄) + (p * B₁₂) - B₂₃B₂₄ + B₃₁B₁₄) e₄

v = e₄

`(s² + p² - ⟨B²⟩₀)v`

v'  = (s² + p² - (-B₂₃² -B₃₁² -B₁₂² + B₁₄² + B₂₄² + B₃₄²)) e₄

`2s(v · B)`

    + 2 * s * (+B₁₄e₁ + B₂₄e₂ + B₃₄e₃)

`2I(v ∧ B)`

    + 2 * p * (B₂₃e₁ + B₃₁e₂ + B₁₂e₃)

`2(v · B) · B`

    + 2 * (-B₁₄B₃₁e₃ +B₁₄B₁₂e₂ +B₁₄²e₄ +B₂₄B₂₃e₃ -B₂₄B₁₂e₁ +B₂₄²e₄ -B₃₄B₂₃e₂ +B₃₄B₃₁e₁ +B₃₄²e₄)

simplify

e₁ Parts

    2 * s * (+B₁₄e₁) +
    2 * p * (B₂₃e₁) +
    2 * (-B₂₄B₁₂e₁ +B₃₄B₃₁e₁)

    = 2 * ((s * B₁₄) + (p * B₂₃) - B₂₄B₁₂ + B₃₄B₃₁) e₁

e₂ Parts

    2 * s * (B₂₄e₂) +
    2 * p * (B₃₁e₂) +
    2 * (+B₁₄B₁₂e₂ -B₃₄B₂₃e₂)

    = 2 * ((s * B₂₄) + (p * B₃₁) + B₁₄B₁₂ - B₃₄B₂₃) e₂

e₃ Parts

    2 * s * (B₃₄e₃) +
    2 * p * (B₁₂e₃) +
    2 * (-B₁₄B₃₁e₃ +B₂₄B₂₃e₃)

    = 2 * ((s * B₃₄) + (p * B₁₂) - B₁₄B₃₁ + B₂₄B₂₃) e₃

e₄ Parts

    (s² + p² + B₂₃² + B₃₁² + B₁₂² - B₁₄² - B₂₄² - B₃₄²) e₄ +
    2 * (+B₁₄²e₄ +B₂₄²e₄ +B₃₄²e₄)

    = (s² + p² + B₂₃² + B₃₁² + B₁₂² + B₁₄² + B₂₄² + B₃₄²) e₄

combine

v'₁ =   (s² + p² + B₂₃² - B₃₁² - B₁₂² + B₁₄² - B₂₄² - B₃₄²) v₁ +
        2 * ((s * -B₁₂) + (p * B₃₄) + B₂₃B₃₁ + B₂₄B₁₄) v₂ +
        2 * ((s * B₃₁) + (p * -B₂₄) + B₂₃B₁₂ + B₃₄B₁₄) v₃ +
        2 * ((s * B₁₄) + (p * B₂₃) - B₂₄B₁₂ + B₃₄B₃₁) v₄

v'₂ =   2 * ((s * B₁₂) + (p * -B₃₄) + B₃₁B₂₃ + B₁₄B₂₄) v₁ +
        (s² + p² - B₂₃² + B₃₁² - B₁₂² - B₁₄² + B₂₄² - B₃₄²) v₂ +
        2 * ((s * -B₂₃) + (p * B₁₄) + B₃₁B₁₂ + B₃₄B₂₄) v₃ +
        2 * ((s * B₂₄) + (p * B₃₁) + B₁₄B₁₂ - B₃₄B₂₃) v₄

v'₃ =   2 * ((s * -B₃₁) + (p * B₂₄) + B₁₂B₂₃ + B₁₄B₃₄) v₁ +
        2 * ((s * B₂₃) + (p * -B₁₄) + B₁₂B₃₁ + B₂₄B₃₄) v₂ +
        (s² + p² - B₂₃² - B₃₁² + B₁₂² - B₁₄² - B₂₄² + B₃₄²) v₃ +
        2 * ((s * B₃₄) + (p * B₁₂) - B₁₄B₃₁ + B₂₄B₂₃) v₄

v'₄ =   2 * ((s * B₁₄) + (p * B₂₃) - B₃₁B₃₄ + B₁₂B₂₄) v₁ +
        2 * ((s * B₂₄) + (p * B₃₁) + B₂₃B₃₄ - B₁₂B₁₄) v₂ +
        2 * ((s * B₃₄) + (p * B₁₂) - B₂₃B₂₄ + B₃₁B₁₄) v₃ +
        (s² + p² + B₂₃² + B₃₁² + B₁₂² + B₁₄² + B₂₄² + B₃₄²) v₄

i made lots of mistakes here sadly ... corrected i think but well, ill see

⟨M⟩(2)

e₁₂ e₂₃ e₃₁ e³¹ ∧

R×R

R1 × R2

R1*R2 = (R1[0] + R1[1] e₂₃ + R1[2] e₃₁ + R1[3] e₁₂ + R1[4] e₁₄ + R1[5] e₂₄ + R1[6] e₃₄ + R1[7] e₁₂₃₄)
      * (R2[0] + R2[1] e₂₃ + R2[2] e₃₁ + R2[3] e₁₂ + R2[4] e₁₄ + R2[5] e₂₄ + R2[6] e₃₄ + R2[7] e₁₂₃₄)

      = R1[0]     R2[0] + R1[0]     R2[1] e₂₃ + R1[0]     R2[2] e₃₁ + R1[0]     R2[3] e₁₂ + R1[0]     R2[4] e₁₄ + R1[0]     R2[5] e₂₄ + R1[0]     R2[6] e₃₄ + R1[0]     R2[7] e₁₂₃₄

      + R1[1] e₂₃ R2[0] + R1[1] e₂₃ R2[1] e₂₃ + R1[1] e₂₃ R2[2] e₃₁ + R1[1] e₂₃ R2[3] e₁₂ + R1[1] e₂₃ R2[4] e₁₄ + R1[1] e₂₃ R2[5] e₂₄ + R1[1] e₂₃ R2[6] e₃₄ + R1[1] e₂₃ R2[7] e₁₂₃₄
      + R1[2] e₃₁ R2[0] + R1[2] e₃₁ R2[1] e₂₃ + R1[2] e₃₁ R2[2] e₃₁ + R1[2] e₃₁ R2[3] e₁₂ + R1[2] e₃₁ R2[4] e₁₄ + R1[2] e₃₁ R2[5] e₂₄ + R1[2] e₃₁ R2[6] e₃₄ + R1[2] e₃₁ R2[7] e₁₂₃₄
      + R1[3] e₁₂ R2[0] + R1[3] e₁₂ R2[1] e₂₃ + R1[3] e₁₂ R2[2] e₃₁ + R1[3] e₁₂ R2[3] e₁₂ + R1[3] e₁₂ R2[4] e₁₄ + R1[3] e₁₂ R2[5] e₂₄ + R1[3] e₁₂ R2[6] e₃₄ + R1[3] e₁₂ R2[7] e₁₂₃₄
      + R1[4] e₁₄ R2[0] + R1[4] e₁₄ R2[1] e₂₃ + R1[4] e₁₄ R2[2] e₃₁ + R1[4] e₁₄ R2[3] e₁₂ + R1[4] e₁₄ R2[4] e₁₄ + R1[4] e₁₄ R2[5] e₂₄ + R1[4] e₁₄ R2[6] e₃₄ + R1[4] e₁₄ R2[7] e₁₂₃₄
      + R1[5] e₂₄ R2[0] + R1[5] e₂₄ R2[1] e₂₃ + R1[5] e₂₄ R2[2] e₃₁ + R1[5] e₂₄ R2[3] e₁₂ + R1[5] e₂₄ R2[4] e₁₄ + R1[5] e₂₄ R2[5] e₂₄ + R1[5] e₂₄ R2[6] e₃₄ + R1[5] e₂₄ R2[7] e₁₂₃₄
      + R1[6] e₃₄ R2[0] + R1[6] e₃₄ R2[1] e₂₃ + R1[6] e₃₄ R2[2] e₃₁ + R1[6] e₃₄ R2[3] e₁₂ + R1[6] e₃₄ R2[4] e₁₄ + R1[6] e₃₄ R2[5] e₂₄ + R1[6] e₃₄ R2[6] e₃₄ + R1[6] e₃₄ R2[7] e₁₂₃₄

      + R1[7] e₁₂₃₄ R2[0] + R1[7] e₁₂₃₄ R2[1] e₂₃ + R1[7] e₁₂₃₄ R2[2] e₃₁ + R1[7] e₁₂₃₄ R2[3] e₁₂ + R1[7] e₁₂₃₄ R2[4] e₁₄ + R1[7] e₁₂₃₄ R2[5] e₂₄ + R1[7] e₁₂₃₄ R2[6] e₃₄ + R1[7] e₁₂₃₄ R2[7] e₁₂₃₄

First lets solve all same planes to -1 (spatial) and 1 (with time e₄ / boosts)

R1*R2 = (R1[0] + R1[1] e₂₃ + R1[2] e₃₁ + R1[3] e₁₂ + R1[4] e₁₄ + R1[5] e₂₄ + R1[6] e₃₄ + R1[7] e₁₂₃₄)
      * (R2[0] + R2[1] e₂₃ + R2[2] e₃₁ + R2[3] e₁₂ + R2[4] e₁₄ + R2[5] e₂₄ + R2[6] e₃₄ + R2[7] e₁₂₃₄)

      = R1[0]     R2[0] + R1[0]     R2[1] e₂₃ + R1[0]     R2[2] e₃₁ + R1[0]     R2[3] e₁₂ + R1[0]     R2[4] e₁₄ + R1[0]     R2[5] e₂₄ + R1[0]     R2[6] e₃₄ + R1[0]     R2[7] e₁₂₃₄

      + R1[1] e₂₃ R2[0] - R1[1]     R2[1]     + R1[1] e₂₃ R2[2] e₃₁ + R1[1] e₂₃ R2[3] e₁₂ + R1[1] e₂₃ R2[4] e₁₄ + R1[1] e₂₃ R2[5] e₂₄ + R1[1] e₂₃ R2[6] e₃₄ + R1[1] e₂₃ R2[7] e₁₂₃₄
      + R1[2] e₃₁ R2[0] + R1[2] e₃₁ R2[1] e₂₃ - R1[2]     R2[2]     + R1[2] e₃₁ R2[3] e₁₂ + R1[2] e₃₁ R2[4] e₁₄ + R1[2] e₃₁ R2[5] e₂₄ + R1[2] e₃₁ R2[6] e₃₄ + R1[2] e₃₁ R2[7] e₁₂₃₄
      + R1[3] e₁₂ R2[0] + R1[3] e₁₂ R2[1] e₂₃ + R1[3] e₁₂ R2[2] e₃₁ - R1[3]     R2[3]     + R1[3] e₁₂ R2[4] e₁₄ + R1[3] e₁₂ R2[5] e₂₄ + R1[3] e₁₂ R2[6] e₃₄ + R1[3] e₁₂ R2[7] e₁₂₃₄
      + R1[4] e₁₄ R2[0] + R1[4] e₁₄ R2[1] e₂₃ + R1[4] e₁₄ R2[2] e₃₁ + R1[4] e₁₄ R2[3] e₁₂ + R1[4]     R2[4]     + R1[4] e₁₄ R2[5] e₂₄ + R1[4] e₁₄ R2[6] e₃₄ + R1[4] e₁₄ R2[7] e₁₂₃₄
      + R1[5] e₂₄ R2[0] + R1[5] e₂₄ R2[1] e₂₃ + R1[5] e₂₄ R2[2] e₃₁ + R1[5] e₂₄ R2[3] e₁₂ + R1[5] e₂₄ R2[4] e₁₄ + R1[5]     R2[5]     + R1[5] e₂₄ R2[6] e₃₄ + R1[5] e₂₄ R2[7] e₁₂₃₄
      + R1[6] e₃₄ R2[0] + R1[6] e₃₄ R2[1] e₂₃ + R1[6] e₃₄ R2[2] e₃₁ + R1[6] e₃₄ R2[3] e₁₂ + R1[6] e₃₄ R2[4] e₁₄ + R1[6] e₃₄ R2[5] e₂₄ + R1[6]     R2[6]     + R1[6] e₃₄ R2[7] e₁₂₃₄

      + R1[7] e₁₂₃₄ R2[0] + R1[7] e₁₂₃₄ R2[1] e₂₃ + R1[7] e₁₂₃₄ R2[2] e₃₁ + R1[7] e₁₂₃₄ R2[3] e₁₂ + R1[7] e₁₂₃₄ R2[4] e₁₄ + R1[7] e₁₂₃₄ R2[5] e₂₄ + R1[7] e₁₂₃₄ R2[6] e₃₄ + R1[7] e₁₂₃₄ R2[7] e₁₂₃₄

e₁₂₃₄² = e₁₂₃₄₁₂₃₄ = -e₁₂₃₁₄₂₃₄ = e₁₂₁₃₄₂₃₄ = -e₂₃₄₂₃₄ = e₂₃₂₄₃₄ = -e₃₄₃₄ = e₄₄ = -1

Lets do all plane multipications sharing an axis

R1*R2 = (R1[0] + R1[1] e₂₃ + R1[2] e₃₁ + R1[3] e₁₂ + R1[4] e₁₄ + R1[5] e₂₄ + R1[6] e₃₄ + R1[7] e₁₂₃₄)
      * (R2[0] + R2[1] e₂₃ + R2[2] e₃₁ + R2[3] e₁₂ + R2[4] e₁₄ + R2[5] e₂₄ + R2[6] e₃₄ + R2[7] e₁₂₃₄)

      = R1[0]     R2[0]     + R1[0]     R2[1] e₂₃   + R1[0]     R2[2] e₃₁   + R1[0]     R2[3] e₁₂   + R1[0]     R2[4] e₁₄   + R1[0]     R2[5] e₂₄   + R1[0]     R2[6] e₃₄   + R1[0]     R2[7] e₁₂₃₄

      + R1[1] e₂₃ R2[0]     - R1[1]     R2[1]       - R1[1]     R2[2] e₁₂   + R1[1]     R2[3] e₃₁   + R1[1]     R2[4] e₁₂₃₄ - R1[1]     R2[5] e₃₄   + R1[1]     R2[6] e₂₄   - R1[1]     R2[7] e₁₄
      + R1[2] e₃₁ R2[0]     + R1[2]     R2[1] e₁₂   - R1[2]     R2[2]       - R1[2]     R2[3] e₂₃   + R1[2]     R2[4] e₃₄   + R1[2]     R2[5] e₁₂₃₄ - R1[2]     R2[6] e₁₄   - R1[2]     R2[7] e₂₄
      + R1[3] e₁₂ R2[0]     - R1[3]     R2[1] e₃₁   + R1[3]     R2[2] e₂₃   - R1[3]     R2[3]       - R1[3]     R2[4] e₂₄   + R1[3]     R2[5] e₁₄   + R1[3]     R2[6] e₁₂₃₄ - R1[3]     R2[7] e₃₄
      + R1[4] e₁₄ R2[0]     + R1[4]     R2[1] e₁₂₃₄ - R1[4]     R2[2] e₃₄   + R1[4]     R2[3] e₂₄   + R1[4]     R2[4]       + R1[4]     R2[5] e₁₂   - R1[4]     R2[6] e₃₁   + R1[4]     R2[7] e₂₃
      + R1[5] e₂₄ R2[0]     + R1[5]     R2[1] e₃₄   + R1[5]     R2[2] e₁₂₃₄ - R1[5]     R2[3] e₁₄   - R1[5]     R2[4] e₁₂   + R1[5]     R2[5]       + R1[5]     R2[6] e₂₃   + R1[5]     R2[7] e₃₁
      + R1[6] e₃₄ R2[0]     - R1[6]     R2[1] e₂₄   + R1[6]     R2[2] e₁₄   + R1[6]     R2[3] e₁₂₃₄ + R1[6]     R2[4] e₃₁   - R1[6]     R2[5] e₂₃   + R1[6]     R2[6]       + R1[6]     R2[7] e₁₂

      + R1[7] e₁₂₃₄ R2[0]   - R1[7]     R2[1] e₁₄   - R1[7]     R2[2] e₂₄   - R1[7]     R2[3] e₃₄   + R1[7]     R2[4] e₂₃   + R1[7]     R2[5] e₃₁   + R1[7]     R2[6] e₁₂   - R1[7]     R2[7]

For some reason, i should know better, i made lots of mistakes here

Collect

R'[0] s     = R1[0] R2[0] - R1[1] R2[1] - R1[2] R2[2] - R1[3] R2[3] + R1[4] R2[4] + R1[5] R2[5] + R1[6] R2[6] - R1[7] R2[7]
R'[1] e₂₃   = R1[0] R2[1] + R1[1] R2[0] - R1[2] R2[3] + R1[3] R2[2] + R1[4] R2[7] + R1[5] R2[6] - R1[6] R2[5] + R1[7] R2[4]
R'[2] e₃₁   = R1[0] R2[2] + R1[1] R2[3] + R1[2] R2[0] - R1[3] R2[1] - R1[4] R2[6] + R1[5] R2[7] + R1[6] R2[4] + R1[7] R2[5]
R'[3] e₁₂   = R1[0] R2[3] - R1[1] R2[2] + R1[2] R2[1] + R1[3] R2[0] + R1[4] R2[5] - R1[5] R2[4] + R1[6] R2[7] + R1[7] R2[6]
R'[4] e₁₄   = R1[0] R2[4] - R1[1] R2[7] - R1[2] R2[6] + R1[3] R2[5] + R1[4] R2[0] - R1[5] R2[3] + R1[6] R2[2] - R1[7] R2[1]
R'[5] e₂₄   = R1[0] R2[5] + R1[1] R2[6] - R1[2] R2[7] - R1[3] R2[4] + R1[4] R2[3] + R1[5] R2[0] - R1[6] R2[1] - R1[7] R2[2]
R'[6] e₃₄   = R1[0] R2[6] - R1[1] R2[5] + R1[2] R2[4] - R1[3] R2[7] - R1[4] R2[2] + R1[5] R2[1] + R1[6] R2[0] - R1[7] R2[3]
R'[7] e₁₂₃₄ = R1[0] R2[7] + R1[1] R2[4] + R1[2] R2[5] + R1[3] R2[6] + R1[4] R2[1] + R1[5] R2[2] + R1[6] R2[3] + R1[7] R2[0]

Code

static multiply(a: Rot4, b: Rot4): Rot4 {

    const s1 = a[0], yz1 = a[1], zx1 = a[2], xy1 = a[3], xw1 = a[4], yw1 = a[5], zw1 = a[6], p1 = a[7];
    const s2 = b[0], yz2 = b[1], zx2 = b[2], xy2 = b[3], xw2 = b[4], yw2 = b[5], zw2 = b[6], p2 = b[7];

    const s = (s1 * s2 - yz1 * yz2) - (zx1 * zx2) - (xy1 * xy2) + (xw1 * xw2) + (yw1 * yw2) + (zw1 * zw2) - (p1 * p2);
    const eyz = (s1 * yz2) + (yz1 * s2) - (zx1 * xy2) + (xy1 * zx2) + (xw1 * p2) + (yw1 * zw2) - (zw1 * yw2) + (p1 * xw2);
    const ezx = (s1 * zx2) + (yz1 * xy2) + (zx1 * s2) - (xy1 * yz2) - (xw1 * zw2) + (yw1 * p2) + (zw1 * xw2) + (p1 * yw2);
    const exy = (s1 * xy2) - (yz1 * zx2) + (zx1 * yz2) + (xy1 * s2) + (xw1 * yw2) - (yw1 * xw2) + (zw1 * p2) + (p1 * zw2);
    const exw = (s1 * xw2) - (yz1 * p2) - (zx1 * zw2) + (xy1 * yw2) + (xw1 * s2) - (yw1 * xy2) + (zw1 * zx2) - (p1 * yz2);
    const eyw = (s1 * yw2) + (yz1 * zw2) - (zx1 * p2) - (xy1 * xw2) + (xw1 * xy2) + (yw1 * s2) - (zw1 * yz2) - (p1 * zx2);
    const ezw = (s1 * zw2) - (yz1 * yw2) + (zx1 * xw2) - (xy1 * p2) - (xw1 * zx2) + (yw1 * yz2) + (zw1 * s2) - (p1 * xy2);
    const exyzw = (s1 * p2) + (yz1 * xw2) + (zx1 * yw2) + (xy1 * zw2) + (xw1 * yz2) + (yw1 * zx2) + (zw1 * xy2) + (p1 * s2);

    const out = new Float32Array([s, eyz, ezx, exy, exw, eyw, ezw, exyzw]);

    return out;

}

static rotateVector4(r: Rot4, v: Vec4): Vec4 {
    const s = r[0], yz = r[1], zx = r[2], xy = r[3],
        xw = r[4], yw = r[5], zw = r[6], p = r[7];

    // Helper squares
    const s_2 = s * s;
    const yz_2 = yz * yz, zx_2 = zx * zx, xy_2 = xy * xy;
    const xw_2 = xw * xw, yw_2 = yw * yw, zw_2 = zw * zw;
    const p_2 = p * p;

    const out = new Float32Array(4);

    out[0] = ((s_2 + p_2 + yz_2 - zx_2 - xy_2 + xw_2 - yw_2 - zw_2) * v[0]) +
        (2 * ((s * -xy) + (p * zw) + (yz * zx) + (yw * xw)) * v[1]) +
        (2 * ((s * zx) + (p * -yw) + (yz * xy) + (zw * xw)) * v[2]) +
        (2 * ((s * xw) + (p * yz) - (yw * xy) + (zw * zx)) * v[3])

    out[1] = (2 * ((s * xy) + (p * -zw) + (zx * yz) + (xw * yw)) * v[0]) +
        ((s_2 + p_2 - yz_2 + zx_2 - xy_2 - xw_2 + yw_2 - zw_2) * v[1]) +
        (2 * ((s * -yz) + (p * xw) + (zx * xy) + (zw * yw)) * v[2]) +
        (2 * ((s * yw) + (p * zx) + (xw * xy) - (zw * yz)) * v[3])

    out[2] = (2 * ((s * -zx) + (p * yw) + (xy * yz) + (xw * zw)) * v[0]) +
        (2 * ((s * yz) + (p * -xw) + (xy * zx) + (yw * zw)) * v[1]) +
        ((s_2 + p_2 - yz_2 - zx_2 + xy_2 - xw_2 - yw_2 + zw_2) * v[2]) +
        (2 * ((s * zw) + (p * xy) - (xw * zx) + (yw * yz)) * v[3])

    out[3] = (2 * ((s * xw) + (p * yz) - (zx * zw) + (xy * yw)) * v[0]) +
        (2 * ((s * yw) + (p * zx) + (yz * zw) - (xy * xw)) * v[1]) +
        (2 * ((s * zw) + (p * xy) - (yz * yw) + (zx * xw)) * v[2]) +
        ((s_2 + p_2 + yz_2 + zx_2 + xy_2 + xw_2 + yw_2 + zw_2) * v[3])

    return out;
}

static toMat4(r: Rot4): Mat4 {
    const s = r[0], yz = r[1], zx = r[2], xy = r[3],
        xw = r[4], yw = r[5], zw = r[6], p = r[7];

    // Helper squares
    const s_2 = s * s;
    const yz_2 = yz * yz, zx_2 = zx * zx, xy_2 = xy * xy;
    const xw_2 = xw * xw, yw_2 = yw * yw, zw_2 = zw * zw;
    const p_2 = p * p;

    const out = MAT4_IDENTITY.slice();

    // all vₙ parts IN TO OUT v'₁ to v'₄ - COLUMN MAYOR!!

    // COLUMN 0 (Basis X: v=[1, 0, 0, 0])  
    out[0] = (s_2 + p_2 + yz_2 - zx_2 - xy_2 + xw_2 - yw_2 - zw_2);
    out[1] = 2 * ((s * xy) + (p * -zw) + (zx * yz) + (xw * yw));
    out[2] = 2 * ((s * -zx) + (p * yw) + (xy * yz) + (xw * zw));
    out[3] = 2 * ((s * xw) + (p * yz) - (zx * zw) + (xy * yw));

    // COLUMN 1 (Basis Y: v=[0, 1, 0, 0])
    out[4] = 2 * ((s * -xy) + (p * zw) + (yz * zx) + (yw * xw));
    out[5] = (s_2 + p_2 - yz_2 + zx_2 - xy_2 - xw_2 + yw_2 - zw_2);
    out[6] = 2 * ((s * yz) + (p * -xw) + (xy * zx) + (yw * zw));
    out[7] = 2 * ((s * yw) + (p * zx) + (yz * zw) - (xy * xw));

    // COLUMN 2 (Basis Z: v=[0, 0, 1, 0])
    out[8] = 2 * ((s * zx) + (p * -yw) + (yz * xy) + (zw * xw));
    out[9] = 2 * ((s * -yz) + (p * xw) + (zx * xy) + (zw * yw));
    out[10] = (s_2 + p_2 - yz_2 - zx_2 + xy_2 - xw_2 - yw_2 + zw_2);
    out[11] = 2 * ((s * zw) + (p * xy) - (yz * yw) + (zx * xw));

    // COLUMN 3 (Basis W: v=[0, 0, 0, 1])
    out[12] = 2 * ((s * xw) + (p * yz) - (yw * xy) + (zw * zx));
    out[13] = 2 * ((s * yw) + (p * zx) + (xw * xy) - (zw * yz));
    out[14] = 2 * ((s * zw) + (p * xy) - (xw * zx) + (yw * yz));
    out[15] = (s_2 + p_2 + yz_2 + zx_2 + xy_2 + xw_2 + yw_2 + zw_2);

    return out;
}

Geometric Algebra Space-Time ❡

Sources ❡

Format ❡

Basis Axes ❡

Bivectors ❡

Trivectors ❡

Quadvector ❡

In Algo ❡

(s² - I²)v + 2s(v · B) + 2I(v ∧ B) + 2(v · B)B - vB² ❡

B² ❡

2(v · B)B ❡

(s² - I² - ⟨B²⟩₀)v + 2s(v · B) + 2I(v ∧ B) + ⟨2(v · B)B⟩₁ ❡

I² ❡

v · B ❡

(v · B) · B ❡

2I(v ∧ B) ❡

Putting it all together ❡

s² ❡

p² ❡

⟨B²⟩₀ ❡

v = e₁ ❡

(s² + p² - ⟨B²⟩₀)v ❡

2s(v · B) ❡

2I(v ∧ B) ❡

2(v · B) · B ❡

simplify ❡

v = e₂ ❡

(s² + p² - ⟨B²⟩₀)v ❡

2s(v · B) ❡

2I(v ∧ B) ❡

2(v · B) · B ❡

simplify ❡

v = e₃ ❡

(s² + p² - ⟨B²⟩₀)v ❡

2s(v · B) ❡

2I(v ∧ B) ❡

2(v · B) · B ❡

simplify ❡

v = e₄ ❡

(s² + p² - ⟨B²⟩₀)v ❡

2s(v · B) ❡

2I(v ∧ B) ❡

2(v · B) · B ❡

simplify ❡

combine ❡

R×R ❡

Collect ❡

Code ❡

Geometric Algebra Space-Time

Sources

Format

Basis Axes

Bivectors

Trivectors

Quadvector

In Algo

(s² - I²)v + 2s(v · B) + 2I(v ∧ B) + 2(v · B)B - vB²

B²

2(v · B)B

(s² - I² - ⟨B²⟩₀)v + 2s(v · B) + 2I(v ∧ B) + ⟨2(v · B)B⟩₁

`I²`

v · B

(v · B) · B

2I(v ∧ B)

Putting it all together

s²

p²

⟨B²⟩₀

v = e₁

`(s² + p² - ⟨B²⟩₀)v`

`2s(v · B)`

`2I(v ∧ B)`

`2(v · B) · B`

simplify

v = e₂

`(s² + p² - ⟨B²⟩₀)v`

`2s(v · B)`

`2I(v ∧ B)`

`2(v · B) · B`

simplify

v = e₃

`(s² + p² - ⟨B²⟩₀)v`

`2s(v · B)`

`2I(v ∧ B)`

`2(v · B) · B`

simplify

v = e₄

`(s² + p² - ⟨B²⟩₀)v`

`2s(v · B)`

`2I(v ∧ B)`

`2(v · B) · B`

simplify

combine

R×R

Collect

Code