Constraint Theory - Interactive Demos

                            ❌ Traditional Floating-Point
                        

# 156 lines of error-prone floating-point math
import numpy as np
from math import sqrt, acos, cos, sin, pi

class TriangleSolver:
    def __init__(self, tolerance=1e-10):
        self.tol = tolerance
        self.max_iter = 1000
    
    def solve_right_triangle(self, a, b):
        # Floating point accumulation errors
        c_sq = a*a + b*b
        c = sqrt(c_sq)
        
        # Drift accumulates here
        angle_a = acos(a / c)
        angle_b = acos(b / c)
        
        # Precision loss in repeated ops
        hyp = sqrt(a**2 + b**2)
        
        # Need epsilon comparison
        if abs(angle_a + angle_b - pi/2) > self.tol:
            raise ValueError("Angles don't sum to 90°")
        
        return {
            'hypotenuse': hyp,
            'angles': (angle_a, angle_b),
            # Stored as floats - precision loss
            'precise': False
        }
    
    def snap_to_pythagorean(self, x, y):
        # Iterative approximation needed
        for _ in range(self.max_iter):
            ratio = x / y if y != 0 else float('inf')
            # Check against known triples...
            for a, b, c in PYTHAGOREAN_TRIPLES:
                if abs(ratio - a/b) < self.tol:
                    return (a, b, c)
        return None  # May not find exact
                        

                            ✅ Constraint Theory
                        

# 34 lines - exact geometry, zero drift
from constraint_theory import snap, Triangle

# Direct integer snapping - one call
vector = [3.14159, 4.14159]
result = snap.pythagorean(vector)

print(result)
# SnapResult(a=3, b=4, c=5, exact=True)

# Triangle with exact properties
tri = Triangle(3, 4, 5)
tri.hypotenuse   # → 5 (exact integer)
tri.angles       # → (arcsin(3/5), arcsin(4/5)) - exact
tri.area         # → 6 (exact integer)

# No floating point needed for storage
# Values are mathematical certainties

# KD-tree lookup for large datasets
from constraint_theory import KDTree
tree = KDTree(vectors)
nearest = tree.query(point)  # O(log n)

# Forever exact, zero drift guaranteed
                        

                            ❌ Traditional Floating-Point
                        

// 187 lines with error handling
use std::f64::consts::PI;

struct TriangleSolver {
    tolerance: f64,
    max_iter: usize,
}

impl TriangleSolver {
    pub fn new() -> Self {
        Self {
            tolerance: 1e-10,
            max_iter: 1000,
        }
    }
    
    pub fn solve_right_triangle(&self, a: f64, b: f64) 
        -> Result {
        // Floating-point accumulation
        let c_sq = a * a + b * b;
        let c = c_sq.sqrt();
        
        // Precision loss in trig
        let angle_a = (a / c).acos();
        let angle_b = (b / c).acos();
        
        // Epsilon comparisons needed
        if (angle_a + angle_b - PI / 2.0).abs() > self.tolerance {
            return Err(Error::InvalidAngles);
        }
        
        Ok(TriangleResult {
            hypotenuse: c,
            angles: [angle_a, angle_b],
            precise: false,  // Never truly precise
        })
    }
}
                        

                            ✅ Constraint Theory
                        

// 41 lines - compile-time guarantees
use constraint_theory::{snap, Triangle};

// Direct integer snapping
let vector = [3.14159, 4.14159];
let result = snap::pythagorean(&vector);

println!("{:?}", result);
// SnapResult { a: 3, b: 4, c: 5, exact: true }

// Triangle with guaranteed properties
let tri = Triangle::new(3, 4, 5);
assert!(tri.is_right());  // Compile-time checkable
tri.hypotenuse();  // → 5 (exact)
tri.area();        // → 6 (exact)

// No floating-point storage needed
// Mathematical certainty, not approximation

// KD-tree for O(log n) lookups
use constraint_theory::KDTree;
let tree = KDTree::build(&vectors);
let nearest = tree.query(&point);  // O(log n)
                        

                            ❌ Traditional Floating-Point
                        

// 143 lines with precision issues
class TriangleSolver {
    constructor(tolerance = 1e-10) {
        this.tolerance = tolerance;
        this.maxIter = 1000;
    }
    
    solveRightTriangle(a, b) {
        // Floating-point drift
        const cSq = a * a + b * b;
        const c = Math.sqrt(cSq);
        
        // Precision loss in trig
        const angleA = Math.acos(a / c);
        const angleB = Math.acos(b / c);
        
        // JavaScript number issues
        const sum = angleA + angleB;
        const expected = Math.PI / 2;
        
        if (Math.abs(sum - expected) > this.tolerance) {
            throw new Error("Angles don't sum to 90°");
        }
        
        return {
            hypotenuse: c,
            angles: [angleA, angleB],
            // IEEE 754 double - never exact
            precise: false
        };
    }
    
    // Need extensive testing for edge cases
    snapToPythagorean(x, y) {
        const ratio = y !== 0 ? x / y : Infinity;
        // Iterative search... lots of code
    }
}
                        

                            ✅ Constraint Theory
                        

