chore: OpenSSF workflows and compliance updates

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

conformance/valid/v11_add_block.tangle

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# Conformance: add{} block (JTV data injection)
+
+def x = add{ 1 + 2 + 3 }
+assert x == 6

conformance/valid/v12_weave_expr.tangle

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# Conformance: weave as expression (inside def body)
+
+def simple_crossing =
+  weave strands a:Q, b:Q into
+    (a > b)
+  yield strands b:Q, a:Q

conformance/valid/v13_recursive_match.tangle

@@ -0,0 +1,12 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# Conformance: recursive function with pattern matching (Turing completeness)
+
+def length(w) = match w with
+  | identity => 0
+  | s1 . rest => 1 + length(rest)
+  | s2 . rest => 1 + length(rest)
+  | _ => 0
+end
+
+assert length(braid[s1, s1, s1]) == 3
+assert length(identity) == 0

conformance/valid/v14_simplify.tangle

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# Conformance: simplify (Reidemeister moves) and isotopy
+
+assert simplify(braid[s1, s1^-1]) == identity
+assert braid[s1, s1^-1] ~ identity

conformance/valid/v15_tensor.tangle

@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# Conformance: horizontal tensor (|) with index shifting
+
+assert (braid[s1] | braid[s1]) == braid[s1, s3]

conformance/valid/v16_close_mirror_reverse.tangle

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# Conformance: close, mirror, reverse operations
+
+def trefoil = braid[s1, s1, s1]
+
+assert mirror(trefoil) == braid[s1^-1, s1^-1, s1^-1]
+assert reverse(braid[s1, s2]) == braid[s2, s1]
+
+compute writhe(close(trefoil))

editors/tangle.tmLanguage.json

