Conformal Ga

conformal-ga

CGA: Embed Euclidean space into a higher-dimensional conformal space

Version: 1.0.0
Trit: -1 (MINUS - contractive/measurement)

Overview

Conformal Geometric Algebra (CGA) extends PGA by adding two extra dimensions that encode scale and infinity. This allows representing circles and spheres as simple blades.

Algebra Signatures

Null Basis

The key insight: two null vectors encode the origin and infinity:

Algebra(4,1, () => {
  // Standard basis: e1, e2, e3 (Euclidean), e4 (+), e5 (-)
  
  // Null vectors
  var no = 0.5*(1e5 - 1e4);  // Origin (null)
  var ni = 1e4 + 1e5;         // Infinity (null)
  
  // Key property: no · ni = -1
  console.log((no << ni).s);  // -1
  
  // Point embedding: x ↦ no + x + (x²/2)ni
  var point = (x,y,z) => {
    var x2 = x*x + y*y + z*z;
    return no + x*1e1 + y*1e2 + z*1e3 + 0.5*x2*ni;
  };
});

Geometric Objects as Blades

Points (Grade 1 OPNS)

var P = point(1, 2, 3);  // Null vector
// P · P = 0 (null)

Point Pairs (Grade 2)

var A = point(0,0,0), B = point(1,0,0);
var pointPair = A ^ B;  // Wedge of two points

Circles (Grade 3)

var A = point(0,0,0), B = point(1,0,0), C = point(0,1,0);
var circle = A ^ B ^ C;  // Through three points

// Or: dual sphere intersected with plane
var sphere = dualSphere(center, radius);
var plane = dualPlane(normal, distance);
var circle2 = sphere ^ plane;

Spheres (Grade 4 OPNS / Grade 1 IPNS)

// OPNS: 4 points define a sphere
var sphere = A ^ B ^ C ^ D;

// IPNS (dual): center + radius encoding
var dualSphere = (c, r) => point(c.x, c.y, c.z) - 0.5*r*r*ni;

Planes (Grade 4 OPNS)

// OPNS: 3 points + infinity
var plane = A ^ B ^ C ^ ni;

// IPNS (dual): normal + distance
var dualPlane = (n, d) => n.x*1e1 + n.y*1e2 + n.z*1e3 + d*ni;

Conformal Transformations

All Möbius transformations are motors in CGA!

Rotation

// Same as PGA - bivector in Euclidean part
var rotor = Math.cos(angle/2) + Math.sin(angle/2)*1e12;
var rotated = rotor * object * ~rotor;

Translation

// Translator uses ni (infinity)
var translator = 1 - 0.5*distance*(direction ^ ni);
var translated = translator * object * ~translator;

Dilation (Scaling)

// Unique to CGA - uses no and ni
var dilator = Math.cosh(s/2) + Math.sinh(s/2)*(no ^ ni);
var scaled = dilator * object * ~dilator;
// Scales by e^s

Inversion (Circle/Sphere)

// Reflect in a sphere - a versor!
var inverted = sphere * point * sphere;
// Maps inside to outside

Distance and Angle Extraction

Distance Between Points

function distance(P, Q) {
  return Math.sqrt(-2 * (P << Q).s);
}

Radius of Sphere/Circle

function radius(sphere) {
  var s2 = (sphere * sphere).s;
  var sni = (sphere << ni).s;
  return Math.sqrt(Math.abs(s2)) / Math.abs(sni);
}

OPNS vs IPNS

// Convert between them via dualization
var ipns = !opns;  // Dual
var opns = !ipns;  // UnDual

ganja.js CGA Examples

Algebra(4,1, () => {
  var no = 0.5*(1e5-1e4), ni = 1e4+1e5;
  var point = (x,y,z) => no + x*1e1 + y*1e2 + z*1e3 + 0.5*(x*x+y*y+z*z)*ni;
  
  // Three points define a circle
  var A = point(1,0,0), B = point(0,1,0), C = point(-1,0,0);
  var circle = A ^ B ^ C;
  
  // Render it
  return this.graph([
    0xFF0000, A, B, C,
    0x00FF00, circle
  ], {conformal: true, gl: true});
});

GF(3) Role

CGA is MINUS (-1) because it primarily measures and contracts:

• Distance computation uses inner product (contraction)
• Sphere/circle radius extraction
• Intersection (meet) operations

Conservation Triad

conformal-ga (-1) ⊗ pga-motor-interpolation (0) ⊗ ga-visualization (+1) = 0 ✓

Applications

1. Computer Vision: Circle/sphere fitting
2. Robotics: Kinematics with scaling
3. Graphics: Ray-sphere intersection
4. Physics: Conformal field theory

Related Algebras

Commands

# ganja.js CGA demo
node -e "var A=require('ganja.js'); A(4,1,()=>{
  var no=0.5*(1e5-1e4), ni=1e4+1e5;
  var pt=(x,y,z)=>no+x*1e1+y*1e2+z*1e3+0.5*(x*x+y*y+z*z)*ni;
  console.log('Origin:', pt(0,0,0));
  console.log('ni:', ni);
})()"

# Python clifford
python3 -c "from clifford.g3c import *; print(eo, einf)"

References

• ganja.js CGA examples
• Geometric Algebra for Computer Science - Dorst, Fontijne, Mann
• clifford Python library
• bivector.net CGA tutorials

Autopoietic Marginalia

The interaction IS the skill improving itself.

Every use of this skill is an opportunity for worlding:

• MEMORY (-1): Record what was learned
• REMEMBERING (0): Connect patterns to other skills
• WORLDING (+1): Evolve the skill based on use

Add Interaction Exemplars here as the skill is used.