init

gentests

test

readme

.github/FUNDING.yml

···
+# These are supported funding model platforms
+
+github: [vic] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: oeiuwq # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/workflows/go.yml

···
+name: Build & Test
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: '1.25'
+
+    - name: Test
+      run: go test -v ./...
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: '1.25'
+
+    - name: Check if `go fmt` and `go mod tidy` make any changes
+      run: |
+        set -x
+        go fmt ./...
+        go mod tidy
+        git diff --exit-code

.tangled/workflows/mirror.yml

···
+when:
+  - event: ["push"]
+    branch: ["*"]
+engine: "nixery"
+clone:
+  skip: true
+dependencies:
+  nixpkgs:
+    - gh
+steps:
+  - name: mirror
+    command: gh -R vic/vic issue comment 3 -b godnet

LICENSE

···
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

···
+# GoD-Net - A Golang implementation of Delta Interaction Nets.

cmd/gentests/helper/reduction.go

···
+package gentests
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/vic/godnet/pkg/deltanet"
+	"github.com/vic/godnet/pkg/lambda"
+)
+
+func CheckLambdaReduction(t *testing.T, testName string, inputStr string, outputStr string) {
+	expectedOutput := strings.TrimSpace(outputStr)
+
+	// Parse expected output
+	expectedTerm, err := lambda.Parse(expectedOutput)
+	if err != nil {
+		t.Fatalf("Parse error for expected output: %v", err)
+	}
+
+	// Instead of round-tripping expected output through DeltaNet (which
+	// loses original free variable names and produces implementation
+	// placeholders), we normalize both expected and actual terms to a
+	// structural, alpha-renamed form and compare those. Normalization
+	// replaces all free variable names with the placeholder "<free>"
+	// and renames bound variables to a canonical sequence x0, x1, ...
+	normalize := func(t lambda.Term) lambda.Term {
+		// mapping from original bound name -> canonical name
+		bindings := make(map[string]string)
+		var idx int
+		var walk func(lambda.Term) lambda.Term
+		walk = func(tt lambda.Term) lambda.Term {
+			switch v := tt.(type) {
+			case lambda.Var:
+				if name, ok := bindings[v.Name]; ok {
+					return lambda.Var{Name: name}
+				}
+				return lambda.Var{Name: "<free>"}
+			case lambda.Abs:
+				canon := fmt.Sprintf("x%d", idx)
+				idx++
+				// shadowing: save old if any
+				old, had := bindings[v.Arg]
+				bindings[v.Arg] = canon
+				body := walk(v.Body)
+				if had {
+					bindings[v.Arg] = old
+				} else {
+					delete(bindings, v.Arg)
+				}
+				return lambda.Abs{Arg: canon, Body: body}
+			case lambda.App:
+				return lambda.App{Fun: walk(v.Fun), Arg: walk(v.Arg)}
+			default:
+				return tt
+			}
+		}
+		return walk(t)
+	}
+
+	// Parse input
+	term, err := lambda.Parse(inputStr)
+	if err != nil {
+		t.Fatalf("Parse error: %v", err)
+	}
+
+	// Convert input to Net
+	net := deltanet.NewNetwork()
+	root, port := lambda.ToDeltaNet(term, net)
+
+	// Connect to output interface
+	output := net.NewVar()
+	net.Link(root, port, output, 0)
+
+	// Reduce
+	start := time.Now()
+	net.ReduceAll()
+	elapsed := time.Since(start)
+
+	// Optionally canonicalize/prune unreachable nodes when the expected
+	// result is a simple free variable. Canonicalization (erasure
+	// canonicalization) is only necessary for tests where the expected
+	// canonical form is a free variable and pruning unreachable subnets
+	// is required to match the intended lambda term.
+	resNode, resPort := net.GetLink(output, 0)
+	if _, ok := expectedTerm.(lambda.Var); ok {
+		net.Canonicalize(resNode, resPort)
+		// refresh root after canonicalization
+		resNode, resPort = net.GetLink(output, 0)
+	}
+
+	// Read back into a Term
+	resNode, resPort = net.GetLink(output, 0)
+	t.Logf("%s: root node before FromDeltaNet: %v id=%d port=%d", testName, resNode.Type(), resNode.ID(), resPort)
+	actualTerm := lambda.FromDeltaNet(net, resNode, resPort)
+
+	// If expected is a simple free variable, collapse any top-level
+	// unused abstractions that canonicalization may have missed. This
+	// ensures cases where an outer binder is unused (should be erased)
+	// are represented as the free value for comparison.
+	if _, ok := expectedTerm.(lambda.Var); ok {
+		// Helper to test if a name occurs in a term
+		var occurs func(name string, t lambda.Term) bool
+		occurs = func(name string, t lambda.Term) bool {
+			switch v := t.(type) {
+			case lambda.Var:
+				return v.Name == name
+			case lambda.Abs:
+				// shadowing: if the inner arg equals name, occurrences inside are shadowed
+				if v.Arg == name {
+					return false
+				}
+				return occurs(name, v.Body)
+			case lambda.App:
+				return occurs(name, v.Fun) || occurs(name, v.Arg)
+			default:
+				return false
+			}
+		}
+
+		// Strip top-level unused abstractions
+		for {
+			ab, ok := actualTerm.(lambda.Abs)
+			if !ok {
+				break
+			}
+			if !occurs(ab.Arg, ab.Body) {
+				actualTerm = ab.Body
+				continue
+			}
+			break
+		}
+	}
+
+	// Normalize both expectedTerm and actualTerm for comparison
+	normExpected := normalize(expectedTerm)
+	normActual := normalize(actualTerm)
+
+	if fmt.Sprintf("%s", normActual) != fmt.Sprintf("%s", normExpected) {
+		t.Errorf("Mismatch in %s:\nInput: %s\nExpected: %s\nActual:   %s", testName, inputStr, fmt.Sprintf("%s", normExpected), fmt.Sprintf("%s", normActual))
+	}
+
+	// Optional: Check stats if stats.nix exists
+	// For now, we just log them
+	stats := net.GetStats()
+	t.Logf("%s: %d reductions in %v", testName, stats.TotalReductions, elapsed)
+}

cmd/gentests/main.go

···
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/vic/godnet/pkg/lambda"
+)
+
+type TestCase struct {
+	Name   string
+	Input  string
+	Output string
+}
+
+const testTemplate = `
+package gentests
+import _ "embed"
+import "testing"
+import "github.com/vic/godnet/cmd/gentests/helper"
+//go:embed input.nix
+var input string
+//go:embed output.nix
+var output string
+func Test_%s_Reduction(t *testing.T) {
+	gentests.CheckLambdaReduction(t, "%s", input, output)
+}
+`
+
+func main() {
+	tests := []TestCase{
+		// Identity
+		{"001_id", "x: x", "y: y"},
+		{"002_id_id", "(x: x) (y: y)", "z: z"},
+
+		// K Combinator (Erasure)
+		{"003_k_1", "(x: y: x) a b", "a"},
+		{"004_k_2", "(x: y: y) a b", "b"},
+		{"005_erase_complex", "(x: y: x) a ((z: z) b)", "a"},
+
+		// S Combinator (Sharing)
+		{"006_s_1", "(x: y: z: x z (y z)) (a: b: a) (c: d: c) e", "e"},
+		{"007_s_2", "(x: y: z: x z (y z)) (a: b: b) (c: d: c) e", "e"},
+
+		// Church Numerals
+		{"010_zero", "(f: x: x) f x", "x"},
+		{"011_one", "(f: x: f x) f x", "f x"},
+		{"012_two", "(f: x: f (f x)) f x", "f (f x)"},
+		{"013_succ_0", "(n: f: x: f (n f x)) (f: x: x) f x", "f x"},
+		{"014_succ_1", "(n: f: x: f (n f x)) (f: x: f x) f x", "f (f x)"},
+		{"015_add_1_1", "(m: n: f: x: m f (n f x)) (f: x: f x) (f: x: f x) f x", "f (f x)"},
+		{"016_mul_2_2", "(m: n: f: m (n f)) (f: x: f (f x)) (f: x: f (f x)) f x", "f (f (f (f x)))"},
+
+		// Logic
+		{"020_true", "(x: y: x) a b", "a"},
+		{"021_false", "(x: y: y) a b", "b"},
+		{"022_not_true", "(b: b (x: y: y) (x: y: x)) (x: y: x) a b", "b"},
+		{"023_not_false", "(b: b (x: y: y) (x: y: x)) (x: y: y) a b", "a"},
+		{"024_and_true_true", "(p: q: p q p) (x: y: x) (x: y: x) a b", "a"},
+		{"025_and_true_false", "(p: q: p q p) (x: y: x) (x: y: y) a b", "b"},
+
+		// Pairs
+		{"030_pair_fst", "(p: p (x: y: x)) ((x: y: f: f x y) a b)", "a"},
+		{"031_pair_snd", "(p: p (x: y: y)) ((x: y: f: f x y) a b)", "b"},
+
+		// Let bindings
+		{"040_let_simple", "let x = a; in x", "a"},
+		{"041_let_id", "let i = x: x; in i a", "a"},
+		{"042_let_nested", "let x = a; in let y = b; in x", "a"},
+		{"043_let_shadow", "let x = a; in let x = b; in x", "b"},
+
+		// Complex / Stress
+		{"050_deep_app", "(x: x x x) (y: y)", "y: y"},
+		{"051_share_app", "(f: f (f x)) (y: y)", "x"},
+
+		{"060_pow_2_3", "(b: e: e b) (f: x: f (f x)) (f: x: f (f (f x))) f x", "f (f (f (f (f (f (f (f x)))))))"},
+
+		// Replicator tests
+		{"070_share_complex", "(x: x (x a)) (y: y)", "a"},
+
+		// Erasure of shared term
+		{"071_erase_shared", "(x: y: y) ((z: z) a) b", "b"},
+
+		// Commutation
+		{"072_self_app", "(x: x x) (y: y)", "y: y"},
+
+		// Nested Lambdas
+		{"080_nested_1", "x: y: z: x y z", "x: y: z: x y z"},
+		{"081_nested_app", "(x: y: x y) a b", "a b"},
+
+		// Free variables
+		{"090_free_1", "x", "x"},
+		{"091_free_app", "x y", "x y"},
+		{"092_free_abs", "y: x y", "y: x y"},
+
+		// Mixed
+		{"100_mixed_1", "(x: x) ((y: y) a)", "a"},
+	}
+
+	baseDir := "cmd/gentests/tests"
+	os.MkdirAll(baseDir, 0755)
+
+	for _, tc := range tests {
+		dir := filepath.Join(baseDir, tc.Name)
+		os.MkdirAll(dir, 0755)
+
+		// Normalize Input
+		inTerm, err := lambda.Parse(tc.Input)
+		if err != nil {
+			fmt.Printf("Error parsing input for %s: %v\n", tc.Name, err)
+			continue
+		}
+
+		// Normalize Output
+		outTerm, err := lambda.Parse(tc.Output)
+		if err != nil {
+			fmt.Printf("Error parsing output for %s: %v\n", tc.Name, err)
+			continue
+		}
+
+		testGo := fmt.Sprintf(testTemplate, tc.Name, tc.Name)
+
+		os.WriteFile(filepath.Join(dir, "input.nix"), []byte(inTerm.String()), 0644)
+		os.WriteFile(filepath.Join(dir, "output.nix"), []byte(outTerm.String()), 0644)
+		os.WriteFile(filepath.Join(dir, "reduction_test.go"), []byte(testGo), 0644)
+	}
+
+	fmt.Printf("Generated %d tests\n", len(tests))
+}
+
+/*
+func church(n int) string {
+	body := "x"
+	for i := 0; i < n; i++ {
+		body = fmt.Sprintf("f (%s)", body)
+	}
+	return fmt.Sprintf("(f: x: %s)", body)
+}
+
+func churchBody(n int) string {
+	body := "x"
+	for i := 0; i < n; i++ {
+		body = fmt.Sprintf("f (%s)", body)
+	}
+	return body
+}
+*/

cmd/godnet/main.go

