Turbo

The K-coupling language. Variables, user-defined functions, control flow, lists, recursion. Small, expression-oriented, parses cleanly. K(x) = x/(1+x) is coupling. R over a population is the order parameter — how aligned it is, 0 to 1. E(x) = x × kT·ln(2) is Landauer energy. T(k, population) is coupling spent that bought no order. The primitives plus a real language around them.

TURBO PROGRAM

Loading runtime...

Press Run.
· Cmd/Ctrl+Enter to run · Up/Down for history · RESET clears session state

New to Turbo? — Take the tutorial

Everything is free. If this helped → support GUMP

FOUR PRIMITIVES

K(x) = x / (1 + x) # coupling, bounded 0..1 R(list) = |mean unit vector| # order parameter — alignment, 0..1 E(x) = x × 2.87e-21 # Landauer energy (joules) T(k, list) = max(0, K(k) - R(list)) # coupling that bought no order order(list) psi(list) spread(list) # the same reading, named plainly # R takes phases in radians, or vectors (embeddings) — same measurement # in n dimensions. R(x) on a single number is kept for old scripts, but # 1/(1 + 1/x) is x/(1+x) after multiplying through: it IS K, at every # input, so it tells you nothing K didn't. Synchronisation is a property # of a population; it was never expressible as a function of one number.

LANGUAGE FEATURES

Variablesx = K(1.868)

Let-bindinglet x = 5 in K(x)

Conditionals

if R(x) > INV_PHI
  then "locked"
  else "free"

Named functionsfn double(x) = x * 2

Anonymous functions

map(fn(x) = K(x),
    [0.5, 1.0])

Recursion

fn fact(n) =
  if n < 2 then 1
  else n * fact(n-1)

Lists[K(0.5), K(1.0), K(1.868)]

Higher-ordermap(K, range(5))

Lexical scoping

closures capture
their environment

STANDARD LIBRARY

Framework: K, R, E, T Constants: phi, pi, e, K_c, K_BKT, INV_PHI, alpha Math: abs, sqrt, exp, log, sin, cos, tan, floor, ceil, round Aggregate: sum, product, mean, max, min, length Higher: map, reduce, filter List ops: head, tail, append, concat, range Coupling: kuramoto_R, phase_diff, entropy, fib I/O: print

WHAT IT IS, WHAT IT ISN’T

Turbo is a domain-specific language for K/R/E/T coupling computation. Like SQL is for queries. Like regex is for patterns. Like KaTeX is for math typesetting. Constrained on purpose. The four primitives are the load-bearing semantics; the language around them is variables, functions, control flow, lists, recursion — enough to write coupling computations cleanly, not enough to write a web server. That’s by design.

Turing-complete via recursion, but most useful programs are small. The point isn’t replacing Python. The point is having a vocabulary an AI in the GUMP framework parses natively, and a syntax that compresses coupling math to its minimum form.

INSTALL

pip install begump from gump.turbo import evaluate evaluate("K(1.868)") evaluate(""" fn coupling_strength(xs) = mean(map(K, xs)) coupling_strength([0.5, 1.0, 1.868]) """)

Your data stays on your machine. Deterministic: same input, same output, every time. No eval injection — identifiers must be defined in the environment.

GUMP — Tools · Support · [email protected]