demo + tests: LLM bootstrap workflow + 10 reverse-autograd extras

examples/demos/llm_bootstrap_workflow.omc:
  End-to-end demo of the canonical "an LLM driving OMC via MCP"
  workflow — surface overview, category listing, OMC-unique
  primitives, builtin lookup, code memory (omc_id, remember,
  recall_matches), change report, error explanation.

test_reverse_autograd_extras.omc (10):
  Chain rule sin(x^2), polynomial 3x^3 + 2x + 1, neg composition,
  exp(2x) via squared exp(x), multi-variable distance squared
  gradients, sigmoid of sum (both partials), tanh at 1, sum
  reduction gradient, substrate metadata visible on tape_value
  for integer leaves AND after operations (8 = Fibonacci attractor
  preserved through tape_add).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

examples/demos/llm_bootstrap_workflow.omc

@@ -0,0 +1,95 @@
+# Demonstrates the canonical LLM bootstrap + iteration workflow.
+#
+# This is what an LLM driving OMC via MCP would do at the start of a
+# session: pull the bootstrap pack, learn the surface, then start
+# writing + iterating with introspection + memory.
+
+fn show(label, v) {
+    print(concat_many(label, " = ", to_string(v)));
+}
+
+fn main() {
+    print("=== LLM bootstrap workflow ===");
+    print("");
+
+    # Step 1: How big is the surface?
+    print("[1] Surface overview");
+    show("  documented builtins  ", omc_builtin_count());
+    show("  OMC-unique           ", omc_unique_count());
+    show("  categories           ", omc_categories_count());
+    show("  error patterns       ", omc_error_count());
+    print("");
+
+    # Step 2: What's available?
+    print("[2] Category sample");
+    h cats = omc_categories();
+    h i = 0;
+    while i < arr_len(cats) {
+        h c = arr_get(cats, i);
+        h items = omc_list_builtins(c);
+        print(concat_many("  ", c, ": ", to_string(arr_len(items)), " builtins"));
+        i = i + 1;
+        if i >= 8 { i = arr_len(cats); }  # limit output
+    }
+    print("");
+
+    # Step 3: What's the canonical OMC-only surface?
+    print("[3] OMC-unique sample (Python has no equivalent)");
+    h unique = omc_unique_builtins();
+    h k = 0;
+    while k < arr_len(unique) {
+        if k < 8 {
+            print(concat_many("  - ", arr_get(unique, k)));
+        }
+        k = k + 1;
+    }
+    if k > 8 { print(concat_many("  ... +", to_string(k - 8), " more")); }
+    print("");
+
+    # Step 4: Help on a specific builtin (the "look it up" loop)
+    print("[4] Looking up arr_softmax");
+    h help = omc_help("arr_softmax");
+    show("  signature  ", dict_get(help, "signature"));
+    show("  description", dict_get(help, "description"));
+    show("  example    ", dict_get(help, "example"));
+    print("");
+
+    # Step 5: Write some code, hash it, remember
+    print("[5] Code memory: remember, then recall");
+    omc_memory_clear();
+    h code_v1 = "fn loss(p, t) { return (p - t) * (p - t); }";
+    h id = omc_id(code_v1);
+    show("  v1 omc_id  ", id);
+    omc_remember("loss", code_v1);
+    h code_v2 = "fn loss(pred, target) { return (pred - target) * (pred - target); }";
+    show("  v2 omc_id  ", omc_id(code_v2));
+    show("  matches?   ", omc_recall_matches("loss", code_v2));  # 1 (alpha-eq)
+    h code_v3 = "fn loss(p, t) { return (p - t) * (p - t) + 0.01; }";
+    show("  v3 omc_id  ", omc_id(code_v3));
+    show("  matches?   ", omc_recall_matches("loss", code_v3));  # 0 (changed)
+    print("");
+
+    # Step 6: Change report
+    print("[6] What changed?");
+    h r = omc_change_report(code_v1, code_v3);
+    show("  modified  ", dict_get(r, "modified"));
+    show("  suggestion", dict_get(r, "suggested_action"));
+    print("");
+
+    # Step 7: If error, explain it
+    print("[7] Catching + explaining a typo");
+    h err_msg = "";
+    try {
+        h _ = arr_softmx([1.0, 2.0]);  # typo
+    } catch e {
+        err_msg = e;
+    }
+    h ex = omc_explain_error(err_msg);
+    show("  matched   ", dict_get(ex, "matched"));
+    show("  fix       ", dict_get(ex, "fix"));
+    print("");
+
+    print("=== End: this is the workflow LLMs run via MCP ===");
+}
+
+main();

examples/tests/test_reverse_autograd_extras.omc