···
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	"time"
+
+	"github.com/vic/godnet/pkg/deltanet"
+	"github.com/vic/godnet/pkg/lambda"
+)
+
+func main() {
+	var input []byte
+	var err error
+
+	if len(os.Args) > 1 {
+		input, err = os.ReadFile(os.Args[1])
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error reading file: %v\n", err)
+			os.Exit(1)
+		}
+	} else {
+		input, err = io.ReadAll(os.Stdin)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error reading stdin: %v\n", err)
+			os.Exit(1)
+		}
+	}
+
+	term, err := lambda.Parse(string(input))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Parse error: %v\n", err)
+		os.Exit(1)
+	}
+
+	net := deltanet.NewNetwork()
+	root, port := lambda.ToDeltaNet(term, net)
+
+	// Connect root to a dummy interface node to allow reduction at the root
+	output := net.NewVar()
+	net.Link(root, port, output, 0)
+
+	start := time.Now()
+	net.ReduceAll()
+	elapsed := time.Since(start)
+
+	// Read back from the output node
+	resNode, resPort := net.GetLink(output, 0)
+	res := lambda.FromDeltaNet(net, resNode, resPort)
+	fmt.Println(res)
+
+	stats := net.GetStats()
+	fmt.Fprintf(os.Stderr, "\nStats:\n")
+	fmt.Fprintf(os.Stderr, "Time: %v\n", elapsed)
+	fmt.Fprintf(os.Stderr, "Total Reductions: %d\n", stats.TotalReductions)
+	if elapsed.Seconds() > 0 {
+		fmt.Fprintf(os.Stderr, "Reductions/sec: %.2f\n", float64(stats.TotalReductions)/elapsed.Seconds())
+	}
+	fmt.Fprintf(os.Stderr, "Fan Annihilation: %d\n", stats.FanAnnihilation)
+	fmt.Fprintf(os.Stderr, "Replicator Annihilation: %d\n", stats.RepAnnihilation)
+	fmt.Fprintf(os.Stderr, "Replicator Commutation: %d\n", stats.RepCommutation)
+	fmt.Fprintf(os.Stderr, "Fan-Replicator Commutation: %d\n", stats.FanRepCommutation)
+	fmt.Fprintf(os.Stderr, "Erasure: %d\n", stats.Erasure)
+}

go.mod

···
+module github.com/vic/godnet
+
+go 1.25.3

pkg/deltanet/canonical_test.go

