Edit detail for SandBox Categorical Relativity revision 11 of 11

Special relativity without Lorentz transformations.

Here are some sample computations based on papers by Z. Oziewicz

• Relativity grupoid instead of relativity group
• How do you add relative velocities?
• What Is Categorical Relativity?

  In categorical relativity the inverse relative velocity morphism is observer dependent, and not absolute as in the usual formulation where .

and the book by T. Matolcsi

• Space-time without reference frames

See also the slides: SandBoxRelativeVelocity (presented at IARD 2006).

Mathematical Preliminaries

A vector is represented as a nx1 matrix (column vector)

(1) -> vect(x:List Expression Integer):Matrix Expression Integer == matrix map(y+->[y],x)

   Function declaration vect : List(Expression(Integer)) -> Matrix(
      Expression(Integer)) has been added to workspace.

vect [a1,a2,a3]

Compiling function vect with type List(Expression(Integer)) -> 
      Matrix(Expression(Integer))

(1)

Then a row vector is

transpose(vect [a1,a2,a3])

(2)

Inner product is

transpose(vect [a1,a2,a3])*vect [b1,b2,b3]

(3)

and tensor product is

vect [a1,a2,a3]*transpose(vect [b1,b2,b3])

(4)

Applying the Lorentz form produces a row vector

g(x)==transpose(x)*diagonalMatrix [-1,1,1,1]

or a scalar

g(x,y)== (transpose(x)*diagonalMatrix([-1,1,1,1])*y)::EXPR INT

For difficult verifications it is sometimes convenient to replace symbols by random numerical values.

possible(x)==subst(x, map(y+->(y=(random(100) - random(100))),variables x) )

Is?(eq:Equation EXPR INT):Boolean == (lhs(eq)-rhs(eq)=0)::Boolean

   Function declaration Is? : Equation(Expression(Integer)) -> Boolean 
      has been added to workspace.

Is2?(eq:Equation(Matrix(EXPR(INT)))):Boolean == _
( (lhs(eq)-rhs(eq)) :: Matrix Expression AlgebraicNumber = _
zero(nrows(lhs(eq)),ncols(lhs(eq)))$Matrix Expression AlgebraicNumber )::Boolean

   Function declaration Is2? : Equation(Matrix(Expression(Integer)))
       -> Boolean has been added to workspace.

The AlgebraicNumber? domain can test for numerical equality of complicated expressions involving .

IsPossible?(eq:Equation EXPR INT):Boolean == _
  (possible(lhs(eq)-rhs(eq)) :: Expression AlgebraicNumber=0)::Boolean

   Function declaration IsPossible? : Equation(Expression(Integer)) -> 
      Boolean has been added to workspace.

IsPossible2?(eq:Equation(Matrix(EXPR(INT)))):Boolean == _
  ( map(possible,(lhs(eq)-rhs(eq))) :: Matrix Expression AlgebraicNumber = _
zero(nrows(lhs(eq)),ncols(lhs(eq)))$Matrix Expression AlgebraicNumber )::Boolean

   Function declaration IsPossible2? : Equation(Matrix(Expression(
      Integer))) -> Boolean has been added to workspace.

Massive Objects

An object (also referred to as an obserser) is represented by a time-like 4-vector

P:=vect [sqrt(p1^2+p2^2+p3^2+1),p1,p2,p3];

g(P,P)

Compiling function g with type (Matrix(Expression(Integer)), Matrix(
      Expression(Integer))) -> Expression(Integer)

(5)

Q:=vect [sqrt(q1^2+q2^2+q3^2+1),q1,q2,q3];

g(Q,Q)

(6)

Associated with each such vector is the orthogonal 3-d Euclidean subspace

Relative Velocity

An object Q has a unique relative velocity w(P,Q) with respect to object P given by

w(P,Q)==-Q/g(P,Q)-P

Lorentz factor

gamma(v)==1/sqrt(1-g(v,v))

