Eta

A differentiable Lisp

One runtime for symbolic reasoning, logic, differentiation and causal inference.

Eta embeds unification, backtracking, and reverse-mode differentiation directly into the VM. Constraints, macros, neural networks, and causal programs operate on the same execution model, value representation, and garbage collector.

AAD reference

(import std.core std.aad)

;; d₁ = [ln(S/K) + (r + σ²/2)·T] / (σ·√T)
(defun bs-d1 (S K r sigma T)
  (/ (+ (log (/ S K))
        (* (+ r (/ (* sigma sigma) 2)) T))
     (* sigma (sqrt T))))

;; C = S·Φ(d₁) − K·e^{-rT}·Φ(d₂)
(defun bs-call (S K r sigma T)
  (let ((d1 (bs-d1 S K r sigma T))
        (d2 (- (bs-d1 S K r sigma T) (* sigma (sqrt T)))))
    (- (* S (norm-cdf d1))
       (* (* K (exp (* -1 (* r T)))) (norm-cdf d2)))))

;; grad records the forward pass on a tape, then runs one
;; backward sweep — yielding price + all five Greeks at once.
(let* ((res    (grad (lambda (S K r sigma T) (bs-call S K r sigma T))
                     '(100.0 90.0 0.03 0.30 0.5)))
       (price  (car res))
       (greeks (cadr res)))
  (println "Price " price)
  (println "Delta " (vector-ref greeks 0))   ;; ∂C/∂S
  (println "Vega  " (vector-ref greeks 3))   ;; ∂C/∂σ
  (println "Rho   " (vector-ref greeks 2))   ;; ∂C/∂r
  (println "Theta " (vector-ref greeks 4)))  ;; ∂C/∂T

Symbolic · Logic · Neural · CausalLisp.

One runtime for symbolic reasoning, logic, differentiation and causal inference.

Symbolic · Logic · Neural · Causal
Lisp.