plurigrid SICMUtils (Emmy)
"Executable mathematics for computational physics" — Sam Ritchie (mentat-collective)
Overview
SICMUtils (now Emmy) is the Clojure implementation of the scmutils library from SICM. It provides:
- Symbolic algebra and simplification
- Automatic differentiation (forward and reverse mode)
- Literal functions and operators
- Lagrangian and Hamiltonian mechanics
- Differential geometry primitives
SRFI Reachability States
BEFORE: Disconnected State
┌─────────────────────────────────────────────────────────────┐
│ BEFORE SRFI BRIDGE │
├─────────────────────────────────────────────────────────────┤
│ SICMUtils (Clojure) SRFI (Scheme) │
│ ═══════════════════ ═════════════ │
│ emmy.generic/* SRFI-1 (lists) ╳ ISOLATED │
│ emmy.structure/* SRFI-9 (records) ╳ ISOLATED │
│ emmy.expression/* SRFI-27 (random) ╳ ISOLATED │
│ emmy.calculus/* SRFI-45 (lazy) ╳ ISOLATED │
│ emmy.mechanics/* SRFI-171 (transducers) ╳ │
│ │
│ No compositional path: Clojure ↛ Scheme │
│ No GF(3) conservation across language boundary │
│ No splittable RNG interop │
└─────────────────────────────────────────────────────────────┘
AFTER: Connected State via Cat# Bicomodules
┌─────────────────────────────────────────────────────────────┐
│ AFTER SRFI BRIDGE (via Cat# bicomodules) │
├─────────────────────────────────────────────────────────────┤
│ SICMUtils (Clojure) SRFI (Scheme) │
│ ═══════════════════ ═════════════ │
│ │
│ emmy.generic/* ────────────► SRFI-1 (fold/unfold) │
│ │ Bicomodule: List transformations │
│ │ ListAlgebra preserve structure │
│ ▼ │
│ emmy.structure/* ──────────► SRFI-9 (define-record-type) │
│ │ Bicomodule: Up/down tuples ↔ records │
│ │ StructBridge │
│ ▼ │
│ emmy.expression/* ─────────► SRFI-27 (random-source) │
│ │ Bicomodule: SplitMix64 ↔ random-source │
│ │ RNGBridge preserves determinism │
│ ▼ │
│ emmy.calculus/* ───────────► SRFI-45 (delay/force) │
│ │ Bicomodule: Lazy derivatives ↔ promises │
│ │ LazyDiff │
│ ▼ │
│ emmy.mechanics/* ──────────► SRFI-171 (transducers) │
│ Bicomodule: Phase space evolution as │
│ PhaseXduce composable transformation │
│ │
│ GF(3) CONSERVED across boundary via Gay.jl coloring │
└─────────────────────────────────────────────────────────────┘
Reachability Matrix
| SICMUtils Module | SRFI | Bicomodule | Trit | Reachable |
|---|---|---|---|---|
emmy.generic |
1 | ListAlgebra | -1 | ✓ AFTER |
emmy.structure |
9 | StructBridge | -1 | ✓ AFTER |
emmy.expression |
27 | RNGBridge | 0 | ✓ AFTER |
emmy.calculus |
45 | LazyDiff | 0 | ✓ AFTER |
emmy.numerical.ode |
171 | PhaseXduce | +1 | ✓ AFTER |
emmy.mechanics.lagrange |
204 | PatternMech | +1 | ✓ AFTER |
Bicomodule Implementations
1. ListAlgebra: emmy.generic ↔ SRFI-1
;; Clojure side (SICMUtils)
(ns sicmutils.srfi-bridge.list-algebra
(:require [emmy.generic :as g]))
(defn fold-to-srfi
"Translate emmy fold to SRFI-1 fold signature."
[f init coll]
;; SRFI-1: (fold kons knil list)
;; Emmy: (reduce f init coll)
(reduce f init coll))
(defn unfold-from-srfi
"Generate sequence using SRFI-1 unfold semantics."
[p f g seed]
;; SRFI-1: (unfold p f g seed)
(take-while (complement p)
(iterate g (f seed))))
;; Scheme side (SRFI-1)
(import (srfi 1))
(define (emmy-compatible-fold kons knil lis)
;; Wrap to ensure Clojure-compatible left fold
(fold kons knil lis))
2. RNGBridge: emmy.expression ↔ SRFI-27
;; Bridge Gay.jl SplitMix64 to SRFI-27 random-source
(ns sicmutils.srfi-bridge.rng
(:require [emmy.expression :as expr]))
(def ^:const GOLDEN 0x9e3779b97f4a7c15)
(def ^:const MIX1 0xbf58476d1ce4e5b9)
(def ^:const MIX2 0x94d049bb133111eb)
(defn splitmix64 [x]
(let [x (unchecked-add x GOLDEN)
x (unchecked-multiply (bit-xor x (unsigned-bit-shift-right x 30)) MIX1)
x (unchecked-multiply (bit-xor x (unsigned-bit-shift-right x 27)) MIX2)]
(bit-xor x (unsigned-bit-shift-right x 31))))
(defn make-emmy-random-source [seed]
{:seed (atom seed)
:next-int (fn []
(let [current @(:seed this)
next (splitmix64 current)]
(reset! (:seed this) next)
next))})
;; SRFI-27 wrapper for Emmy RNG
(import (srfi 27))
(define (make-emmy-compatible-source seed)
(let ((source (make-random-source)))
(random-source-pseudo-randomize! source seed 1069)
source))
;; Verify determinism matches Gay.jl
(define (verify-splitmix seed expected)
(let* ((source (make-emmy-compatible-source seed))
(rand-int (random-source-make-integers source)))
(= (rand-int (expt 2 64)) expected)))
3. LazyDiff: emmy.calculus ↔ SRFI-45
;; Lazy derivative computation
(ns sicmutils.srfi-bridge.lazy-diff
(:require [emmy.calculus.derivative :as d]))
(defn lazy-D
"Delay derivative computation until forced."
[f]
(delay (d/D f)))
(defn force-derivative [lazy-df x]
(@lazy-df x))
;; SRFI-45 lazy derivatives
(import (srfi 45))
(define (lazy-derivative f)
(delay (lambda (x)
(/ (- (f (+ x 0.0001)) (f x)) 0.0001))))
(define (force-at lazy-df x)
((force lazy-df) x))
4. PhaseXduce: emmy.mechanics ↔ SRFI-171
;; Phase space evolution as transducer
(ns sicmutils.srfi-bridge.phase-xduce
(:require [emmy.mechanics.hamilton :as ham]))
(defn hamilton-transducer
"Transducer for Hamiltonian evolution."
[H dt]
(fn [rf]
(fn
([] (rf))
([result] (rf result))
([result state]
(rf result (ham/evolve H state dt))))))
;; SRFI-171 transducer for phase evolution
(import (srfi 171))
(define (hamiltonian-xform H dt)
(tmap (lambda (state)
(phase-evolve H state dt))))
;; Compose with other transformations
(define phase-pipeline
(compose
(hamiltonian-xform H 0.01)
(tfilter (lambda (s) (< (energy s) max-energy)))
(ttake 1000)))
GF(3) Conservation Across Boundary
Clojure (SICMUtils) Scheme (SRFI)
═══════════════════ ════════════
emmy.generic [-1] ◄─────► SRFI-1 [-1]
emmy.structure [-1] ◄─────► SRFI-9 [-1]
emmy.expression [ 0] ◄─────► SRFI-27 [ 0]
emmy.calculus [ 0] ◄─────► SRFI-45 [ 0]
emmy.mechanics [+1] ◄─────► SRFI-171 [+1]
Σ Clojure = -1 + -1 + 0 + 0 + 1 = -1
Σ Scheme = -1 + -1 + 0 + 0 + 1 = -1
Bicomodule preserves: Σ_source ≡ Σ_target (mod 3) ✓
Cat# Equipment Structure
┌─────────────────────────────────────────────────────────────┐
│ Cat# = Comod(P) for SICM ↔ SRFI │
├─────────────────────────────────────────────────────────────┤
│ Vertical (Functors): │
│ SICMUtils.Mechanics ────► SRFI.Numeric │
│ SICMUtils.Calculus ────► SRFI.Lazy │
│ │
│ Horizontal (Bicomodules): │
│ ListAlgebra: generic ↛ srfi-1 │
│ RNGBridge: expression ↛ srfi-27 │
│ LazyDiff: calculus ↛ srfi-45 │
│ PhaseXduce: mechanics ↛ srfi-171 │
│ │
│ Equipment: │
│ Companions: SICMUtils modules → SRFI libraries │
│ Conjoints: SRFI libraries → SICMUtils modules │
│ Mates: Natural transformations between functors │
└─────────────────────────────────────────────────────────────┘
Commands
# Run SICMUtils REPL
clj -M:emmy
# Execute Lagrangian example
clj -X emmy.examples/harmonic-oscillator
# Bridge to Scheme
clj -X sicmutils.srfi-bridge/export-to-scheme :format :srfi-171
# Verify SRFI compatibility
clj -M:test -n sicmutils.srfi-bridge-test
# Check GF(3) conservation
bb verify_trit_balance.bb sicmutils srfi
Integration with sicm Skill
| sicm Chapter | SICMUtils Namespace | SRFI Bridge |
|---|---|---|
| Ch1 Lagrangian | emmy.mechanics.lagrange |
SRFI-171 (transducers) |
| Ch2 Rigid Bodies | emmy.mechanics.rotation |
SRFI-9 (records) |
| Ch3 Hamiltonian | emmy.mechanics.hamilton |
SRFI-171 (transducers) |
| Ch4 Phase Space | emmy.numerical.ode |
SRFI-27 (random) |
| Ch5 Canonical | emmy.calculus.form-field |
SRFI-45 (lazy) |
| Ch6 Evolution | emmy.calculus.derivative |
SRFI-45 (lazy) |
| Ch7 Perturbation | emmy.series |
SRFI-41 (streams) |
| App A Scheme | N/A (native Scheme) | All SRFIs |
Trit Assignment
Trit: +1 (PLUS - constructive computation)
Home: Physics/Computation
Poly Op: ◁ (substitution for symbolic manipulation)
Kan Role: Lan (extend computation to new domains)
Color: #FF6B35 (energy orange, matches sicm)
GF(3) Triads
sicm (-1) ⊗ sicmutils (0) ⊗ srfi (+1) = 0 ✓
sicp (-1) ⊗ sicmutils (0) ⊗ emmy (+1) = 0 ✓
calculus (-1) ⊗ sicmutils (0) ⊗ physics (+1) = 0 ✓
References
- Emmy (SICMUtils) - Modern Clojure implementation
- SICM - Sussman & Wisdom textbook
- SRFI - Scheme Requests for Implementation
- scmutils - Original MIT Scheme library
REPL atlas
Part of: repl-commons. Family canonical: sicm.