E.P.J. de Haas · Kandinsky College, Nijmegen

The BQ algebra, one matrix product at a time

In the BQ-Pauli algebra a physical four-vector is four real coordinates on a basis of 2×2 complex matrices, A = a0T̂ + a·K̂, with K̂ = (Î, Ĵ, K̂). Multiplying such vectors is ordinary matrix multiplication, and the algebra sorts every product into its own channels. These eleven interactive models build that up in four themes, from the bare algebra to gravity, and every result on them is computed live from the explicit matrices. A separate section lifts the algebra to the Dirac level.

space-time (minquat)T̂   Î   Ĵ   K̂ spin-norm (pauliquat)1̂   σ̂I   σ̂J   σ̂K withT̂ = i1̂,  K̂i = T̂σ̂i

Eleven interactive models in four themes

Each theme adds one ingredient to the previous one: the bare algebra, then four-vectors and their products, then a global rapidity that changes the frame, then a local rapidity field that brings in gravity.

1Algebra only

The eight basis matrices and their 64 products, before any physics is put on them.

space-time spin-norm
Step 1 · the basis

BQ-Pauli multiplication table

Pick any of the 64 products of the eight basis matrices. The page multiplies the two 2×2 matrices entry by entry, identifies the outcome as a signed basis element, and checks it against the table in the paper.

σ̂Iσ̂J = −K̂,   T̂K̂i = −σ̂i
entry-by-entry workingcommute or anticommuteslide equation numbers
Open the table

2Vectors and their multiplication

Real coordinates on the space-time basis make four-vectors; their products sort into the norm, rotation and boost channels and carry Maxwell’s equations, the Lorentz force and the field quadratics.

ATB 1̂ K̂ σ̂ normrotationboost R, P, U, ∂,A, J, G, F …
Step 2 · two four-vectors

Bilinear product explorer

Choose A and B from the four-vectors of the BQ papers, from position and momentum to the four-gradient, the potential and the current. The page derives the three channels of ATB symbolically and checks them by explicit matrix multiplication.

ATB = (a0b0 − a·b)1̂ + (a×b)·K̂ + (a0b − ab0)·σ̂
RTP, ∂TA, JTAinvariant normsnumerical check
Open the explorer
D c1 cK cσ 1̂T̂ K̂σ̂ −∇·B∇·E / cAmpèreFaraday
Step 3 · three four-vectors

Triple product explorer

Multiply a bilinear from the left by a third four-vector. The output fills all four channels 1̂, T̂, K̂ and σ̂: with D = ∂ and C = ∂TA it gives Maxwell’s equations, with D = J the Lorentz force and its spin-norm partner.

E = −(d·cK)1̂ + (d0c1 + d·cσ)T̂ + …
∂B: MaxwellJB: Lorentz forcefluid UH and ∂H
Open the explorer
FF FTF 1̂T̂ 1̂σ̂ B² − E²/c²E·B / c energy densityPoynting E×B invariant observer-dependent
Step 4 · the fields squared

Field quadratics

Square a field F = f1̂ + k·K̂ + s·σ̂ in two ways. FF holds the Lorentz invariants, FTF an energy density and its flux in a chosen frame. Applied to the electromagnetic field, the relativistic fluid field and the angular-momentum bivector.

BB = −(B² − E²/c²)1̂ + (2/c)(E·B)T̂
EM invariantsenergy and Poyntingfluid uH and Π×Ω
Open the model

3Lorentz transformations: a global rapidity

One constant rapidity ψ between two inertial frames, AL = U−1AU−1, applied to vectors, to the bilinear and to the triple-product equations.

AL = U−1AU−1 U = eψσ̂I/2 AL⁻¹ = UAU
Step 5 · changing frame

Lorentz transformations

Boost any four-vector of the papers along Î with the rotor U = eψσ̂I/2: AL = U−1AU−1, its inverse UAU, and the time adjoint, which transforms the other way: (AT)L = (AL−1)T. A spacetime diagram shows the vector moving along its invariant hyperbola.

a0′ = γ(a0 − βa1),  a1′ = γ(a1 − βa0)
rapidity sliderexp-rotorinverse and adjoint
Open the model
σ̂-channel K̂-channel C = ATB CL = UCU−1 CL⁻¹ = U−1CU
Step 6 · changing frame for products

Lorentz transformation of the bilinear