Binary Boost

b(P,v)==gamma(v)*(P+v)

Observer P measures velocity u. u is space-like and in .

u:=w(P,Q);

Compiling function w with type (Matrix(Expression(Integer)), Matrix(
      Expression(Integer))) -> Matrix(Expression(Integer))

g(P,u)

(7)

possible(g(u,u))::EXPR Float

Compiling function possible with type Expression(Integer) -> 
      Expression(Integer)

(8)

IsPossible?(gamma(u)=-g(P,Q))

Compiling function gamma with type Matrix(Expression(Integer)) -> 
      Expression(Integer)

Compiling function IsPossible? with type Equation(Expression(Integer
      )) -> Boolean

(9)

u is velocity of object Q

IsPossible?(g(Q,u)=gamma(u)-1/gamma(u))

(10)

Observer Q is u-boost of P

IsPossible2?(Q=b(P,u))

Compiling function b with type (Matrix(Expression(Integer)), Matrix(
      Expression(Integer))) -> Matrix(Expression(Integer))

Compiling function IsPossible2? with type Equation(Matrix(Expression
      (Integer))) -> Boolean

(11)

Inverse velocity is measured by Q

u' := w(Q,P);

g(Q,u')

(12)

Inverse velocity is not reciprocal

IsPossible2?(-u=u')

(13)

Object P is u'-boost of Q

IsPossible2?(P=b(Q,u'))

(14)

Objects P and Q are completely determined by velocities u and u'

IsPossible2?(P = -1/g(u,u)*(u+u'/gamma(u)))

(15)

IsPossible2?(Q = -1/g(u,u)*(u'+u/gamma(u)))

(16)

The magnitude of the inverse velocity is the same as the velocity

IsPossible?(g(u,u)=g(u',u'))

(17)

Collinear Velocities

Suppose the velocity v of some object L is collinear with reciprocal velocity u':

v := alpha*u';

L := b(Q,v);

Is2?(v=w(Q,L))

Compiling function Is2? with type Equation(Matrix(Expression(Integer
      ))) -> Boolean

(18)

Composition of collinear velocities

For velocity v collinear with reciprocal velocity u' we have Matolcsi (4.3.3)

Is2?(w(P,L)=(u-alpha*u)/(1-alpha*g(u,u)))

(19)

General composition of relative velocities (Oziewicz)

compose(v,u,u') == ( u + v/gamma(u) - g(v,u')/g(u,u)*(u + u'/gamma(u)) ) / (1-g(v,u'))

Is2?(w(P,L)=compose(v,u,u'))

Compiling function compose with type (Matrix(Expression(Integer)), 
      Matrix(Expression(Integer)), Matrix(Expression(Integer))) -> 
      Matrix(Expression(Integer))

(20)

IsPossible2?(w(P,L)=compose(w(Q,L),w(P,Q),w(Q,P)))

(21)

Associativity

Unlike Einstein addition of velocities, composition (denoted ) of relative velocities is associative:

R:=vect [sqrt(r1^2+r2^2+r3^2+1),r1,r2,r3];

g(R,R)

(22)

S:=vect [sqrt(s1^2+s2^2+s3^2+1),s1,s2,s3];

g(S,S)

(23)

Unfortunately Axiom is not able to evaluate all of these in a reasonable amount of time (within the 1 minute wiki limit).

--IsPossible2?(w(P,R)=compose(w(Q,R),w(P,Q),w(Q,P)))
--IsPossible2?(w(R,P)=compose(w(Q,P),w(R,Q),w(Q,R)))
IsPossible2?(w(Q,S)=compose(w(R,S),w(Q,R),w(R,Q)))

(24)

--IsPossible2?(w(P,S)=compose(w(Q,S),w(P,Q),w(Q,P)))
--IsPossible2?(w(P,S)=compose(w(R,S),w(P,R),w(R,P)))
0

(25)