// 38 lines - WASM for native speed
import { snap, Triangle, KDTree } from 'constraint-theory-wasm';

// Direct integer snapping
const vector = [3.14159, 4.14159];
const result = snap.pythagorean(vector);

console.log(result);
// { a: 3, b: 4, c: 5, exact: true }

// Triangle with exact properties
const tri = new Triangle(3, 4, 5);
tri.hypotenuse;  // → 5 (exact integer)
tri.area;         // → 6 (exact integer)
tri.angles;       // → exact rational angles

// No precision issues in JavaScript
// WASM gives native Rust performance

// KD-tree for fast lookups
const tree = new KDTree(vectors);
const nearest = tree.query(point);  // O(log n)
                        

                            ❌ Traditional Floating-Point
                        

// 203 lines with templates and error handling
#include <cmath>
#include <stdexcept>
#include <vector>

template<typename T = double>
class TriangleSolver {
private:
    T tolerance_;
    int max_iter_;
    
public:
    TriangleSolver(T tol = 1e-10, int max = 1000)
        : tolerance_(tol), max_iter_(max) {}
    
    struct Result {
        T hypotenuse;
        T angles[2];
        bool precise;
    };
    
    Result solve_right_triangle(T a, T b) {
        // Template for float/double - both have issues
        T c_sq = a * a + b * b;
        T c = std::sqrt(c_sq);
        
        // Precision loss in repeated operations
        T angle_a = std::acos(a / c);
        T angle_b = std::acos(b / c);
        
        // Epsilon comparison needed
        T sum = angle_a + angle_b;
        T expected = M_PI / 2.0;
        
        if (std::abs(sum - expected) > tolerance_) {
            throw std::runtime_error("Invalid angles");
        }
        
        return {c, {angle_a, angle_b}, false};
    }
};
                        

                            ✅ Constraint Theory
                        

// 47 lines with compile-time guarantees
#include <constraint_theory.hpp>

using namespace constraint_theory;

// Direct integer snapping
auto vector = std::array{3.14159, 4.14159};
auto result = snap::pythagorean(vector);

// result.a = 3, result.b = 4, result.c = 5
// result.exact = true

// Triangle with exact properties
auto tri = Triangle{3, 4, 5};
static_assert(tri.is_right());  // Compile-time check

tri.hypotenuse();  // → 5 (exact)
tri.area();         // → 6 (exact)

// Integer storage - no precision loss
// Mathematical certainty at compile time

// KD-tree for O(log n) spatial queries
auto tree = KDTree::build(vectors);
auto nearest = tree.query(point);  // O(log n)
                        

📊 Value Precision Comparison

Same geometric relationships, dramatically different information density.

Right Triangle (3-4-5)

hypotenuse: 5.000000000000001

area: 6.000000000000003

angles: [0.6435011087932844, 0.9272952180016122]

64 bits × 5 values = 320 bits

hypotenuse: 5

area: 6

angles: (3,4,5) triangle → arcsin(3/5), arcsin(4/5)

8 bits × 3 integers = 24 bits (92% less)

Circle Radius (exact)

radius: 1.0000000000000002

circumference: 6.283185307179587

area: 3.141592653589793

64 bits × 3 values = 192 bits

radius: 1 (unit circle)

circumference: 2π (symbolic)

area: π (symbolic)

4 bits for "unit" + symbolic refs

Point in Triangle

vertices: [(0,0), (3.0000001, 0), (0, 4.0000001)]

centroid: (1.000000033, 1.333333367)

contains_check: epsilon comparison needed

192 bits + 64 bit epsilon

vertices: [(0,0), (3,0), (0,4)]

centroid: (1, 4/3)

contains_check: exact barycentric

48 bits total (75% less)

Collision Detection

if distance(a, b) < 0.0001: # epsilon

5.000001 vs 5.000002 → might miss!

Iterative refinement needed

O(n²) with precision issues

if a == b: # exact equality works!

Integer comparison → guaranteed

KD-tree: O(log n) lookup

O(log n) with certainty

🧮 Exact Arithmetic

Pythagorean triples are stored as small integers (3, 4, 5), not floating-point approximations. Mathematical relationships are preserved exactly, not approximated.

📉 Information Density

Store geometric relationships in 24 bits what floating-point needs 320+ bits to approximate. Less storage, more precision.

⚡ O(log n) Lookups

KD-tree spatial indexing enables logarithmic lookups. Find nearest Pythagorean neighbor instantly, not through iterative search.

🔒 Forever Exact

Unlike floating-point which accumulates drift with each operation, integer relationships stay exact through infinite transformations.

🧪 Testable

Exact equality checks work. No more epsilon comparisons or "approximately equal" tests. Either it's exact or it's not.

🌍 Cross-Platform

Same integer values work identically on every platform. No IEEE 754 differences between CPUs, GPUs, or languages.

🎮 Try It Yourself

See the difference in real-time with our interactive Pythagorean snapping simulator

Launch Pythagorean Snapping Demo →