Boost both factors of C = ATB for any pair of the papers’ four-vectors. The adjoint carries the opposite rotor, so the bilinear transforms by a similarity, CL = UCU−1: the norm stays, and the K̂ and σ̂ channels mix like B and E/c. Shown in seven forms, from the matrix and the rotor to Minkowski’s complex field transformation.

cK,J′ = γ(cK,J + βcσ,K),  cσ,K′ = γ(cσ,K + βcK,J)
all 144 pairsEM field boostMinkowski 1908
Open the model
∂B = μ0J JB = F ∂′B′ = μ0J′ J′B′ = F′ EL = U−1(DC)U−1
Step 7 · equations in every frame

Lorentz covariance of the triple product

A triple E = D(ATB) is boosted like a four-vector again, EL = U−1EU−1, and both its minquat and its pauliquat sector are four-vectors. So ∂B = μ0J, JB = F and the fluid equations keep their form, checked with boosted vectors and with fields differentiated in the boosted coordinates.

eT′ = γ(eT − βeK,I),  e1′ = γ(e1 − βeσ,I)
MaxwellLorentz forcefluid equations
Open the model

4Gravity: a local rapidity

The rapidity becomes a field χ(r, t) feeding a local rotor; a Galilean coframe with a Lorentzian quadratic gives the metric; the constant-Lagrangian disk is read in that metric and derived along two routes, the rotor’s own Maurer–Cartan connection and the convective acceleration of the flow.

r_c dRG = G−1dR G−1 θr = dr − v dt → gμν
Step 8 · gravity as a local rotor

The gravity rotor: from rapidity to metric

Newtonian, Hubble and azimuthal rapidity fields feed a local Lorentz rotor G(r, t). Its action on dR is exact and its quadratic flat; the gravitational content is in the choice of a Galilean coframe with a Lorentzian quadratic, which gives the riverbed and gμν. Compared with Schwarzschild, de Sitter/FLRW, Schwarzschild–de Sitter and a rotating frame, and tested with its Einstein tensor.

gtt = −(c² − vr²),  gtr = ∓vr,  vr = c(ψN − ψH)
rapidity buttonsGalilean coframeEinstein tensor
Open the model
R CL: γrs constant Kepler γrs = −u·us/c² = c/√(−gtt)
Step 9 · CL in the metric

CL as an equi-redshift flow

In the Galilean-coframe metric with a radial and an azimuthal river, γrs is the river’s Lorentz factor relative to the static Killing observers, equal to the rotor’s Γ at slow-flow order. The river is geodesic with conserved Killing energy, so wherever the radial flow is nonzero the constant-Lagrangian condition means flow along levels of the redshift factor. The constant is a closure; a slowly changing H leaves the analysis intact, and the normal-frame energy density of the CL disk comes out negative under ordinary GR.

Dγrs/Dτ = 0 ⇔ ∂rgtt = 0 ⇔ vr² + vφ² = K  (vr ≠ 0)
Killing energyredshift levelsquasi-stationary H
Open the model
R eT = 0 Kepler [UgΩτ]T = (c/2) DΓ/Dτ
Step 10 · the rotor’s own connection

The Maurer–Cartan route to isorapidity

The Maurer–Cartan connection Ωτ = (DG/Dτ)G−1 of the ordered rotor G = GφGr, transported with Ug in the triple product. Its time channel is exactly (c/2)DΓ/Dτ, so isorapidity means no boost rate along the flow. Starting from the Newtonian rapidity alone, the azimuthal and Hubble rapidities and a virial closure at R lead to the galactic rotation law.

eT = 0 ⇔ cosh χr cosh χφ = Γ0 ⇒ vφ² = (3/2)vr(R)² − vr²
Maurer–CartanThomas–Wigner channelrotation curve
Open the model
u a ⊥ u a0 = c DΓ/Dτ = 0 Ag = ΩτUg + UgΩτ†
Step 11 · the four-velocity’s own rate

The kinematic route to isorapidity

The convective four-acceleration Ag = DUg/Dτ of the rotor-boosted four-velocity. Its time channel is c DΓ/Dτ, the power per unit mass along the flow, and UgTAg has no norm channel. Isorapidity is the branch with purely transverse acceleration, and Ag = ΩτUg + UgΩτ† makes it one statement with the Maurer–Cartan route.

a0 = c DΓ/Dτ = 2eT,  u0a0 = u·a
convective accelerationorthogonalitypower
Open the model

The Dirac level