@@ -0,0 +1,133 @@
+# More reverse-mode autograd tests.
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        test_record_failure(msg + ": expected " + to_string(expected) + " got " + to_string(actual));
+    }
+}
+
+fn assert_true(cond, msg) { if !cond { test_record_failure(msg); } }
+
+fn approx_eq(a, b, tol) {
+    h d = a - b;
+    if d < 0.0 { d = 0.0 - d; }
+    return d <= tol;
+}
+
+# Scalar chain: y = sin(x^2)
+fn test_chain_sin_square() {
+    tape_reset();
+    h x = tape_var(1.0);
+    h x2 = tape_mul(x, x);
+    h y = tape_sin(x2);
+    tape_backward(y);
+    # d/dx sin(x^2) = 2x * cos(x^2). At x=1: 2 * cos(1) ≈ 1.0806
+    assert_true(approx_eq(tape_grad(x), 1.0806, 0.001), "chain sin(x^2)");
+}
+
+# Mixed ops
+fn test_polynomial_grad() {
+    tape_reset();
+    h x = tape_var(2.0);
+    # y = x^3 + 2*x + 1
+    h x3 = tape_pow_int(x, 3);
+    h two = tape_const(2.0);
+    h two_x = tape_mul(two, x);
+    h sum_1 = tape_add(x3, two_x);
+    h one = tape_const(1.0);
+    h y = tape_add(sum_1, one);
+    tape_backward(y);
+    # dy/dx = 3x^2 + 2 = 14 at x=2
+    assert_true(approx_eq(tape_grad(x), 14.0, 0.001), "3x^2 + 2 at 2");
+}
+
+# Negation
+fn test_neg_in_chain() {
+    tape_reset();
+    h x = tape_var(5.0);
+    h n = tape_neg(x);  # = -5
+    h y = tape_mul(n, n);  # = 25
+    tape_backward(y);
+    # d(-x*-x)/dx = d(x^2)/dx = 2x = 10
+    assert_true(approx_eq(tape_grad(x), 10.0, 0.001), "(-x)^2 grad");
+}
+
+# Exp chain
+fn test_exp_squared() {
+    tape_reset();
+    h x = tape_var(1.0);
+    h ex = tape_exp(x);
+    h y = tape_mul(ex, ex);  # = exp(2x)
+    tape_backward(y);
+    # d/dx exp(2x) = 2*exp(2x) at x=1 = 2 * e^2 ≈ 14.778
+    assert_true(approx_eq(tape_grad(x), 14.778, 0.01), "d/dx exp(2x)");
+}
+
+# Multi-variable: gradient of distance squared
+fn test_distance_squared_grad() {
+    tape_reset();
+    h x = tape_var(3.0);
+    h y = tape_var(4.0);
+    h x2 = tape_mul(x, x);
+    h y2 = tape_mul(y, y);
+    h d2 = tape_add(x2, y2);
+    tape_backward(d2);
+    # d/dx (x^2 + y^2) = 2x = 6
+    # d/dy = 8
+    assert_true(approx_eq(tape_grad(x), 6.0, 0.001), "dx");
+    assert_true(approx_eq(tape_grad(y), 8.0, 0.001), "dy");
+}
+
+# Sigmoid through addition
+fn test_sigmoid_of_sum() {
+    tape_reset();
+    h a = tape_var(1.0);
+    h b = tape_var(0.0);
+    h s = tape_add(a, b);
+    h y = tape_sigmoid(s);
+    tape_backward(y);
+    # sigmoid(1)*(1-sigmoid(1)) ≈ 0.196
+    assert_true(approx_eq(tape_grad(a), 0.196, 0.01), "dy/da");
+    assert_true(approx_eq(tape_grad(b), 0.196, 0.01), "dy/db");
+}
+
+# Tanh
+fn test_tanh_grad_at_one() {
+    tape_reset();
+    h x = tape_var(1.0);
+    h y = tape_tanh(x);
+    tape_backward(y);
+    # d/dx tanh(x) = 1 - tanh^2(x). tanh(1) ≈ 0.7616, so 1 - 0.5801 ≈ 0.42
+    assert_true(approx_eq(tape_grad(x), 0.42, 0.01), "tanh' at 1");
+}
+
+# tape_sum reduces a vector
+fn test_tape_sum_grad() {
+    tape_reset();
+    h X = tape_var([1.0, 2.0, 3.0]);
+    h s = tape_sum(X);
+    tape_backward(s);
+    h gX = tape_grad(X);
+    # d(sum)/dx_i = 1 for each i
+    assert_true(approx_eq(arr_get(gX, 0), 1.0, 0.001), "g[0]=1");
+    assert_true(approx_eq(arr_get(gX, 2), 1.0, 0.001), "g[2]=1");
+}
+
+# Substrate metadata visible on forward values
+fn test_substrate_visible_forward() {
+    tape_reset();
+    h x = tape_var(8);  # Fibonacci attractor
+    h v = tape_value(x);
+    # Value comes back as substrate-annotated HInt for integers.
+    # We can't introspect HInt fields directly, but is_attractor works.
+    assert_eq(is_attractor(v), 1, "8 attractor preserved");
+}
+
+fn test_substrate_visible_after_op() {
+    tape_reset();
+    h x = tape_var(3);
+    h y = tape_var(5);
+    h s = tape_add(x, y);  # = 8
+    h v = tape_value(s);
+    assert_eq(is_attractor(v), 1, "8 attractor after sum");
+}