@@ -1,10 +1,12 @@
 {
   "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
   "_comment": "SPDX-License-Identifier: PMPL-1.0-or-later",
+  "_description": "TextMate grammar for TANGLE — Turing-complete topological programming language",
   "name": "Tangle",
   "scopeName": "source.tangle",
   "fileTypes": [
-    "tangle"
+    "tangle",
+    "tgl"
   ],
   "patterns": [
     {
@@ -19,6 +21,9 @@
     {
       "include": "#constants"
     },
+    {
+      "include": "#jtv-blocks"
+    },
     {
       "include": "#keywords"
     },
@@ -42,13 +47,13 @@
     "comments": {
       "patterns": [
         {
-          "name": "comment.line.double-dash.tangle",
-          "match": "--.*$"
+          "name": "comment.line.hash.tangle",
+          "match": "#.*$"
         },
         {
           "name": "comment.block.tangle",
-          "begin": "\\{-",
-          "end": "-\\}",
+          "begin": "\\(\\*",
+          "end": "\\*\\)",
           "patterns": [
             {
               "include": "#comments"
@@ -74,9 +79,17 @@
     },
     "numbers": {
       "patterns": [
+        {
+          "name": "constant.numeric.hex.tangle",
+          "match": "\\b0x[0-9a-fA-F]+\\b"
+        },
+        {
+          "name": "constant.numeric.binary.tangle",
+          "match": "\\b0b[01]+\\b"
+        },
         {
           "name": "constant.numeric.float.tangle",
-          "match": "\\b[0-9]+\\.[0-9]+\\b"
+          "match": "\\b[0-9]+\\.[0-9]+([eE][+-]?[0-9]+)?\\b"
         },
         {
           "name": "constant.numeric.integer.tangle",
@@ -89,6 +102,68 @@
         {
           "name": "constant.language.boolean.tangle",
           "match": "\\b(true|false)\\b"
+        },
+        {
+          "name": "constant.language.identity.tangle",
+          "match": "\\bidentity\\b"
+        }
+      ]
+    },
+    "jtv-blocks": {
+      "patterns": [
+        {
+          "name": "meta.block.add.tangle",
+          "begin": "\\b(add)\\s*(\\{)",
+          "beginCaptures": {
+            "1": { "name": "keyword.control.jtv.tangle" },
+            "2": { "name": "punctuation.definition.block.begin.tangle" }
+          },
+          "end": "\\}",
+          "endCaptures": {
+            "0": { "name": "punctuation.definition.block.end.tangle" }
+          },
+          "patterns": [
+            { "include": "#strings" },
+            { "include": "#numbers" },
+            { "include": "#constants" },
+            { "include": "#identifiers" }
+          ]
+        },
+        {
+          "name": "meta.block.harvard.tangle",
+          "begin": "\\b(harvard)\\s*(\\{)",
+          "beginCaptures": {
+            "1": { "name": "keyword.control.jtv.tangle" },
+            "2": { "name": "punctuation.definition.block.begin.tangle" }
+          },
+          "end": "\\}",
+          "endCaptures": {
+            "0": { "name": "punctuation.definition.block.end.tangle" }
+          },
+          "patterns": [
+            { "include": "#jtv-keywords" },
+            { "include": "#jtv-purity" },
+            { "include": "#strings" },
+            { "include": "#numbers" },
+            { "include": "#constants" },
+            { "include": "#identifiers" }
+          ]
+        }
+      ]
+    },
+    "jtv-keywords": {
+      "patterns": [
+        {
+          "name": "keyword.control.jtv.tangle",
+          "match": "\\b(fn|if|else|while|for|return|print|module|import|as|then|reverse)\\b"
+        }
+      ]
+    },
+    "jtv-purity": {
+      "patterns": [
+        {
+          "name": "storage.modifier.purity.tangle",
+          "match": "@(pure|total)\\b"
         }
       ]
     },
@@ -100,7 +175,7 @@
         },
         {
           "name": "keyword.declaration.tangle",
-          "match": "\\b(def|weave|into|strands|compute|assert|identity)\\b"
+          "match": "\\b(def|weave|into|strands|compute|assert)\\b"
         },
         {
           "name": "keyword.other.topology.tangle",
@@ -134,10 +209,6 @@
           "name": "keyword.operator.pipeline.tangle",
           "match": ">>"
         },
-        {
-          "name": "keyword.operator.crossing.tangle",
-          "match": ">|<"
-        },
         {
           "name": "keyword.operator.isotopy.tangle",
           "match": "~"
@@ -150,6 +221,10 @@
           "name": "keyword.operator.assignment.tangle",
           "match": "="
         },
+        {
+          "name": "keyword.operator.crossing.tangle",
+          "match": "[><]"
+        },
         {
           "name": "keyword.operator.tensor.tangle",
           "match": "\\|"

examples/braids_as_data.tangle

@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# braids_as_data.tangle — Braid words as an algebraic data structure
+#
+# Tangle's most distinctive feature: braid words ARE the data structure.
+# identity = nil, s_i = constructor, `.` = cons, pattern matching = destruct.
+#
+# This means recursive algorithms over braids look like list algorithms,
+# but the data they process has intrinsic topological meaning.
+#
+# Demonstrates:
+#   - Pattern matching on braid structure (D1.3)
+#   - Recursion on Words (D1.3)
+#   - Turing completeness via pattern matching + recursion (D1.24)
+#   - Multiple generator matching
+#   - The Word/Tangle distinction (D1.1)
+
+# --- Count the total number of generators ---
+
+def length(w) = match w with
+  | identity => 0
+  | s1 . rest => 1 + length(rest)
+  | s2 . rest => 1 + length(rest)
+  | s3 . rest => 1 + length(rest)
+  | _ => 0
+end
+
+# --- Count only positive crossings (writhe contribution) ---
+
+def positive_count(w) = match w with
+  | identity => 0
+  | s1 . rest => 1 + positive_count(rest)
+  | s2 . rest => 1 + positive_count(rest)
+  | _ => positive_count(identity)
+end
+
+# --- Check if a word starts with a specific generator ---
+
+def starts_with_s1(w) = match w with
+  | s1 . rest => true
+  | _ => false
+end
+
+# --- Test the recursive functions ---
+
+def three_strand = braid[s1, s2, s1, s2]
+
+assert length(three_strand) == 4
+assert starts_with_s1(three_strand) == true
+assert starts_with_s1(braid[s2]) == false
+assert starts_with_s1(identity) == false
+
+# --- Composition is concatenation ---
+
+def a = braid[s1, s1]
+def b = braid[s2, s2]
+def ab = a . b
+
+assert ab == braid[s1, s1, s2, s2]
+assert length(ab) == 4
+
+# --- Identity is the unit ---
+
+assert identity . a == a
+assert a . identity == a
+
+# --- Simplification cancels adjacent inverses ---
+
+def redundant = braid[s1, s2, s2^-1, s1]
+assert simplify(redundant) == braid[s1, s1]

examples/isotopy.tangle

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# isotopy.tangle — Exploring isotopy equivalence
+#
+# The key insight of TANGLE: two braids can be structurally different
+# (different sequences of generators) but topologically equivalent
+# (same knot/link when closed). The `~` operator checks this.
+#
+# Demonstrates:
+#   - Isotopy equivalence vs structural equality (D1.2)
+#   - Reidemeister moves (D1.16)
+#   - The deep duality between syntax and topology
+
+# --- Reidemeister II: inverse cancellation ---
+
+# s1 followed by s1^-1 is isotopic to doing nothing
+assert braid[s1, s1^-1] ~ identity
+
+# This works at any position in the word
+assert braid[s2, s1, s1^-1, s2] ~ braid[s2, s2]
+
+# But structurally they are NOT equal
+assert braid[s1, s1^-1] == braid[s1, s1^-1]
+
+# --- Far commutativity ---
+# Generators on distant strands can commute: s1 s3 = s3 s1
+# (because |1-3| >= 2)
+
+# s1 and s3 commute, so s1 s3 s1^-1 ~ s3
+assert simplify(braid[s1, s3, s1^-1]) ~ braid[s3]
+
+# --- Self-isotopy ---
+# Every braid is isotopic to itself
+assert braid[s1, s2, s1] ~ braid[s1, s2, s1]
+assert identity ~ identity
+
+# --- Isotopy of closed braids ---
+# The closure of isotopic braids gives the same knot
+assert close(braid[s1, s1^-1]) ~ close(identity)
+
+# --- Pipeline and composition are isotopic ---
+# >> is syntactic sugar for . (D1.20)
+assert (braid[s1] >> braid[s2]) ~ (braid[s1] . braid[s2])

examples/tensor_product.tangle

@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# tensor_product.tangle — Horizontal tensor and multi-strand braids
+#
+# The tensor product (|) places two braids side by side, shifting
+# the second braid's strand indices by the width of the first.
+# This is the monoidal structure of the braid category.
+#
+# Demonstrates:
+#   - Horizontal tensor operator (D1.8)
+#   - Auto-widening on composition (D1.8.5)
+#   - Multi-strand braid construction
+#   - The categorical structure of Tangle
+
+# --- Basic tensor ---
+# braid[s1] acts on strands 1,2 (width 2)
+# Tensoring with another braid[s1] shifts the second to strands 3,4
+
+def crossing_12 = braid[s1]
+def crossing_34 = crossing_12 | crossing_12
+
+# The tensor should produce s1 followed by s3
+# (s1 on strands 1-2, then s1 shifted by 2 = s3 on strands 3-4)
+assert crossing_34 == braid[s1, s3]
+
+# --- Building complex braids via tensor ---
+
+def left = braid[s1, s1]
+def right = braid[s1]
+
+# Left on strands 1-2, right on strands 3-4
+def both = left | right
+assert both == braid[s1, s1, s3]
+
+# --- Composition after tensor ---
+# After tensoring, we can compose vertically to interleave
+
+def interleaved = both . braid[s2]
+assert interleaved == braid[s1, s1, s3, s2]
+
+# --- Tensor width tracking ---
+
+def w2 = braid[s1]
+def w3 = braid[s2]
+
+# w2 has width 2, w3 has width 3
+# Tensor: w3 shifts by width(w2) = 2, so s2 becomes s4
+def tensored = w2 | w3
+assert tensored == braid[s1, s4]
+
+# --- Identity tensor ---
+# identity has width 0, so tensoring with it changes nothing
+
+assert (identity | braid[s1]) == braid[s1]
+assert (braid[s1] | identity) == braid[s1]
+
+# --- Writhe of tensor products ---
+
+compute writhe(crossing_34)
+compute writhe(both)