The lift of the BQ-Pauli algebra to 4×4 matrices has its own index, models and scripts in the folder dirac/.

βμ αi Σi β̃μ χ βK = [[0, K̂], [−K̂, 0]] 16 × 16 products, blocks of BQ-Pauli elements
The next level · its own index

The BQ algebra at the Dirac level

The same algebra one storey up: 4×4 complex matrices in the Weyl representation, whose 2×2 blocks are BQ-Pauli elements. Sixteen basis elements in grades 0 to 4, with their own models and Python scripts, starting from the BQ-Dirac multiplication table.

β0² = −𝟙,  βi² = +𝟙,  χ = −β0βIβJβK,  χ² = −𝟙
Weyl representationPauli blocksgrades 0–4
Go to the Dirac level

Reproduce in Python

The web pages compute in JavaScript. The folder py_sources holds an independent Python implementation with SymPy. It checks every channel rule exactly along two routes: term by term with the multiplication table, as on these pages, and as an explicit 2×2 matrix product decomposed on the eight basis elements.

  • 1 · Algebra only
  • bq_core.py · basis, four-vectors, operator order, channel rules
  • bq_pauli_table.py · the 64 basis products against the paper’s table
  • 2 · Vectors and their multiplication
  • bq_bilinear.py · the channels of ATB, all 169 pairs
  • bq_triple.py · the four channels of D(ATB), all 2197 triples
  • bq_quadratics.py · FF and FTF for the EM, fluid and other fields
  • 3 · Global rapidity
  • bq_lorentz.py · AL = U−1AU−1, adjoints, invariance, step 5 and the Lemma
  • bq_bilinear_lorentz.py · CL = UCU−1 for all 169 pairs, basis rules and complex form
  • bq_triple_lorentz.py · EL = U−1EU−1 for all 2197 triples, both sectors, both lemmas
  • 4 · Local rapidity: gravity
  • bq_gravity_rotor.py · the gravity rotor: dRG, flat quadratic, Galilean coframe, gμν, known metrics, Einstein tensor
  • bq_cl_killing.py · γrs as the river–static Lorentz factor, CL as an equi-redshift flow, the closures for K, quasi-stationary H, Gn̂n̂ < 0
  • bq_mc_connection.py · Ωτ = (DG/Dτ)G−1, the channels of UgΩτ, eT = (c/2)DΓ/Dτ exactly, isorapidity and the rotation law
  • bq_kinematic_route.py · Ag = DUg/Dτ, a0 = c DΓ/Dτ, orthogonality, the two branches, Ag = ΩτUg + UgΩτ†

Only Python 3 and SymPy are needed. A four-gradient acts on everything to its right; when it stands last, the product is evaluated on a test field ψ.

# get the code and install SymPy
git clone https://github.com/haas2u-ai/bq_algebra
cd bq_algebra/py_sources
pip install -r requirements.txt

# 1 · algebra only: the multiplication table
python bq_pauli_table.py
python bq_pauli_table.py sI sJ

# 2 · vectors and their multiplication
python bq_bilinear.py R P --table
python bq_bilinear.py --all
python bq_triple.py J D A --c1zero --table
python bq_triple.py --examples
python bq_quadratics.py --all

# 3 · global rapidity: Lorentz transformations
python bq_lorentz.py --all
python bq_bilinear_lorentz.py --all
python bq_triple_lorentz.py --maxwell
python bq_triple_lorentz.py --all

# 4 · local rapidity: gravity
python bq_gravity_rotor.py
python bq_cl_killing.py
python bq_mc_connection.py
python bq_kinematic_route.py

Conventions used throughout

All coordinates are real; the imaginary unit sits in the basis element T̂ = i1̂, so the Lorentz signature enters through the basis and not through index lowering. The space-time basis T̂, Î, Ĵ, K̂ and the spin-norm basis 1̂, σ̂I, σ̂J, σ̂K together span the full biquaternion algebra; a product of two space-time vectors always needs both.

The superscript T is the BQ time-reversal operation, AT = −a0T̂ + a·K̂: not the matrix transpose, not conjugation and not multiplication by T̂. In every product the left factor stands to the left, so a four-gradient on the left acts on what follows it.

Each model computes its results from the explicit 2×2 matrices and shows a numerical check of the stated rule; the Python sources repeat every product as an exact symbolic check. The BQ definitions in the papers remain authoritative; pages and scripts are a reproducibility aid.

Links