···
+package deltanet
+
+import (
+	"testing"
+)
+
+func TestUnpairedReplicatorDecay(t *testing.T) {
+	n := NewNetwork()
+	n.EnableTrace(100)
+
+	// Create a Replicator with 1 aux port, delta 0
+	// This is the identity replicator that should decay
+	rep := n.NewReplicator(0, []int{0})
+
+	// Create two vars to connect
+	v1 := n.NewVar()
+	v2 := n.NewVar()
+
+	// Connect v1 to Rep Principal
+	n.Link(v1, 0, rep, 0)
+	// Connect v2 to Rep Aux 0
+	n.Link(v2, 0, rep, 1)
+
+	// Run Canonicalization (which should trigger decay)
+	// We assume ReduceAll or a specific method handles this.
+	// For now, let's assume we'll add a method for this specific check or it happens during reduction if we trigger it.
+	// Since it's a static rule on a single node, it might need a trigger.
+	// Let's assume we call a new method `ApplyCanonicalRules`.
+	n.ApplyCanonicalRules()
+
+	// Check if Rep is gone and v1 is connected to v2
+	// Wait for async ops
+	n.wg.Wait()
+
+	// Verify connection
+	if !n.IsConnected(v1, 0, v2, 0) {
+		t.Errorf("Replicator did not decay: v1 and v2 are not connected")
+	}
+
+	// Verify trace
+	trace := n.TraceSnapshot()
+	found := false
+	for _, ev := range trace {
+		if ev.Rule == RuleRepDecay {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Errorf("RuleRepDecay not found in trace")
+	}
+}
+
+func TestUnpairedReplicatorMerging(t *testing.T) {
+	n := NewNetwork()
+	n.EnableTrace(100)
+
+	// Create Rep A: Level 0, Deltas [1] (Not identity, won't decay)
+	repA := n.NewReplicator(0, []int{1})
+	// Create Rep B: Level 1, Deltas [-1] (Not identity, won't decay)
+	repB := n.NewReplicator(1, []int{-1})
+
+	// Connect Rep A Aux 0 to Rep B Principal
+	// This satisfies the condition: B is connected to A via aux port.
+	// Level diff: 1 - 0 = 1. Delta of port is 1. 0 + 1 = 1. OK.
+	n.Link(repA, 1, repB, 0)
+
+	// Connect vars to outside
+	v1 := n.NewVar()
+	v2 := n.NewVar()
+	n.Link(v1, 0, repA, 0)
+	n.Link(v2, 0, repB, 1)
+
+	// Trigger merging
+	n.ApplyCanonicalRules()
+	// n.wg.Wait()
+
+	// Expectation: A and B merge into a single Replicator.
+	// v1 should be connected to the new Replicator's Principal
+	// v2 should be connected to the new Replicator's Aux 0
+
+	// Get what v1 is connected to
+	target, _ := n.GetLink(v1, 0)
+	if target == nil {
+		t.Fatalf("v1 is disconnected")
+	}
+	if target.Type() != NodeTypeReplicator {
+		t.Errorf("v1 connected to %v, expected Replicator", target.Type())
+	}
+	if target.ID() == repA.ID() || target.ID() == repB.ID() {
+		// Ideally it's a new node or one of them reused.
+		// If it's one of them, the other should be gone.
+		// Let's check if we have a single path.
+	}
+
+	// Check path v1 -> Rep -> v2
+	// New Rep should have 1 aux port (from Rep B)
+	if len(target.Ports()) < 2 {
+		t.Fatalf("Target replicator has insufficient ports")
+	}
+	target2, _ := n.GetLink(target, 1) // Aux 0
+	if target2 == nil {
+		t.Fatalf("Replicator Aux 0 disconnected")
+	}
+	if target2.ID() != v2.ID() {
+		t.Errorf("Replicator Aux 0 connected to %v, expected v2", target2.ID())
+	}
+
+	// Verify trace
+	trace := n.TraceSnapshot()
+	found := false
+	for _, ev := range trace {
+		if ev.Rule == RuleRepMerge {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Errorf("RuleRepMerge not found in trace")
+	}
+}
+
+func TestPhase2AuxFanReplication(t *testing.T) {
+	n := NewNetwork()
+	n.EnableTrace(100)
+
+	// Setup: Fan connected to Replicator
+	// Fan Principal -> Rep Principal (Active Pair)
+	// This normally triggers Fan-Rep commutation.
+	// In Phase 2, it should trigger Aux Fan Replication.
+
+	fan := n.NewFan()
+	rep := n.NewReplicator(0, []int{0, 0}) // 2 aux ports
+
+	// Connect Fan Principal to Rep Principal
+	n.Link(fan, 0, rep, 0)
+
+	// Connect other ports to vars to keep them alive
+	v1 := n.NewVar(); n.Link(fan, 1, v1, 0)
+	v2 := n.NewVar(); n.Link(fan, 2, v2, 0)
+	v3 := n.NewVar(); n.Link(rep, 1, v3, 0)
+	v4 := n.NewVar(); n.Link(rep, 2, v4, 0)
+
+	// Force Phase 2
+	n.SetPhase(2)
+
+	// Reduce
+	n.ReduceAll()
+
+	// Verify trace
+	trace := n.TraceSnapshot()
+	found := false
+	for _, ev := range trace {
+		if ev.Rule == RuleAuxFanRep {
+			found = true
+			break
+		}
+		if ev.Rule == RuleFanRep {
+			t.Errorf("Found RuleFanRep in Phase 2, expected RuleAuxFanRep")
+		}
+	}
+	if !found {
+		t.Errorf("RuleAuxFanRep not found in trace")
+	}
+}

pkg/deltanet/deltanet.go

···
+package deltanet
+
+import (
+	"fmt"
+	"runtime"
+	"sync"
+	"sync/atomic"
+)
+
+// NodeType identifies the type of agent.
+type NodeType int
+
+const (
+	NodeTypeFan NodeType = iota
+	NodeTypeEraser
+	NodeTypeReplicator
+	NodeTypeVar // Wire/Interface
+)
+
+func (t NodeType) String() string {
+	switch t {
+	case NodeTypeFan:
+		return "Fan"
+	case NodeTypeEraser:
+		return "Eraser"
+	case NodeTypeReplicator:
+		return "Replicator"
+	case NodeTypeVar:
+		return "Var"
+	default:
+		return "Unknown"
+	}
+}
+
+// Node represents an agent in the interaction net.
+type Node interface {
+	Type() NodeType
+	ID() uint64
+	Ports() []*Port
+	// Specific methods for Replicators
+	Level() int
+	Deltas() []int
+}
+
+// Port represents a connection point on a node.
+type Port struct {
+	Node  Node
+	Index int
+	Wire  atomic.Pointer[Wire]
+}
+
+// Wire represents a connection between two ports.
+type Wire struct {
+	P0    atomic.Pointer[Port]
+	P1    atomic.Pointer[Port]
+	depth uint64
+}
+
+// BaseNode contains common fields.
+type BaseNode struct {
+	id    uint64
+	typ   NodeType
+	ports []*Port
+}
+
+func (n *BaseNode) Type() NodeType { return n.typ }
+func (n *BaseNode) ID() uint64     { return n.id }
+func (n *BaseNode) Ports() []*Port { return n.ports }
+func (n *BaseNode) Level() int     { return 0 }
+func (n *BaseNode) Deltas() []int  { return nil }
+
+// ReplicatorNode specific fields.
+type ReplicatorNode struct {
+	BaseNode
+	level  int
+	deltas []int
+}
+
+func (n *ReplicatorNode) Level() int    { return n.level }
+func (n *ReplicatorNode) Deltas() []int { return n.deltas }
+
+// Network manages the graph of nodes and interactions.
+type Network struct {
+	nextID    uint64
+	scheduler *Scheduler
+	wg        sync.WaitGroup
+	workers   int
+	startOnce sync.Once
+
+	// Stats
+	ops uint64 // Total reductions
+
+	// Detailed stats
+	statFanAnn     uint64
+	statRepAnn     uint64
+	statRepComm    uint64
+	statFanRepComm uint64
+	statErasure    uint64
+	statRepDecay   uint64
+	statRepMerge   uint64
+	statAuxFanRep  uint64
+	// Registry of created nodes (used for canonicalization)
+	nodes   map[uint64]Node
+	nodesMu sync.Mutex
+
+	traceBuf []TraceEvent
+	traceCap uint64
+	traceIdx uint64
+	traceOn  uint32
+
+	phase int
+}
+
+// Stats holds reduction statistics.
+type Stats struct {
+	TotalReductions   uint64
+	FanAnnihilation   uint64
+	RepAnnihilation   uint64
+	RepCommutation    uint64
+	FanRepCommutation uint64
+	Erasure           uint64
+	RepDecay          uint64
+	RepMerge          uint64
+	AuxFanRep         uint64
+}
+
+func NewNetwork() *Network {
+	n := &Network{
+		scheduler: NewScheduler(),
+		workers:   runtime.NumCPU(),
+		nodes:     make(map[uint64]Node),
+		phase:     1,
+	}
+	return n
+}
+
+func (n *Network) Start() {
+	n.startOnce.Do(func() {
+		for i := 0; i < n.workers; i++ {
+			go n.worker()
+		}
+	})
+}
+
+// SetPhase sets the reduction phase.
+// func (n *Network) SetPhase(p int) {
+// 	n.phase = p
+// }
+
+
+func (n *Network) GetStats() Stats {
+	return Stats{
+		TotalReductions:   atomic.LoadUint64(&n.ops),
+		FanAnnihilation:   atomic.LoadUint64(&n.statFanAnn),
+		RepAnnihilation:   atomic.LoadUint64(&n.statRepAnn),
+		RepCommutation:    atomic.LoadUint64(&n.statRepComm),
+		FanRepCommutation: atomic.LoadUint64(&n.statFanRepComm),
+		Erasure:           atomic.LoadUint64(&n.statErasure),
+		RepDecay:          atomic.LoadUint64(&n.statRepDecay),
+		RepMerge:          atomic.LoadUint64(&n.statRepMerge),
+		AuxFanRep:         atomic.LoadUint64(&n.statAuxFanRep),
+	}
+}
+
+func (n *Network) nextNodeID() uint64 {
+	return atomic.AddUint64(&n.nextID, 1)
+}
+
+func (n *Network) addNodeInternal(typ NodeType, numPorts int) *BaseNode {
+	id := n.nextNodeID()
+	node := &BaseNode{
+		id:    id,
+		typ:   typ,
+		ports: make([]*Port, numPorts),
+	}
+	for i := 0; i < numPorts; i++ {
+		node.ports[i] = &Port{Node: node, Index: i}
+	}
+	n.nodesMu.Lock()
+	if n.nodes == nil {
+		n.nodes = make(map[uint64]Node)
+	}
+	n.nodes[node.id] = node
+	n.nodesMu.Unlock()
+	return node
+}
+
+func (n *Network) NewFan() Node {
+	return n.addNodeInternal(NodeTypeFan, 3) // 0: Principal, 1: Aux1, 2: Aux2
+}
+
+func (n *Network) NewEraser() Node {
+	return n.addNodeInternal(NodeTypeEraser, 1) // 0: Principal
+}
+
+func (n *Network) NewReplicator(level int, deltas []int) Node {
+	id := n.nextNodeID()
+	numPorts := 1 + len(deltas) // 0: Principal, 1..n: Aux
+	node := &ReplicatorNode{
+		BaseNode: BaseNode{
+			id:    id,
+			typ:   NodeTypeReplicator,
+			ports: make([]*Port, numPorts),
+		},
+		level:  level,
+		deltas: deltas,
+	}
+	for i := 0; i < numPorts; i++ {
+		node.ports[i] = &Port{Node: node, Index: i}
+	}
+	n.nodesMu.Lock()
+	if n.nodes == nil {
+		n.nodes = make(map[uint64]Node)
+	}
+	n.nodes[node.id] = node
+	n.nodesMu.Unlock()
+	return node
+}
+
+func (n *Network) NewVar() Node {
+	node := n.addNodeInternal(NodeTypeVar, 1) // 0: Connection
+	return node
+}
+
+// Canonicalize prunes all nodes not reachable from the given root (node, port).
+// For every unreachable node, all its connected wires are replaced by erasers.
+func (n *Network) Canonicalize(root Node, rootPort int) {
+	if n.nodes == nil {
+		return
+	}
+
+	visited := make(map[uint64]bool)
+	var stack []struct {
+		node Node
+		port int
+	}
+	stack = append(stack, struct {
+		node Node
+		port int
+	}{root, rootPort})
+
+	for len(stack) > 0 {
+		el := stack[len(stack)-1]
+		stack = stack[:len(stack)-1]
+		if el.node == nil {
+			continue
+		}
+		id := el.node.ID()
+		if visited[id] {
+			continue
+		}
+		visited[id] = true
+
+		// Visit all neighbor ports connected to this node
+		for _, p := range el.node.Ports() {
+			w := p.Wire.Load()
+			if w == nil {
+				continue
+			}
+			other := w.Other(p)
+			if other == nil {
+				continue
+			}
+			stack = append(stack, struct {
+				node Node
+				port int
+			}{other.Node, other.Index})
+		}
+	}
+
+	// Snapshot nodes to avoid holding lock while mutating the network
+	n.nodesMu.Lock()
+	nodesSnapshot := make([]Node, 0, len(n.nodes))
+	for _, node := range n.nodes {
+		nodesSnapshot = append(nodesSnapshot, node)
+	}
+	n.nodesMu.Unlock()
+
+	// For every node not visited, replace its connections with erasers
+	for _, node := range nodesSnapshot {
+		id := node.ID()
+		if visited[id] {
+			continue
+		}
+		// (debug) previously printed pruned node info here; removed for cleanliness
+		// For each of the node's ports, if connected, splice an eraser in place
+		for _, p := range node.Ports() {
+			w := p.Wire.Load()
+			if w == nil {
+				continue
+			}
+			// Replace the port in the wire with an eraser principal
+			newEra := n.NewEraser()
+			n.splice(newEra.Ports()[0], p)
+		}
+		n.removeNode(node)
+	}
+}
+
+// Link connects two ports.
+func (n *Network) Link(node1 Node, port1 int, node2 Node, port2 int) {
+	n.LinkAt(node1, port1, node2, port2, 0)
+}
+
+// LinkAt connects two ports with a specified depth.
+func (n *Network) LinkAt(node1 Node, port1 int, node2 Node, port2 int, depth uint64) {
+	p1 := node1.Ports()[port1]
+	p2 := node2.Ports()[port2]
+
+	wire := &Wire{depth: depth}
+	wire.P0.Store(p1)
+	wire.P1.Store(p2)
+
+	p1.Wire.Store(wire)
+	p2.Wire.Store(wire)
+
+	// Check if this forms an active pair
+	if port1 == 0 && port2 == 0 && isActive(node1) && isActive(node2) {
+		n.wg.Add(1)
+		n.scheduler.Push(wire, int(depth))
+	}
+}
+
+func isActive(node Node) bool {
+	return node.Type() != NodeTypeVar
+}
+
+// IsConnected checks if two ports are connected.
+func (n *Network) IsConnected(node1 Node, port1 int, node2 Node, port2 int) bool {
+	p1 := node1.Ports()[port1]
+	w := p1.Wire.Load()
+	if w == nil {
+		return false
+	}
+
+	other := w.Other(p1)
+	return other != nil && other.Node == node2 && other.Index == port2
+}
+
+// GetLink returns the node connected to the given port.
+func (n *Network) GetLink(node Node, port int) (Node, int) {
+	p := node.Ports()[port]
+	w := p.Wire.Load()
+	if w == nil {
+		return nil, -1
+	}
+	other := w.Other(p)
+	if other == nil {
+		return nil, -1
+	}
+	return other.Node, other.Index
+}
+
+func (w *Wire) Other(p *Port) *Port {
+	p0 := w.P0.Load()
+	if p0 == p {
+		return w.P1.Load()
+	}
+	return p0
+}
+
+// ReduceAll reduces the network until no more active pairs exist.
+func (n *Network) ReduceAll() {
+	n.Start()
+	// Wait for all active pairs to be processed
+	n.wg.Wait()
+}
+
+func (n *Network) worker() {
+	for {
+		wire := n.scheduler.Pop()
+		n.reducePair(wire)
+		n.wg.Done()
+	}
+}
+
+func (n *Network) reducePair(w *Wire) {
+	p0 := w.P0.Load()
+	p1 := w.P1.Load()
+
+	if p0 == nil || p1 == nil {
+		return // Already handled?
+	}
+
+	a := p0.Node
+	b := p1.Node
+	depth := w.depth
+
+	// Dispatch based on types
+	atomic.AddUint64(&n.ops, 1)
+	rule := RuleUnknown
+	switch {
+	case a.Type() == b.Type():
+		// Annihilation
+		if a.Type() == NodeTypeReplicator {
+			// Check levels
+			if a.Level() == b.Level() {
+				atomic.AddUint64(&n.statRepAnn, 1)
+				rule = RuleRepRep
+				n.annihilate(a, b)
+			} else {
+				atomic.AddUint64(&n.statRepComm, 1)
+				rule = RuleRepRepComm
+				n.commuteReplicators(a, b, depth)
+			}
+		} else {
+			atomic.AddUint64(&n.statFanAnn, 1)
+			rule = RuleFanFan
+			n.annihilate(a, b)
+		}
+	case a.Type() == NodeTypeEraser || b.Type() == NodeTypeEraser:
+		atomic.AddUint64(&n.statErasure, 1)
+		if a.Type() == NodeTypeEraser {
+			rule = RuleErasure
+			n.erase(a, b)
+		} else {
+			rule = RuleErasure
+			n.erase(b, a)
+		}
+	case (a.Type() == NodeTypeFan && b.Type() == NodeTypeReplicator) || (a.Type() == NodeTypeReplicator && b.Type() == NodeTypeFan):
+		if n.phase == 2 {
+			atomic.AddUint64(&n.statAuxFanRep, 1)
+			rule = RuleAuxFanRep
+			if a.Type() == NodeTypeFan {
+				n.auxFanReplication(a, b, depth)
+			} else {
+				n.auxFanReplication(b, a, depth)
+			}
+		} else {
+			atomic.AddUint64(&n.statFanRepComm, 1)
+			if a.Type() == NodeTypeFan {
+				rule = RuleFanRep
+				n.commuteFanReplicator(a, b, depth)
+			} else {
+				rule = RuleFanRep
+				n.commuteFanReplicator(b, a, depth)
+			}
+		}
+	default:
+		fmt.Printf("Unknown interaction: %v <-> %v\n", a.Type(), b.Type())
+	}
+	n.recordTrace(rule, a, b)
+}
+
+// Helper to connect two ports with a NEW wire
+func (n *Network) connect(p1, p2 *Port, depth uint64) {
+	wire := &Wire{depth: depth}
+	wire.P0.Store(p1)
+	wire.P1.Store(p2)
+	p1.Wire.Store(wire)
+	p2.Wire.Store(wire)
+
+	// Check for new active pair
+	if p1.Index == 0 && p2.Index == 0 && isActive(p1.Node) && isActive(p2.Node) {
+		n.wg.Add(1)
+		n.scheduler.Push(wire, int(depth))
+	}
+}
+
+// Helper to splice a new port into an existing wire.
+// pNew replaces pOld in the wire.
+func (n *Network) splice(pNew, pOld *Port) {
+	w := pOld.Wire.Load()
+	if w == nil {
+		return
+	}
+
+	// Point pNew to w
+	pNew.Wire.Store(w)
+
+	// Update w to point to pNew instead of pOld
+	if w.P0.Load() == pOld {
+		w.P0.Store(pNew)
+	} else {
+		w.P1.Store(pNew)
+	}
+
+	// Clear the old port's Wire pointer so it no longer appears connected.
+	// Leaving pOld.Wire non-nil can make canonicalization traverse through
+	// stale references and incorrectly mark nodes as reachable.
+	pOld.Wire.Store(nil)
+
+	// Check if this forms active pair
+	neighbor := w.Other(pNew)
+	if neighbor != nil && pNew.Index == 0 && neighbor.Index == 0 && isActive(pNew.Node) && isActive(neighbor.Node) {
+		n.wg.Add(1)
+		n.scheduler.Push(w, int(w.depth))
+	}
+}
+
+// Helper to fuse two existing wires (Annihilation)
+func (n *Network) fuse(p1, p2 *Port) {
+	// Retry loop for CAS
+	for {
+		w1 := p1.Wire.Load()
+		w2 := p2.Wire.Load()
+
+		if w1 == nil || w2 == nil {
+			// Should not happen if nodes are connected
+			return
+		}
+
+		neighborP1 := w1.Other(p1)
+		neighborP2 := w2.Other(p2)
+
+		if neighborP1 == nil || neighborP2 == nil {
+			// Disconnected port?
+			return
+		}
+
+		// We want to connect neighborP1 and neighborP2.
+		// We can reuse w1.
+		// We need to update neighborP2 to point to w1.
+
+		// Try to claim neighborP2
+		// fmt.Printf("CAS %p %p %p\n", neighborP2, w2, w1)
+		if neighborP2.Wire.CompareAndSwap(w2, w1) {
+			// Success! Now update w1 to point to neighborP2 instead of p1
+			// We need to replace p1 with neighborP2 in w1
+			if w1.P0.Load() == p1 {
+				w1.P0.Store(neighborP2)
+			} else {
+				w1.P1.Store(neighborP2)
+			}
+
+			// Check if this formed a new active pair
+			if neighborP1.Index == 0 && neighborP2.Index == 0 && isActive(neighborP1.Node) && isActive(neighborP2.Node) {
+				n.wg.Add(1)
+				n.scheduler.Push(w1, int(w1.depth))
+			}
+			return
+		}
+		// CAS failed, neighborP2 moved. Retry.
+		runtime.Gosched()
+	}
+}
+
+func (n *Network) removeNode(node Node) {
+	// No-op in lock-free version (GC handles memory)
+}
+
+func (n *Network) annihilate(a, b Node) {
+	// Link corresponding aux ports
+	count := len(a.Ports())
+	if len(b.Ports()) < count {
+		count = len(b.Ports())
+	}
+
+	for i := 1; i < count; i++ {
+		n.fuse(a.Ports()[i], b.Ports()[i])
+	}
+}
+
+func (n *Network) erase(eraser, victim Node) {
+	for i := 1; i < len(victim.Ports()); i++ {
+		// Create new Eraser
+		newEra := n.NewEraser()
+		// Connect new Eraser (Principal 0) to Victim's neighbor (via Aux i)
+		n.splice(newEra.Ports()[0], victim.Ports()[i])
+	}
+
+	n.removeNode(eraser)
+	n.removeNode(victim)
+}
+
+func (n *Network) commuteFanReplicator(fan, rep Node, depth uint64) {
+	// Create copies
+	r1 := n.createReplicatorCopy(rep)
+	r2 := n.createReplicatorCopy(rep)
+
+	// Connect R1, R2 principal to Fan's neighbors
+	if fan.Ports()[1].Wire.Load() != nil {
+		n.splice(r1.Ports()[0], fan.Ports()[1])
+	}
+	if fan.Ports()[2].Wire.Load() != nil {
+		n.splice(r2.Ports()[0], fan.Ports()[2])
+	}
+
+	// Create Fan copies
+	numRepAux := len(rep.Ports()) - 1
+	for i := 0; i < numRepAux; i++ {
+		f := n.createFanCopy()
+
+		// Connect Fan principal to Rep's neighbor
+		if rep.Ports()[i+1].Wire.Load() != nil {
+			n.splice(f.Ports()[0], rep.Ports()[i+1])
+		}
+
+		// Connect Fan aux to Rep copies aux
+		n.connect(f.Ports()[1], r1.Ports()[i+1], depth)
+		n.connect(f.Ports()[2], r2.Ports()[i+1], depth)
+	}
+
+	n.removeNode(fan)
+	n.removeNode(rep)
+}
+
+func (n *Network) auxFanReplication(fan, rep Node, depth uint64) {
+	// In Phase 2, fans are rotated, so the interaction is structurally standard
+	// but semantically "Aux Fan Replication".
+	n.commuteFanReplicator(fan, rep, depth)
+}
+
+func (n *Network) commuteReplicators(a, b Node, depth uint64) {
+	if a.Level() > b.Level() {
+		n.commuteReplicators(b, a, depth)
+		return
+	}
+
+	// A replicates B
+	// Create N copies of B (B1...BN)
+	numAAux := len(a.Ports()) - 1
+	bCopies := make([]Node, numAAux)
+	for i := 0; i < numAAux; i++ {
+		delta := a.Deltas()[i]
+		bCopy := n.createReplicatorCopyWithLevel(b, b.Level()+delta)
+		bCopies[i] = bCopy
+
+		// Connect B_i principal to A's neighbor
+		if a.Ports()[i+1].Wire.Load() != nil {
+			n.splice(bCopy.Ports()[0], a.Ports()[i+1])
+		}
+	}
+
+	// Create M copies of A (A1...AM)
+	numBAux := len(b.Ports()) - 1
+	aCopies := make([]Node, numBAux)
+	for i := 0; i < numBAux; i++ {
+		aCopy := n.createReplicatorCopy(a)
+		aCopies[i] = aCopy
+
+		// Connect A_i principal to B's neighbor
+		if b.Ports()[i+1].Wire.Load() != nil {
+			n.splice(aCopy.Ports()[0], b.Ports()[i+1])
+		}
+
+		// Connect A_i aux to B copies aux
+		for k := 0; k < len(bCopies); k++ {
+			n.connect(aCopy.Ports()[k+1], bCopies[k].Ports()[i+1], depth)
+		}
+	}
+
+	n.removeNode(a)
+	n.removeNode(b)
+}
+
+func (n *Network) createFanCopy() Node {
+	return n.NewFan()
+}
+
+func (n *Network) createReplicatorCopy(original Node) Node {
+	return n.NewReplicator(original.Level(), original.Deltas())
+}
+
+func (n *Network) createReplicatorCopyWithLevel(original Node, newLevel int) Node {
+	return n.NewReplicator(newLevel, original.Deltas())
+}
+
+func (n *Network) SetPhase(p int) {
+	if p == 2 && n.phase == 1 {
+		n.phase = 2
+		n.rotateAllFans()
+	} else {
+		n.phase = p
+	}
+}
+
+func (n *Network) rotateAllFans() {
+	n.nodesMu.Lock()
+	nodesSnapshot := make([]Node, 0, len(n.nodes))
+	for _, node := range n.nodes {
+		nodesSnapshot = append(nodesSnapshot, node)
+	}
+	n.nodesMu.Unlock()
+
+	for _, node := range nodesSnapshot {
+		if node.Type() == NodeTypeFan {
+			n.rotateFan(node.(*BaseNode)) // Assuming Fan is BaseNode, need to check
+		}
+	}
+}
+
+func (n *Network) rotateFan(fan *BaseNode) {
+	// Rotate ports: P->A2, A1->P, A2->A1
+	// 0 <- 1
+	// 1 <- 2
+	// 2 <- 0
+
+	p0 := fan.ports[0]
+	p1 := fan.ports[1]
+	p2 := fan.ports[2]
+
+	fan.ports[0] = p1
+	fan.ports[1] = p2
+	fan.ports[2] = p0
+
+	fan.ports[0].Index = 0
+	fan.ports[1].Index = 1
+	fan.ports[2].Index = 2
+
+	// Check for active pair on new Principal (p1)
+	if isActive(fan) {
+		w := fan.ports[0].Wire.Load()
+		if w != nil {
+			other := w.Other(fan.ports[0])
+			if other != nil && other.Index == 0 && isActive(other.Node) {
+				n.wg.Add(1)
+				n.scheduler.Push(w, int(w.depth))
+			}
+		}
+	}
+}
+
+// ApplyCanonicalRules applies decay and merge rules to all nodes.
+func (n *Network) ApplyCanonicalRules() {
+	n.nodesMu.Lock()
+	nodes := make([]Node, 0, len(n.nodes))
+	for _, node := range n.nodes {
+		nodes = append(nodes, node)
+	}
+	n.nodesMu.Unlock()
+
+	for _, node := range nodes {
+		// Check if node is still valid (might have been removed by previous rule)
+		if len(node.Ports()) > 0 {
+			p0 := node.Ports()[0]
+			if p0.Wire.Load() == nil {
+				// Disconnected/Removed
+				continue
+			}
+		}
+
+		if node.Type() == NodeTypeReplicator {
+			// Check for Decay
+			if len(node.Ports()) == 2 && node.Deltas()[0] == 0 {
+				n.reduceRepDecay(node)
+				continue
+			}
+			// Check for Merge
+			n.reduceRepMerge(node)
+		}
+	}
+}
+
+func (n *Network) reduceRepMerge(rep Node) {
+	// Check if any aux port is connected to another Replicator's Principal
+	for i := 1; i < len(rep.Ports()); i++ {
+		p := rep.Ports()[i]
+		w := p.Wire.Load()
+		if w == nil {
+			continue
+		}
+		other := w.Other(p)
+		if other == nil {
+			continue
+		}
+
+		// Check if other is Replicator Principal (Index 0)
+		if other.Node.Type() == NodeTypeReplicator && other.Index == 0 {
+			otherRep := other.Node
+
+			// Check compatibility
+			// Level(Other) == Level(Rep) + Delta(Rep)[i-1]
+			delta := rep.Deltas()[i-1]
+			if otherRep.Level() == rep.Level()+delta {
+				n.mergeReplicators(rep, otherRep, i-1)
+				return // Only one merge per pass to avoid complexity
+			}
+		}
+	}
+}
+
+func (n *Network) mergeReplicators(repA, repB Node, auxIndexA int) {
+	// repA Aux[auxIndexA] <-> repB Principal
+
+	// New Deltas
+	newDeltas := make([]int, 0)
+	deltaA := repA.Deltas()[auxIndexA]
+
+	for k, d := range repA.Deltas() {
+		if k == auxIndexA {
+			// Expand with repB deltas
+			for _, dB := range repB.Deltas() {
+				newDeltas = append(newDeltas, deltaA+dB)
+			}
+		} else {
+			newDeltas = append(newDeltas, d)
+		}
+	}
+
+	// Create New Replicator
+	newRep := n.NewReplicator(repA.Level(), newDeltas)
+
+	// Connect Principal
+	// repA Principal neighbor <-> newRep Principal
+	pA0 := repA.Ports()[0]
+	if w := pA0.Wire.Load(); w != nil {
+		// neighbor := w.Other(pA0) // Not needed for splice
+		n.splice(newRep.Ports()[0], pA0)
+	}
+
+	// Connect Aux ports
+	newPortIdx := 1
+	for k := 0; k < len(repA.Deltas()); k++ {
+		if k == auxIndexA {
+			// Connect to repB's aux neighbors
+			for m := 0; m < len(repB.Deltas()); m++ {
+				pB := repB.Ports()[m+1]
+				if w := pB.Wire.Load(); w != nil {
+					n.splice(newRep.Ports()[newPortIdx], pB)
+				}
+				newPortIdx++
+			}
+		} else {
+			// Connect to repA's aux neighbor
+			pA := repA.Ports()[k+1]
+			if w := pA.Wire.Load(); w != nil {
+				n.splice(newRep.Ports()[newPortIdx], pA)
+			}
+			newPortIdx++
+		}
+	}
+
+	n.removeNode(repA)
+	n.removeNode(repB)
+	atomic.AddUint64(&n.statRepMerge, 1)
+	n.recordTrace(RuleRepMerge, repA, repB)
+}
+
+func (n *Network) reduceRepDecay(rep Node) {
+	// Rep(0) <-> A(i)
+	// Rep(1) <-> B(j)
+	// Link A(i) <-> B(j)
+
+	p0 := rep.Ports()[0]
+	p1 := rep.Ports()[1]
+
+	w0 := p0.Wire.Load()
+	w1 := p1.Wire.Load()
+
+	if w0 == nil || w1 == nil {
+		return
+	}
+
+	neighbor0 := w0.Other(p0)
+	neighbor1 := w1.Other(p1)
+
+	if neighbor0 == nil || neighbor1 == nil {
+		return
+	}
+
+	// Create new wire between neighbor0 and neighbor1
+	// We can reuse w0
+
+	// Update neighbor1 to point to w0
+	if neighbor1.Wire.CompareAndSwap(w1, w0) {
+		// Update w0 to point to neighbor1 instead of p0
+		if w0.P0.Load() == p0 {
+			w0.P0.Store(neighbor1)
+		} else {
+			w0.P1.Store(neighbor1)
+		}
+
+		// Check active pair
+		if neighbor0.Index == 0 && neighbor1.Index == 0 && isActive(neighbor0.Node) && isActive(neighbor1.Node) {
+			n.wg.Add(1)
+			n.scheduler.Push(w0, int(w0.depth))
+		}
+
+		n.removeNode(rep)
+		atomic.AddUint64(&n.statRepDecay, 1)
+		n.recordTrace(RuleRepDecay, rep, nil)
+	}
+}

pkg/deltanet/deltanet_test.go

···
+package deltanet
+
+import (
+	"testing"
+)
+
+// TestFanAnnihilation tests Beta-reduction (Fan-Fan interaction).
+func TestFanAnnihilation(t *testing.T) {
+	net := NewNetwork()
+
+	// Create two fans facing each other
+	f1 := net.NewFan()
+	f2 := net.NewFan()
+
+	// Link Principal ports
+	net.Link(f1, 0, f2, 0)
+
+	// Create wires for aux ports
+	in1 := net.NewVar()
+	in2 := net.NewVar()
+	out1 := net.NewVar()
+	out2 := net.NewVar()
+
+	net.Link(f1, 1, in1, 0)
+	net.Link(f1, 2, in2, 0)
+	net.Link(f2, 1, out1, 0)
+	net.Link(f2, 2, out2, 0)
+
+	// Reduce
+	net.ReduceAll()
+
+	// Verify connections: in1 <-> out1, in2 <-> out2
+	if !net.IsConnected(in1, 0, out1, 0) {
+		t.Errorf("Fan annihilation failed: Port 1s not connected")
+	}
+	if !net.IsConnected(in2, 0, out2, 0) {
+		t.Errorf("Fan annihilation failed: Port 2s not connected")
+	}
+}
+
+// TestEraserFanInteraction tests Eraser eating a Fan.
+func TestEraserFanInteraction(t *testing.T) {
+	net := NewNetwork()
+
+	era := net.NewEraser()
+	fan := net.NewFan()
+
+	net.Link(era, 0, fan, 0)
+
+	w1 := net.NewVar()
+	w2 := net.NewVar()
+	net.Link(fan, 1, w1, 0)
+	net.Link(fan, 2, w2, 0)
+
+	net.ReduceAll()
+
+	// w1 and w2 should now be connected to NEW Erasers
+	target1, _ := net.GetLink(w1, 0)
+	if target1 == nil || target1.Type() != NodeTypeEraser {
+		t.Errorf("Port 1 not connected to Eraser, got %v", target1)
+	}
+
+	target2, _ := net.GetLink(w2, 0)
+	if target2 == nil || target2.Type() != NodeTypeEraser {
+		t.Errorf("Port 2 not connected to Eraser, got %v", target2)
+	}
+}
+
+// TestFanReplicatorCommutation tests Fan passing through Replicator.
+func TestFanReplicatorCommutation(t *testing.T) {
+	net := NewNetwork()
+
+	fan := net.NewFan()
+	// Replicator Level 1, 2 aux ports, deltas [0, 0]
+	rep := net.NewReplicator(1, []int{0, 0})
+
+	net.Link(fan, 0, rep, 0)
+
+	// Fan Aux
+	fAux1 := net.NewVar()
+	fAux2 := net.NewVar()
+	net.Link(fan, 1, fAux1, 0)
+	net.Link(fan, 2, fAux2, 0)
+
+	// Rep Aux
+	rAux1 := net.NewVar()
+	rAux2 := net.NewVar()
+	net.Link(rep, 1, rAux1, 0)
+	net.Link(rep, 2, rAux2, 0)
+
+	net.ReduceAll()
+
+	// Expected Topology:
+	// fAux1 connected to Rep(Copy1)
+	// fAux2 connected to Rep(Copy2)
+	// rAux1 connected to Fan(CopyA)
+	// rAux2 connected to Fan(CopyB)
+	// And the internal connections between Rep copies and Fan copies.
+
+	l1, _ := net.GetLink(fAux1, 0)
+	if l1 == nil || l1.Type() != NodeTypeReplicator {
+		t.Errorf("Fan Aux 1 should connect to Replicator, got %v", l1)
+	}
+
+	l2, _ := net.GetLink(fAux2, 0)
+	if l2 == nil || l2.Type() != NodeTypeReplicator {
+		t.Errorf("Fan Aux 2 should connect to Replicator, got %v", l2)
+	}
+
+	l3, _ := net.GetLink(rAux1, 0)
+	if l3 == nil || l3.Type() != NodeTypeFan {
+		t.Errorf("Rep Aux 1 should connect to Fan, got %v", l3)
+	}
+}
+
+// TestReplicatorReplicatorAnnihilation tests two identical replicators annihilating.
+func TestReplicatorReplicatorAnnihilation(t *testing.T) {
+	net := NewNetwork()
+
+	r1 := net.NewReplicator(5, []int{1, 2})
+	r2 := net.NewReplicator(5, []int{1, 2})
+
+	net.Link(r1, 0, r2, 0)
+
+	in1 := net.NewVar()
+	in2 := net.NewVar()
+	out1 := net.NewVar()
+	out2 := net.NewVar()
+
+	net.Link(r1, 1, in1, 0)
+	net.Link(r1, 2, in2, 0)
+	net.Link(r2, 1, out1, 0)
+	net.Link(r2, 2, out2, 0)
+
+	net.ReduceAll()
+
+	if !net.IsConnected(in1, 0, out1, 0) {
+		t.Errorf("Rep annihilation failed: Port 1s not connected")
+	}
+	if !net.IsConnected(in2, 0, out2, 0) {
+		t.Errorf("Rep annihilation failed: Port 2s not connected")
+	}
+}
+
+// TestReplicatorReplicatorCommutation tests two replicators with different levels commuting.
+func TestReplicatorReplicatorCommutation(t *testing.T) {
+	net := NewNetwork()
+
+	// R1 (Level 1) <-> R2 (Level 2)
+	r1 := net.NewReplicator(1, []int{0}) // 1 aux port
+	r2 := net.NewReplicator(2, []int{0}) // 1 aux port
+
+	net.Link(r1, 0, r2, 0)
+
+	in := net.NewVar()
+	out := net.NewVar()
+
+	net.Link(r1, 1, in, 0)
+	net.Link(r2, 1, out, 0)
+
+	net.ReduceAll()
+
+	// Result:
+	// R1 replicates R2 -> R2 copies connected to R1 neighbors.
+	// R2 replicates R1 -> R1 copies connected to R2 neighbors.
+	// Since both have 1 aux port:
+	// in -> R2_copy -> R1_copy -> out
+	// Wait, let's trace.
+	// R1 (Level 1) <-> R2 (Level 2).
+	// R1 replicates R2.
+	// R1 has 1 aux port (connected to 'in').
+	// So we create 1 copy of R2 (R2').
+	// R2' principal connects to 'in'.
+	// R2 replicates R1.
+	// R2 has 1 aux port (connected to 'out').
+	// So we create 1 copy of R1 (R1').
+	// R1' principal connects to 'out'.
+	// Internal connection: R1' aux connects to R2' aux.
+
+	// So: in <-> R2'(0). R2'(1) <-> R1'(1). R1'(0) <-> out.
+
+	l1, _ := net.GetLink(in, 0)
+	if l1 == nil || l1.Type() != NodeTypeReplicator || l1.Level() != 2 {
+		t.Errorf("Input should connect to Replicator Level 2, got %v", l1)
+	}
+
+	l2, _ := net.GetLink(out, 0)
+	if l2 == nil || l2.Type() != NodeTypeReplicator || l2.Level() != 1 {
+		t.Errorf("Output should connect to Replicator Level 1, got %v", l2)
+	}
+}
+
+// TestEraserEraserInteraction tests Eraser annihilating Eraser.
+func TestEraserEraserInteraction(t *testing.T) {
+	net := NewNetwork()
+	e1 := net.NewEraser()
+	e2 := net.NewEraser()
+	net.Link(e1, 0, e2, 0)
+	net.ReduceAll()
+	// Success if no hang/crash.
+}
+
+// TestEraserReplicatorInteraction tests Eraser erasing a Replicator.
+func TestEraserReplicatorInteraction(t *testing.T) {
+	net := NewNetwork()
+	e := net.NewEraser()
+	r := net.NewReplicator(0, []int{0, 0}) // 2 aux ports
+	net.Link(e, 0, r, 0)
+
+	v1 := net.NewVar()
+	v2 := net.NewVar()
+	net.Link(r, 1, v1, 0)
+	net.Link(r, 2, v2, 0)
+
+	net.ReduceAll()
+
+	verifyEraserConnection(t, net, v1)
+	verifyEraserConnection(t, net, v2)
+}
+
+// TestReplicatorEraserInteraction tests Replicator being erased by Eraser (Symmetric).
+func TestReplicatorEraserInteraction(t *testing.T) {
+	net := NewNetwork()
+	r := net.NewReplicator(0, []int{0})
+	e := net.NewEraser()
+	net.Link(r, 0, e, 0)
+
+	v1 := net.NewVar()
+	net.Link(r, 1, v1, 0)
+
+	net.ReduceAll()
+
+	verifyEraserConnection(t, net, v1)
+}
+
+// TestFanEraserInteraction tests Fan being erased by Eraser (Symmetric).
+func TestFanEraserInteraction(t *testing.T) {
+	net := NewNetwork()
+	f := net.NewFan()
+	e := net.NewEraser()
+	net.Link(f, 0, e, 0)
+
+	v1 := net.NewVar()
+	v2 := net.NewVar()
+	net.Link(f, 1, v1, 0)
+	net.Link(f, 2, v2, 0)
+
+	net.ReduceAll()
+
+	verifyEraserConnection(t, net, v1)
+	verifyEraserConnection(t, net, v2)
+}
+
+// TestReplicatorFanInteraction tests Replicator commuting with Fan (Symmetric).
+func TestReplicatorFanInteraction(t *testing.T) {
+	net := NewNetwork()
+	rep := net.NewReplicator(1, []int{0, 0})
+	fan := net.NewFan()
+
+	net.Link(rep, 0, fan, 0)
+
+	rAux1 := net.NewVar()
+	rAux2 := net.NewVar()
+	net.Link(rep, 1, rAux1, 0)
+	net.Link(rep, 2, rAux2, 0)
+
+	fAux1 := net.NewVar()
+	fAux2 := net.NewVar()
+	net.Link(fan, 1, fAux1, 0)
+	net.Link(fan, 2, fAux2, 0)
+
+	net.ReduceAll()
+
+	// Check topology:
+	// rAux1 -> Fan
+	// rAux2 -> Fan
+	// fAux1 -> Rep
+	// fAux2 -> Rep
+
+	l1, _ := net.GetLink(rAux1, 0)
+	if l1 == nil || l1.Type() != NodeTypeFan {
+		t.Errorf("Rep Aux 1 should connect to Fan, got %v", l1)
+	}
+
+	l2, _ := net.GetLink(fAux1, 0)
+	if l2 == nil || l2.Type() != NodeTypeReplicator {
+		t.Errorf("Fan Aux 1 should connect to Replicator, got %v", l2)
+	}
+}
+
+// TestComplexNormalization tests that new active pairs are handled correctly.
+func TestComplexNormalization(t *testing.T) {
+	net := NewNetwork()
+	// Setup: F1(0) <-> R(0). R(1) <-> F2(0).
+	// F1 >< R reduces first.
+	// This creates a copy of F1 (F1') connected to R's neighbor at port 1 (F2).
+	// So F1'(0) <-> F2(0) becomes active.
+	// Then F1' >< F2 reduces (Fan-Fan annihilation).
+
+	f1 := net.NewFan()
+	r := net.NewReplicator(0, []int{0, 0})
+	f2 := net.NewFan()
+
+	net.Link(f1, 0, r, 0)
+	net.Link(r, 1, f2, 0)
+
+	// Aux ports
+	v1 := net.NewVar()
+	v2 := net.NewVar()
+	net.Link(f1, 1, v1, 0)
+	net.Link(f1, 2, v2, 0)
+
+	v3 := net.NewVar()
+	net.Link(r, 2, v3, 0)
+
+	v4 := net.NewVar()
+	v5 := net.NewVar()
+	net.Link(f2, 1, v4, 0)
+	net.Link(f2, 2, v5, 0)
+
+	net.ReduceAll()
+
+	// If successful, we should see connections between the vars.
+	// F1 >< R:
+	// R copies F1. R_copy1 connects to v1, R_copy2 connects to v2.
+	// F1 copies R. F1_copy1 connects to F2(0). F1_copy2 connects to v3.
+	//
+	// F1_copy1 >< F2:
+	// F1_copy1 is a Fan. F2 is a Fan.
+	// Annihilation.
+	// F1_copy1 aux ports connect to F2 aux ports.
+	// F1_copy1 aux ports come from R copies?
+	// Wait.
+	// F1 >< R:
+	// F1 has aux v1, v2.
+	// R has aux F2, v3.
+	//
+	// R copies F1 (R_v1, R_v2).
+	// R_v1 principal -> v1. Aux -> F1 copies aux 1.
+	// R_v2 principal -> v2. Aux -> F1 copies aux 2.
+	//
+	// F1 copies R (F1_F2, F1_v3).
+	// F1_F2 principal -> F2. Aux 1 -> R_v1 aux 1. Aux 2 -> R_v2 aux 1.
+	// F1_v3 principal -> v3. Aux 1 -> R_v1 aux 2. Aux 2 -> R_v2 aux 2.
+	//
+	// Now F1_F2 >< F2 (Fan >< Fan).
+	// F1_F2 aux 1 (connected to R_v1 aux 1) connects to F2 aux 1 (v4).
+	// F1_F2 aux 2 (connected to R_v2 aux 1) connects to F2 aux 2 (v5).
+	//
+	// So:
+	// R_v1 aux 1 <-> v4.
+	// R_v2 aux 1 <-> v5.
+	//
+	// R_v1 is a Replicator copy. Principal -> v1.
+	// R_v2 is a Replicator copy. Principal -> v2.
+	//
+	// So we have:
+	// v1 <-> R_v1(0). R_v1(1) <-> v4. R_v1(2) <-> ... (connected to F1_v3 aux 1)
+	// v2 <-> R_v2(0). R_v2(1) <-> v5. R_v2(2) <-> ... (connected to F1_v3 aux 2)
+	//
+	// F1_v3 is a Fan copy. Principal -> v3.
+	// F1_v3(1) <-> R_v1(2).
+	// F1_v3(2) <-> R_v2(2).
+	//
+	// Topology check:
+	// v1 should be connected to a Replicator.
+	// That Replicator's port 1 should be connected to v4.
+	// That Replicator's port 2 should be connected to a Fan (F1_v3).
+	// That Fan's principal should be connected to v3.
+
+	l, _ := net.GetLink(v1, 0)
+	if l == nil || l.Type() != NodeTypeReplicator {
+		t.Errorf("v1 should connect to Replicator, got %v", l)
+		return
+	}
+	// Check l's port 1
+	l_p1, _ := net.GetLink(l, 1)
+	// l_p1 should be v4 (which is a Var, so we check if it IS v4's node)
+	// But v4 is a Var node.
+	// Wait, GetLink returns the Node.
+	if l_p1 != v4 {
+		t.Errorf("v1's Replicator port 1 should connect to v4, got %v", l_p1)
+	}
+}
+
+// TestReplicatorDeltaShift verifies that Replicator commutation correctly shifts levels by delta.
+func TestReplicatorDeltaShift(t *testing.T) {
+	net := NewNetwork()
+
+	// R1: Level 10, Delta [5]
+	r1 := net.NewReplicator(10, []int{5})
+	// R2: Level 20, Delta [0]
+	r2 := net.NewReplicator(20, []int{0})
+
+	// Connect R1 >< R2
+	net.Link(r1, 0, r2, 0)
+
+	// Aux ports
+	in := net.NewVar()
+	out := net.NewVar()
+	net.Link(r1, 1, in, 0)
+	net.Link(r2, 1, out, 0)
+
+	net.ReduceAll()
+
+	// R1 (Level 10) < R2 (Level 20).
+	// R1 replicates R2.
+	// R2 copy level = R2.Level + R1.Delta = 20 + 5 = 25.
+	// R2 copy connects to 'in' (R1's neighbor).
+	
+	// R2 replicates R1.
+	// R1 copy level = R1.Level = 10.
+	// R1 copy connects to 'out' (R2's neighbor).
+
+	// Check 'in' connection
+	l1, _ := net.GetLink(in, 0)
+	if l1 == nil {
+		t.Fatal("in not connected")
+	}
+	if l1.Type() != NodeTypeReplicator {
+		t.Errorf("in should connect to Replicator, got %v", l1.Type())
+	}
+	if l1.Level() != 25 {
+		t.Errorf("Expected R2 copy level to be 25 (20+5), got %d", l1.Level())
+	}
+
+	// Check 'out' connection
+	l2, _ := net.GetLink(out, 0)
+	if l2 == nil {
+		t.Fatal("out not connected")
+	}
+	if l2.Type() != NodeTypeReplicator {
+		t.Errorf("out should connect to Replicator, got %v", l2.Type())
+	}
+	if l2.Level() != 10 {
+		t.Errorf("Expected R1 copy level to be 10, got %d", l2.Level())
+	}
+}
+
+// TestReplicatorMultiDelta verifies that Replicator commutation handles multiple deltas correctly.
+func TestReplicatorMultiDelta(t *testing.T) {
+	net := NewNetwork()
+	
+	// R1: Level 10, Deltas [5, 10]
+	r1 := net.NewReplicator(10, []int{5, 10})
+	// R2: Level 20, Deltas [0]
+	r2 := net.NewReplicator(20, []int{0})
+	
+	net.Link(r1, 0, r2, 0)
+	
+	// R1 aux
+	in1 := net.NewVar()
+	in2 := net.NewVar()
+	net.Link(r1, 1, in1, 0)
+	net.Link(r1, 2, in2, 0)
+	
+	// R2 aux
+	out := net.NewVar()
+	net.Link(r2, 1, out, 0)
+	
+	net.ReduceAll()
+	
+	// Check in1 -> R2 copy with level 25
+	l1, _ := net.GetLink(in1, 0)
+	if l1 == nil || l1.Type() != NodeTypeReplicator {
+		t.Errorf("in1 should connect to Replicator")
+	} else if l1.Level() != 25 {
+		t.Errorf("in1 Replicator level: expected 25, got %d", l1.Level())
+	}
+	
+	// Check in2 -> R2 copy with level 30
+	l2, _ := net.GetLink(in2, 0)
+	if l2 == nil || l2.Type() != NodeTypeReplicator {
+		t.Errorf("in2 should connect to Replicator")
+	} else if l2.Level() != 30 {
+		t.Errorf("in2 Replicator level: expected 30, got %d", l2.Level())
+	}
+}
+
+// TestEraserPropagation verifies that an Eraser recursively destroys a structure.
+func TestEraserPropagation(t *testing.T) {
+	net := NewNetwork()
+	
+	// E >< F1
+	//      | \
+	//      F2 F3
+	
+	e := net.NewEraser()
+	f1 := net.NewFan()
+	f2 := net.NewFan()
+	f3 := net.NewFan()
+	
+	net.Link(e, 0, f1, 0)
+	net.Link(f1, 1, f2, 0)
+	net.Link(f1, 2, f3, 0)
+	
+	// Vars at the leaves
+	v1 := net.NewVar()
+	v2 := net.NewVar()
+	v3 := net.NewVar()
+	v4 := net.NewVar()
+	
+	net.Link(f2, 1, v1, 0)
+	net.Link(f2, 2, v2, 0)
+	net.Link(f3, 1, v3, 0)
+	net.Link(f3, 2, v4, 0)
+	
+	net.ReduceAll()
+	
+	// All vars should be connected to Erasers
+	verifyEraserConnection(t, net, v1)
+	verifyEraserConnection(t, net, v2)
+	verifyEraserConnection(t, net, v3)
+	verifyEraserConnection(t, net, v4)
+}
+
+func verifyEraserConnection(t *testing.T, net *Network, n Node) {
+	l, _ := net.GetLink(n, 0)
+	if l == nil || l.Type() != NodeTypeEraser {
+		t.Errorf("Node should be connected to Eraser, got %v", l)
+	}
+}

pkg/deltanet/lmo_helpers_test.go

···
+package deltanet
+
+import "testing"
+
+func newFanWithSinks(net *Network) Node {
+	fan := net.NewFan()
+	net.Link(fan, 1, net.NewVar(), 0)
+	net.Link(fan, 2, net.NewVar(), 0)
+	return fan
+}
+
+func newReplicatorWithSinks(net *Network, level int, deltas []int) Node {
+	rep := net.NewReplicator(level, deltas)
+	for i := 1; i < len(rep.Ports()); i++ {
+		net.Link(rep, i, net.NewVar(), 0)
+	}
+	return rep
+}
+
+func newEraserWithFanSink(net *Network) (Node, Node) {
+	eras := net.NewEraser()
+	fan := newFanWithSinks(net)
+	net.Link(eras, 0, fan, 0)
+	return eras, fan
+}
+
+func tracedNet(capacity int) *Network {
+	n := NewNetwork()
+	n.EnableTrace(capacity)
+	n.workers = 1 // Force sequential execution for deterministic order tests
+	return n
+}
+
+func firstTraceEvent(t *testing.T, net *Network) TraceEvent {
+	t.Helper()
+	events := net.TraceSnapshot()
+	if len(events) == 0 {
+		t.Fatalf("expected at least one trace event")
+	}
+	return events[0]
+}
+
+func assertEventMatchesPair(t *testing.T, ev TraceEvent, aID, bID uint64) {
+	t.Helper()
+	if !((ev.AID == aID && ev.BID == bID) || (ev.AID == bID && ev.BID == aID)) {
+		t.Fatalf("event pair mismatch: got (%d,%d) want ids %d and %d", ev.AID, ev.BID, aID, bID)
+	}
+}

pkg/deltanet/lmo_order_test.go

···
+package deltanet
+
+import "testing"
+
+func TestLeftmostPrefersRootFanFan(t *testing.T) {
+	traceNet := tracedNet(8)
+
+	innerLeft := newFanWithSinks(traceNet)
+	innerRight := newFanWithSinks(traceNet)
+	traceNet.LinkAt(innerLeft, 0, innerRight, 0, 1)
+
+	rootLeft := newFanWithSinks(traceNet)
+	rootRight := newFanWithSinks(traceNet)
+	traceNet.Link(rootLeft, 0, rootRight, 0)
+
+	traceNet.Start()
+	traceNet.ReduceAll()
+	event := firstTraceEvent(t, traceNet)
+	if event.Rule != RuleFanFan {
+		t.Fatalf("expected fan-fan rule, got %v", event.Rule)
+	}
+	assertEventMatchesPair(t, event, rootLeft.ID(), rootRight.ID())
+}
+
+func TestLeftmostPrefersRootFanRep(t *testing.T) {
+	traceNet := tracedNet(8)
+
+	innerRep := newReplicatorWithSinks(traceNet, 0, []int{0})
+	innerFan := newFanWithSinks(traceNet)
+	traceNet.LinkAt(innerRep, 0, innerFan, 0, 1)
+
+	rootFan := newFanWithSinks(traceNet)
+	rootRep := newReplicatorWithSinks(traceNet, 1, []int{0, 0})
+	traceNet.Link(rootFan, 0, rootRep, 0)
+
+	traceNet.Start()
+	traceNet.ReduceAll()
+	event := firstTraceEvent(t, traceNet)
+	if event.Rule != RuleFanRep {
+		t.Fatalf("expected fan-rep rule, got %v", event.Rule)
+	}
+	assertEventMatchesPair(t, event, rootFan.ID(), rootRep.ID())
+}
+
+func TestLeftmostPrefersRootEraserFan(t *testing.T) {
+	traceNet := tracedNet(8)
+
+	// Inner pair: Fan-Fan
+	innerLeft := newFanWithSinks(traceNet)
+	innerRight := newFanWithSinks(traceNet)
+	traceNet.LinkAt(innerLeft, 0, innerRight, 0, 1)
+
+	// Root pair: Eraser-Fan
+	rootEraser := traceNet.NewEraser()
+	rootFan := newFanWithSinks(traceNet)
+	traceNet.Link(rootEraser, 0, rootFan, 0)
+
+	traceNet.Start()
+	traceNet.ReduceAll()
+	event := firstTraceEvent(t, traceNet)
+	if event.Rule != RuleErasure {
+		t.Fatalf("expected erasure rule, got %v", event.Rule)
+	}
+	assertEventMatchesPair(t, event, rootEraser.ID(), rootFan.ID())
+}
+
+func TestLeftmostPrefersRootEraserRep(t *testing.T) {
+	traceNet := tracedNet(8)
+
+	// Inner pair: Fan-Fan
+	innerLeft := newFanWithSinks(traceNet)
+	innerRight := newFanWithSinks(traceNet)
+	traceNet.LinkAt(innerLeft, 0, innerRight, 0, 1)
+
+	// Root pair: Eraser-Replicator
+	rootEraser := traceNet.NewEraser()
+	rootRep := newReplicatorWithSinks(traceNet, 1, []int{0, 0})
+	traceNet.Link(rootEraser, 0, rootRep, 0)
+
+	traceNet.Start()
+	traceNet.ReduceAll()
+	event := firstTraceEvent(t, traceNet)
+	if event.Rule != RuleErasure {
+		t.Fatalf("expected erasure rule, got %v", event.Rule)
+	}
+	assertEventMatchesPair(t, event, rootEraser.ID(), rootRep.ID())
+}
+
+func TestLeftmostPrefersRootRepRep(t *testing.T) {
+	traceNet := tracedNet(8)
+
+	// Inner pair: Fan-Fan
+	innerLeft := newFanWithSinks(traceNet)
+	innerRight := newFanWithSinks(traceNet)
+	traceNet.LinkAt(innerLeft, 0, innerRight, 0, 1)
+
+	// Root pair: Rep-Rep (Annihilation)
+	rootRep1 := newReplicatorWithSinks(traceNet, 1, []int{0, 0})
+	rootRep2 := newReplicatorWithSinks(traceNet, 1, []int{0, 0})
+	traceNet.Link(rootRep1, 0, rootRep2, 0)
+
+	traceNet.Start()
+	traceNet.ReduceAll()
+	event := firstTraceEvent(t, traceNet)
+	if event.Rule != RuleRepRep {
+		t.Fatalf("expected rep-rep rule, got %v", event.Rule)
+	}
+	assertEventMatchesPair(t, event, rootRep1.ID(), rootRep2.ID())
+}
+
+func TestLeftmostPrefersRootRepRepComm(t *testing.T) {
+	traceNet := tracedNet(8)
+
+	// Inner pair: Fan-Fan
+	innerLeft := newFanWithSinks(traceNet)
+	innerRight := newFanWithSinks(traceNet)
+	traceNet.LinkAt(innerLeft, 0, innerRight, 0, 1)
+
+	// Root pair: Rep-Rep (Commutation, different levels)
+	rootRep1 := newReplicatorWithSinks(traceNet, 1, []int{0, 0})
+	rootRep2 := newReplicatorWithSinks(traceNet, 2, []int{0, 0})
+	traceNet.Link(rootRep1, 0, rootRep2, 0)
+
+	traceNet.Start()
+	traceNet.ReduceAll()
+	event := firstTraceEvent(t, traceNet)
+	if event.Rule != RuleRepRepComm {
+		t.Fatalf("expected rep-rep-comm rule, got %v", event.Rule)
+	}
+	assertEventMatchesPair(t, event, rootRep1.ID(), rootRep2.ID())
+}

pkg/deltanet/scheduler.go

···
+package deltanet
+
+const MaxPriority = 64
+
+type Scheduler struct {
+	queues [MaxPriority]chan *Wire
+	signal chan struct{}
+}
+
+func NewScheduler() *Scheduler {
+	s := &Scheduler{
+		signal: make(chan struct{}, 10000),
+	}
+	for i := range s.queues {
+		s.queues[i] = make(chan *Wire, 1024)
+	}
+	return s
+}
+
+func (s *Scheduler) Push(w *Wire, depth int) {
+	if depth < 0 {
+		depth = 0
+	}
+	if depth >= MaxPriority {
+		depth = MaxPriority - 1
+	}
+	s.queues[depth] <- w
+	select {
+	case s.signal <- struct{}{}:
+	default:
+		// Signal buffer full, workers should be busy enough
+	}
+}
+
+func (s *Scheduler) Pop() *Wire {
+	for {
+		// Scan for highest priority (lowest depth index)
+		for i := 0; i < MaxPriority; i++ {
+			select {
+			case w := <-s.queues[i]:
+				return w
+			default:
+				continue
+			}
+		}
+		// No work found, wait for signal
+		<-s.signal
+	}
+}

pkg/deltanet/trace.go

···
+package deltanet
+
+import "sync/atomic"
+
+type RuleKind int
+
+const (
+	RuleUnknown RuleKind = iota
+	RuleFanFan
+	RuleRepRep
+	RuleRepRepComm
+	RuleFanRep
+	RuleErasure
+	RuleRepDecay
+	RuleRepMerge
+	RuleAuxFanRep
+)
+
+type TraceEvent struct {
+	Step  uint64
+	Rule  RuleKind
+	AType NodeType
+	AID   uint64
+	BType NodeType
+	BID   uint64
+}
+
+func (n *Network) EnableTrace(capacity int) {
+	if capacity <= 0 {
+		capacity = 1
+	}
+	n.traceBuf = make([]TraceEvent, capacity)
+	n.traceCap = uint64(capacity)
+	atomic.StoreUint64(&n.traceIdx, 0)
+	atomic.StoreUint32(&n.traceOn, 1)
+}
+
+func (n *Network) DisableTrace() {
+	atomic.StoreUint32(&n.traceOn, 0)
+}
+
+func (n *Network) TraceSnapshot() []TraceEvent {
+	if atomic.LoadUint32(&n.traceOn) == 0 {
+		return nil
+	}
+	count := atomic.LoadUint64(&n.traceIdx)
+	if count > n.traceCap {
+		count = n.traceCap
+	}
+	res := make([]TraceEvent, count)
+	copy(res, n.traceBuf[:count])
+	return res
+}
+
+func (n *Network) recordTrace(rule RuleKind, a, b Node) {
+	if atomic.LoadUint32(&n.traceOn) == 0 || n.traceCap == 0 {
+		return
+	}
+	idx := atomic.AddUint64(&n.traceIdx, 1) - 1
+	if idx >= n.traceCap {
+		return
+	}
+	var bType NodeType
+	var bID uint64
+	if b != nil {
+		bType = b.Type()
+		bID = b.ID()
+	}
+	n.traceBuf[idx] = TraceEvent{
+		Step:  idx,
+		Rule:  rule,
+		AType: a.Type(),
+		AID:   a.ID(),
+		BType: bType,
+		BID:   bID,
+	}
+}

pkg/lambda/ast.go

···
+package lambda
+
+import "fmt"
+
+// Term represents a lambda calculus term.
+type Term interface {
+	String() string
+}
+
+// Var represents a variable usage.
+type Var struct {
+	Name string
+}
+
+func (v Var) String() string {
+	return v.Name
+}
+
+// Abs represents an abstraction (lambda).
+type Abs struct {
+	Arg  string
+	Body Term
+}
+
+func (a Abs) String() string {
+	return fmt.Sprintf("(%s: %s)", a.Arg, a.Body)
+}
+
+// App represents an application.
+type App struct {
+	Fun Term
+	Arg Term
+}
+
+func (a App) String() string {
+	return fmt.Sprintf("(%s %s)", a.Fun, a.Arg)
+}
+
+// Let represents a let binding (sugar for application).
+// let x = Val in Body -> (\x. Body) Val
+type Let struct {
+	Name string
+	Val  Term
+	Body Term
+}
+
+func (l Let) String() string {
+	return fmt.Sprintf("let %s = %s; %s", l.Name, l.Val, l.Body)
+}

pkg/lambda/parser.go

···
+package lambda
+
+import (
+	"fmt"
+	"unicode"
+)
+
+type TokenType int
+
+const (
+	TokenEOF TokenType = iota
+	TokenIdent
+	TokenColon
+	TokenEqual
+	TokenSemicolon
+	TokenLParen
+	TokenRParen
+	TokenLet
+	TokenIn
+)
+
+type Token struct {
+	Type    TokenType
+	Literal string
+}
+
+type Parser struct {
+	input   string
+	pos     int
+	current Token
+}
+
+func NewParser(input string) *Parser {
+	p := &Parser{input: input}
+	p.next()
+	return p
+}
+
+func (p *Parser) next() {
+	p.skipWhitespace()
+	if p.pos >= len(p.input) {
+		p.current = Token{Type: TokenEOF}
+		return
+	}
+
+	ch := p.input[p.pos]
+	switch {
+	case isLetter(ch):
+		start := p.pos
+		for p.pos < len(p.input) && (isLetter(p.input[p.pos]) || isDigit(p.input[p.pos])) {
+			p.pos++
+		}
+		lit := p.input[start:p.pos]
+		if lit == "let" {
+			p.current = Token{Type: TokenLet, Literal: lit}
+		} else if lit == "in" {
+			p.current = Token{Type: TokenIn, Literal: lit}
+		} else {
+			p.current = Token{Type: TokenIdent, Literal: lit}
+		}
+	case ch == ':':
+		p.current = Token{Type: TokenColon, Literal: ":"}
+		p.pos++
+	case ch == '=':
+		p.current = Token{Type: TokenEqual, Literal: "="}
+		p.pos++
+	case ch == ';':
+		p.current = Token{Type: TokenSemicolon, Literal: ";"}
+		p.pos++
+	case ch == '(':
+		p.current = Token{Type: TokenLParen, Literal: "("}
+		p.pos++
+	case ch == ')':
+		p.current = Token{Type: TokenRParen, Literal: ")"}
+		p.pos++
+	default:
+		// Treat unknown chars as identifiers for now (e.g. +)
+		// Or maybe just single char symbols
+		p.current = Token{Type: TokenIdent, Literal: string(ch)}
+		p.pos++
+	}
+}
+
+func (p *Parser) skipWhitespace() {
+	for p.pos < len(p.input) && unicode.IsSpace(rune(p.input[p.pos])) {
+		p.pos++
+	}
+}
+
+func isLetter(ch byte) bool {
+	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_'
+}
+
+func isDigit(ch byte) bool {
+	return ch >= '0' && ch <= '9'
+}
+
+func (p *Parser) Parse() (Term, error) {
+	return p.parseTerm()
+}
+
+// Term ::= Abs | Let | App
+func (p *Parser) parseTerm() (Term, error) {
+	if p.current.Type == TokenLet {
+		return p.parseLet()
+	}
+	
+	// Try to parse an abstraction or application
+	// Since application is left-associative and abstraction extends to the right,
+	// we need to be careful.
+	// Nix syntax: x: Body
+	// App: M N
+	
+	// We parse a list of "atoms" and combine them as application.
+	// If we see an identifier followed by colon, it's an abstraction.
+	// But we need lookahead or backtracking.
+	// Actually, `x: ...` starts with ident then colon.
+	// `x y` starts with ident then ident.
+	
+	// Let's parse "Atom" first.
+	// Atom ::= Ident | ( Term )
+	
+	// If current is Ident:
+	// Check next token. If Colon, it's Abs.
+	// Else, it's an Atom (Var), and we continue parsing more Atoms for App.
+	
+	if p.current.Type == TokenIdent {
+		// Lookahead
+		savePos := p.pos
+		saveTok := p.current
+		
+		// Peek next
+		p.next()
+		if p.current.Type == TokenColon {
+			// It's an abstraction
+			arg := saveTok.Literal
+			p.next() // consume colon
+			body, err := p.parseTerm()
+			if err != nil {
+				return nil, err
+			}
+			return Abs{Arg: arg, Body: body}, nil
+		}
+		
+		// Not an abstraction, backtrack
+		p.pos = savePos
+		p.current = saveTok
+	}
+	
+	return p.parseApp()
+}
+
+func (p *Parser) parseApp() (Term, error) {
+	left, err := p.parseAtom()
+	if err != nil {
+		return nil, err
+	}
+	
+	for {
+		if p.current.Type == TokenEOF || p.current.Type == TokenRParen || p.current.Type == TokenSemicolon || p.current.Type == TokenIn {
+			break
+		}
+		// Also stop if we see something that looks like the start of an abstraction?
+		// `x: ...` inside an app? `(x: x) y` is valid. `x y: z` -> `x (y: z)`?
+		// Usually lambda extends as far right as possible.
+		// So `x y: z` parses as `x (y: z)`.
+		// If we see Ident Colon, we should parse it as Abs and append to App.
+		
+		if p.current.Type == TokenIdent {
+			// Check for colon
+			savePos := p.pos
+			saveTok := p.current
+			p.next()
+			if p.current.Type == TokenColon {
+				// It's an abstraction `arg: body`
+				// This abstraction is the argument to the current application
+				argName := saveTok.Literal
+				p.next() // consume colon
+				body, err := p.parseTerm()
+				if err != nil {
+					return nil, err
+				}
+				left = App{Fun: left, Arg: Abs{Arg: argName, Body: body}}
+				// After parsing an abstraction (which consumes everything to the right),
+				// we are done with this application chain?
+				// Yes, because `x y: z a` -> `x (y: z a)`.
+				return left, nil
+			}
+			// Backtrack
+			p.pos = savePos
+			p.current = saveTok
+		}
+		
+		right, err := p.parseAtom()
+		if err != nil {
+			// If we can't parse an atom, maybe we are done
+			break
+		}
+		left = App{Fun: left, Arg: right}
+	}
+	
+	return left, nil
+}
+
+func (p *Parser) parseAtom() (Term, error) {
+	switch p.current.Type {
+	case TokenIdent:
+		name := p.current.Literal
+		p.next()
+		return Var{Name: name}, nil
+	case TokenLParen:
+		p.next()
+		term, err := p.parseTerm()
+		if err != nil {
+			return nil, err
+		}
+		if p.current.Type != TokenRParen {
+			return nil, fmt.Errorf("expected ')'")
+		}
+		p.next()
+		return term, nil
+	default:
+		return nil, fmt.Errorf("unexpected token: %v", p.current)
+	}
+}
+
+func (p *Parser) parseLet() (Term, error) {
+	p.next() // consume 'let'
+	
+	// Parse bindings: x = M; y = N; ...
+	type binding struct {
+		name string
+		val  Term
+	}
+	var bindings []binding
+	
+	for {
+		if p.current.Type != TokenIdent {
+			return nil, fmt.Errorf("expected identifier in let binding")
+		}
+		name := p.current.Literal
+		p.next()
+		
+		if p.current.Type != TokenEqual {
+			return nil, fmt.Errorf("expected '='")
+		}
+		p.next()
+		
+		val, err := p.parseTerm()
+		if err != nil {
+			return nil, err
+		}
+		
+		bindings = append(bindings, binding{name, val})
+		
+		if p.current.Type == TokenSemicolon {
+			p.next()
+			// Check if next is 'in' or another ident
+			if p.current.Type == TokenIn {
+				p.next()
+				break
+			}
+			// Continue to next binding
+		} else if p.current.Type == TokenIn {
+			p.next()
+			break
+		} else {
+			return nil, fmt.Errorf("expected ';' or 'in'")
+		}
+	}
+	
+	body, err := p.parseTerm()
+	if err != nil {
+		return nil, err
+	}
+	
+	// Desugar: let x=M; y=N in B -> (\x. (\y. B) N) M
+	// We iterate backwards
+	term := body
+	for i := len(bindings) - 1; i >= 0; i-- {
+		b := bindings[i]
+		term = App{
+			Fun: Abs{Arg: b.name, Body: term},
+			Arg: b.val,
+		}
+	}
+	
+	return term, nil
+}
+
+// Parse parses a lambda term from a string.
+func Parse(input string) (Term, error) {
+	p := NewParser(input)
+	return p.Parse()
+}

pkg/lambda/translate.go

···
+package lambda
+
+import (
+	"fmt"
+	"github.com/vic/godnet/pkg/deltanet"
+)
+
+// Context for variables: name -> {Node, Port, Level}
+type varInfo struct {
+	node  deltanet.Node
+	port  int
+	level int
+}
+
+// ToDeltaNet converts a lambda term to a Delta Net.
+func ToDeltaNet(term Term, net *deltanet.Network) (deltanet.Node, int) {
+	// We return the Node and Port index that represents the "root" of the term.
+	// This port should be connected to the "parent".
+	
+	vars := make(map[string]*varInfo)
+	
+	return buildTerm(term, net, vars, 0)
+}
+
+func buildTerm(term Term, net *deltanet.Network, vars map[string]*varInfo, level int) (deltanet.Node, int) {
+	switch t := term.(type) {
+	case Var:
+		if info, ok := vars[t.Name]; ok {
+			// Variable is bound
+			
+			if info.node.Type() == deltanet.NodeTypeReplicator {
+				// Subsequent use
+				// info.node is the Replicator.
+				// We need to add a port to it.
+				// Create new Replicator with +1 port.
+				oldRep := info.node
+				oldDeltas := oldRep.Deltas()
+				newDelta := level - (info.level + 1)
+				newDeltas := append(oldDeltas, newDelta)
+				
+				newRep := net.NewReplicator(oldRep.Level(), newDeltas)
+				fmt.Printf("ToDeltaNet: Expand Replicator ID %d level=%d oldDeltas=%v -> newDeltas=%v (usage level=%d, binder level=%d)\n", oldRep.ID(), oldRep.Level(), oldDeltas, newDeltas, level, info.level)
+				
+				// Move connections
+				// Rep.0 -> Source
+				sourceNode, sourcePort := net.GetLink(oldRep, 0)
+				net.Link(newRep, 0, sourceNode, sourcePort)
+				
+				// Move existing aux ports
+				for i := 0; i < len(oldDeltas); i++ {
+					// Get what oldRep.i+1 is connected to
+					destNode, destPort := net.GetLink(oldRep, i+1)
+					if destNode != nil {
+						net.Link(newRep, i+1, destNode, destPort)
+					}
+				}
+				
+				// Update info
+				info.node = newRep
+				info.port = 0
+				
+				// Return new port
+				return newRep, len(newDeltas) // Index is len (1-based? No, 0 is principal. 1..len)
+			}
+			
+			linkNode, _ := net.GetLink(info.node, info.port)
+			
+			if linkNode.Type() == deltanet.NodeTypeEraser {
+				// First use
+				// Remove Eraser (linkNode)
+				// In `deltanet`, `removeNode` is no-op, but we should disconnect.
+				// Actually `Link` overwrites.
+				
+				// Create Replicator
+				delta := level - (info.level + 1)
+				
+				repLevel := info.level + 1
+				
+				// Link Rep.0 to Source (info.node, info.port)
+				rep := net.NewReplicator(repLevel, []int{delta})
+				net.Link(rep, 0, info.node, info.port)
+				fmt.Printf("ToDeltaNet: First-use: created Replicator ID %d level=%d deltas=%v for binder level=%d usage level=%d\n", rep.ID(), rep.Level(), rep.Deltas(), info.level, level)
+				
+				// Update info to point to Rep
+				info.node = rep
+				info.port = 0 // Rep.0 is the input
+				
+				// Return Rep.1
+				return rep, 1
+				
+			} else {
+				// Should not happen if logic is correct (either Eraser or Replicator)
+				panic(fmt.Sprintf("Unexpected node type on variable binding: %v", linkNode.Type()))
+			}
+			
+		} else {
+			// Free variable
+			// Create Var node
+			v := net.NewVar()
+			// Create Replicator to share it (as per deltanets.ts)
+			// "Create free variable node... Create a replicator fan-in... link... return rep.1"
+			// Level 0 for free vars.
+			// Debug: record replicator parameters for free var
+			fmt.Printf("ToDeltaNet: Free var '%s' at level=%d -> Rep(level=%d, deltas=%v)\n", t.Name, level, 0, []int{level - 1})
+			rep := net.NewReplicator(0, []int{level - 1}) // level - (0 + 1) ?
+			net.Link(rep, 0, v, 0)
+			
+			// Register in vars so we can share it if used again
+			vars[t.Name] = &varInfo{node: rep, port: 0, level: 0}
+			
+			return rep, 1
+		}
+		
+	case Abs:
+		// Create Fan
+		fan := net.NewFan()
+		// fan.0 is Result (returned)
+		// fan.1 is Body
+		// fan.2 is Var
+		
+		// Create Eraser for Var initially
+		era := net.NewEraser()
+		net.Link(era, 0, fan, 2)
+		
+		// Register var
+		// Save old var info if shadowing
+		oldVar := vars[t.Arg]
+		vars[t.Arg] = &varInfo{node: fan, port: 2, level: level}
+		
+		// Build Body
+		bodyNode, bodyPort := buildTerm(t.Body, net, vars, level)
+		net.Link(fan, 1, bodyNode, bodyPort)
+		
+		// Restore var
+		if oldVar != nil {
+			vars[t.Arg] = oldVar
+		} else {
+			delete(vars, t.Arg)
+		}
+		
+		return fan, 0
+		
+	case App:
+		// Create Fan
+		fan := net.NewFan()
+		// fan.0 is Function
+		// fan.1 is Result (returned)
+		// fan.2 is Argument
+		
+		// Build Function
+		funNode, funPort := buildTerm(t.Fun, net, vars, level)
+		net.Link(fan, 0, funNode, funPort)
+		
+		// Build Argument (level + 1)
+		argNode, argPort := buildTerm(t.Arg, net, vars, level+1)
+		net.Link(fan, 2, argNode, argPort)
+		
+		return fan, 1
+		
+	case Let:
+		// Should have been desugared by parser, but if we encounter it:
+		// let x = Val in Body -> (\x. Body) Val
+		desugared := App{
+			Fun: Abs{Arg: t.Name, Body: t.Body},
+			Arg: t.Val,
+		}
+		return buildTerm(desugared, net, vars, level)
+		
+	default:
+		panic("Unknown term type")
+	}
+}
+
+// FromDeltaNet reconstructs a lambda term from the network.
+func FromDeltaNet(net *deltanet.Network, rootNode deltanet.Node, rootPort int) Term {
+	// Debug
+	// fmt.Printf("FromDeltaNet: Root %v Port %d\n", rootNode.Type(), rootPort)
+
+	// We traverse from the root.
+	// We need to track visited nodes to handle loops (though lambda terms shouldn't have loops unless we have recursion combinators).
+	// But we also need to track bound variables.
+	
+	// Map from (NodeID, Port) to Variable Name for bound variables.
+	// When we enter Abs at 0, we assign a name to Abs.2.
+	
+	bindings := make(map[uint64]string) // Key: Node ID of the binder (Fan), Value: Name
+	
+	// We need a name generator
+	nameGen := 0
+	nextName := func() string {
+		name := fmt.Sprintf("x%d", nameGen)
+		nameGen++
+		return name
+	}
+	
+	return readTerm(net, rootNode, rootPort, bindings, nextName)
+}
+
+func readTerm(net *deltanet.Network, node deltanet.Node, port int, bindings map[uint64]string, nextName func() string) Term {
+	if node == nil {
+		return Var{Name: "<nil>"}
+	}
+	
+	switch node.Type() {
+	case deltanet.NodeTypeFan:
+		if port == 0 {
+			// Entering Abs at Result -> Abs
+			name := nextName()
+			bindings[node.ID()] = name
+			
+			body := readTerm(net, getLinkNode(net, node, 1), getLinkPort(net, node, 1), bindings, nextName)
+			return Abs{Arg: name, Body: body}
+		} else if port == 1 {
+			// Entering App at Result -> App
+			fun := readTerm(net, getLinkNode(net, node, 0), getLinkPort(net, node, 0), bindings, nextName)
+			arg := readTerm(net, getLinkNode(net, node, 2), getLinkPort(net, node, 2), bindings, nextName)
+			return App{Fun: fun, Arg: arg}
+		} else {
+			// Entering at 2?
+			// This means we are traversing UP a variable binding?
+			// Should not happen in normal term traversal unless we are debugging.
+			return Var{Name: "<binding>"}
+		}
+		
+	case deltanet.NodeTypeReplicator:
+		// We entered a Replicator.
+		// If we entered at Aux port (>= 1), we are reading a variable usage.
+		// We need to trace back to the source (Port 0).
+		if port > 0 {
+			sourceNode := getLinkNode(net, node, 0)
+			sourcePort := getLinkPort(net, node, 0)
+
+			// Trace back until we hit a Fan.2 (Binder) or Var (Free)
+			// If the source is a Fan (Abs/App), traceVariable will delegate
+			// to readTerm to reconstruct the full subterm.
+			return traceVariable(net, sourceNode, sourcePort, bindings, nextName)
+		} else {
+			// Entered at 0?
+			// Reading the value being shared?
+			// This happens if we have `(\x. x) M`. `M` connects to `Rep.0`.
+			// If we read `M`, we traverse `M`.
+			// But here we are reading the *term* that `Rep` is part of.
+			// If `Rep` is part of the term structure (e.g. sharing a subterm),
+			// then `Rep.0` points to the subterm.
+			// So we just recurse on `Rep.0`?
+			// No, `Rep.0` is the *input* to the Replicator.
+			// If we enter at 0, we are going *upstream*?
+			// Wait, `Rep` directionality:
+			// 0 is Input. 1..N are Outputs.
+			// If we enter at 0, we are looking at the Output of `Rep`? No.
+			// If we enter at 0, we came from the Input side.
+			// This means we are traversing *into* the Replicator from the source.
+			// This implies the Replicator is sharing the *result* of something.
+			// e.g. `let x = M in ...`. `M` connects to `Rep.0`.
+			// If we are reading `M`, we don't hit `Rep`.
+			// If we are reading the body, we hit `Rep` at aux ports.
+			// So when do we hit `Rep` at 0?
+			// Only if we are traversing `M` and `M` *is* the Replicator?
+			// No, `Rep` is not a term constructor like Abs/App. It's a structural node.
+			// If `M` is `x`, and `x` is shared, then `M` *is* a wire to `Rep`.
+			// But `Rep` is connected to `x`'s binder.
+			// So `M` connects to `Rep` aux port.
+			// So we enter at aux.
+			
+			// What if `M` is `\y. y` and it is shared?
+			// `Abs` (M) connects to `Rep.0`.
+			// `Rep` aux ports connect to usages.
+			// If we read `M` (e.g. if we are reading the `let` value), we hit `Rep.0`.
+			// So we should just read what `Rep` is connected to?
+			// No, `Rep` *is* the sharing mechanism.
+			// If we are reading the term `M`, and `M` is shared, we see `Abs`.
+			// We don't see `Rep` unless we are reading the *usages*.
+			// Wait. `Abs.0` connects to `Rep.0`.
+			// If we read `M`, we start at `Abs.0`.
+			// We don't start at `Rep`.
+			// Unless `M` is *defined* as `Rep`? No.
+			
+			// Ah, `FromDeltaNet` takes `rootNode, rootPort`.
+			// This is the "output" of the term.
+			// If the term is `\x. x`, output is `Abs.0`.
+			// If the term is `x`, output is `Rep` aux port (or `Abs.2`).
+			// If the term is `M N`, output is `App.1`.
+			
+			// So we should never enter `Rep` at 0 during normal read-back of a term,
+			// unless the term *itself* is being shared and we are reading the *source*?
+			// But `rootNode` is the *result* of the reduction.
+			// If the result is shared, then `rootNode` might be `Rep`?
+			// If the result is `x` (free var), and it's shared?
+			// `Var` -> `Rep.0`. `Rep.1` -> Output.
+			// So Output is `Rep.1`. We enter at 1.
+			
+			// So entering at 0 should be rare/impossible for "Result".
+			return Var{Name: "<rep-0>"}
+		}
+		
+	case deltanet.NodeTypeVar:
+		// Free variable or wire
+		// If it's a named var, return it.
+		// But `Var` nodes don't store names in `deltanet` package?
+		// `deltanet.NewVar()` creates `NodeTypeVar`.
+		// It doesn't store a name.
+		// We lost the name!
+		// We need to store names for free variables if we want to read them back.
+		// But `deltanet` doesn't support labels.
+		// I can't modify `deltanet` package (user reverted).
+		// So I can't store names in `Var` nodes.
+		// I'll return "<free>" or generate a name.
+		return Var{Name: "<free>"}
+		
+	case deltanet.NodeTypeEraser:
+		return Var{Name: "<erased>"}
+		
+	default:
+		return Var{Name: fmt.Sprintf("<? %v>", node.Type())}
+	}
+}
+
+func traceVariable(net *deltanet.Network, node deltanet.Node, port int, bindings map[uint64]string, nextName func() string) Term {
+	// Follow wires up through Replicators (entering at 0, leaving at 0?)
+	// No, `Rep.0` connects to Source.
+	// So if we are at `Rep`, we go to `Rep.0`'s link.
+	
+	currNode := node
+	currPort := port
+	
+	for {
+		if currNode == nil {
+			return Var{Name: "<nil-trace>"}
+		}
+
+		switch currNode.Type() {
+		case deltanet.NodeTypeFan:
+			// Hit a Fan.
+			// If port 2, it's a binder.
+			if currPort == 2 {
+				if name, ok := bindings[currNode.ID()]; ok {
+					return Var{Name: name}
+				}
+				return Var{Name: "<unbound-fan>"}
+			}
+			// If port 0 or 1, reconstruct the full term (Abs or App)
+			return readTerm(net, currNode, currPort, bindings, nextName)
+
+		case deltanet.NodeTypeReplicator:
+			// Continue trace from Rep.0
+			if currPort == 0 {
+				return Var{Name: "<rep-trace-0>"}
+			}
+			nextNode, nextPort := net.GetLink(currNode, 0)
+			currNode = nextNode
+			currPort = nextPort
+
+		case deltanet.NodeTypeVar:
+			return Var{Name: "<free>"}
+
+		case deltanet.NodeTypeEraser:
+			return Var{Name: "<erased>"}
+
+		default:
+			return Var{Name: fmt.Sprintf("<? %v>", currNode.Type())}
+		}
+	}
+}
+
+func getLinkNode(net *deltanet.Network, node deltanet.Node, port int) deltanet.Node {
+	n, _ := net.GetLink(node, port)
+	return n
+}
+
+func getLinkPort(net *deltanet.Network, node deltanet.Node, port int) int {
+	_, p := net.GetLink(node, port)
+	return p
+}