Expand Laurel implementation, so that tests T2 (impure expressions) and T3 (dag control flow) pass as well

.github/CODEOWNERS

@@ -17,13 +17,13 @@
 /StrataTest/DDM/ @joehendrix @shigoel @aqjune-aws
 
 # Dialects
-/Strata/DL/Lambda/ @shigoel @atomb @aqjune-aws
-/StrataTest/DL/Lambda/ @shigoel @atomb @aqjune-aws
+/Strata/DL/Lambda/ @shigoel @atomb @aqjune-aws @joscoh
+/StrataTest/DL/Lambda/ @shigoel @atomb @aqjune-aws @joscoh
 
-/Strata/DL/Imperative/ @atomb @shigoel @aqjune-aws
-/StrataTest/DL/Imperative/ @atomb @shigoel @aqjune-aws
+/Strata/DL/Imperative/ @atomb @shigoel @aqjune-aws @joscoh
+/StrataTest/DL/Imperative/ @atomb @shigoel @aqjune-aws @joscoh
 
-/Strata/DL/SMT/ @andrewmwells-amazon @atomb
+/Strata/DL/SMT/ @andrewmwells-amazon @atomb @aqjune-aws
 
 /Strata/DL/Utils/ @shigoel @atomb @aqjune-aws
 
@@ -33,6 +33,8 @@
 
 /Strata/Languages/C_Simp/ @andrewmwells-amazon @shigoel
 
+/Strata/Languages/Python/ @andrewmwells-amazon @joehendrix @shigoel
+
 /Strata/Transform/ @atomb @andrewmwells-amazon
 
 # Documentation

.github/scripts/check_lean_consistency.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+# This checks that the version of Lean in the main package
+# matches the version in the Verso documentation package.
+set -e
+
+if cmp --silent "lean-toolchain" "docs/verso/lean-toolchain"; then
+  exit 0
+else
+  echo "Strata and StrataDoc lean versions do not match."
+  exit 1
+fi

.github/workflows/cbmc.yml

@@ -0,0 +1,64 @@
+name: CBMC
+
+on:
+  workflow_call:
+
+jobs:
+  cbmc_test:
+    name: Run CBMC tests
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install cvc5
+        shell: bash
+        run: |
+              ARCH=$(uname -m)
+              if [ "$ARCH" = "x86_64" ]; then
+                ARCH_NAME="x86_64"
+              elif [ "$ARCH" = "aarch64" ] || [ "$ARCH" = "arm64" ]; then
+                ARCH_NAME="arm64"
+              else
+                echo "Unsupported architecture: $ARCH"
+                exit 1
+              fi
+              wget https://github.com/cvc5/cvc5/releases/download/cvc5-1.2.1/cvc5-Linux-${ARCH_NAME}-static.zip
+              unzip cvc5-Linux-${ARCH_NAME}-static.zip
+              chmod +x cvc5-Linux-${ARCH_NAME}-static/bin/cvc5
+              echo "$GITHUB_WORKSPACE/cvc5-Linux-${ARCH_NAME}-static/bin/" >> $GITHUB_PATH
+      - name: Install z3
+        shell: bash
+        run: |
+              ARCH=$(uname -m)
+              if [ "$ARCH" = "x86_64" ]; then
+                ARCH_NAME="x86_64"
+                wget https://github.com/Z3Prover/z3/releases/download/z3-4.15.2/z3-4.15.2-x64-glibc-2.39.zip
+                ARCHIVE_NAME="z3-4.15.2-x64-glibc-2.39"
+              elif [ "$ARCH" = "aarch64" ] || [ "$ARCH" = "arm64" ]; then
+                ARCH_NAME="arm64"
+                wget https://github.com/Z3Prover/z3/releases/download/z3-4.15.2/z3-4.15.2-arm64-glibc-2.34.zip
+                ARCHIVE_NAME="z3-4.15.2-arm64-win"
+              else
+                echo "Unsupported architecture: $ARCH"
+                exit 1
+              fi
+              unzip "${ARCHIVE_NAME}.zip"
+              chmod +x "${ARCHIVE_NAME}/bin/z3"
+              echo "$GITHUB_WORKSPACE/${ARCHIVE_NAME}/bin/" >> $GITHUB_PATH
+      - name: Install CBMC
+        shell: bash
+        run: |
+          wget https://github.com/diffblue/cbmc/releases/download/cbmc-6.4.1/ubuntu-22.04-cbmc-6.4.1-Linux.deb
+          sudo dpkg -i ubuntu-22.04-cbmc-6.4.1-Linux.deb
+      - name: Build Strata
+        uses: leanprover/lean-action@v1
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.14'
+      - name: Run CBMC tests
+        shell: bash
+        run: |
+          export CBMC_DIR="/usr/bin/"
+          ./Strata/Backends/CBMC/run_strata_cbmc.sh Strata/Backends/CBMC/tests/simpleTest.csimp.st

.github/workflows/ci.yml

@@ -78,12 +78,20 @@ jobs:
         run: dotnet test ${SOLUTION}
       - name: Test Strata Command line
         run: .github/scripts/testStrataCommand.sh        
-      - name: Verify examples
+      - name: Validate examples against expected output
+        working-directory: Examples
         shell: bash
-        run: |
-              find "Examples" -maxdepth 1 -type f -name "*.st" | while IFS= read -r file; do
-                  source ~/.profile && lake exe StrataVerify "$file"
-              done
+        run: ./run_examples.sh
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.14'
+      - name: Build using pip
+        run: pip install .
+        working-directory: Tools/Python
+      - name: Run pyAnalyze tests
+        working-directory: StrataTest/Languages/Python
+        shell: bash
+        run: ./run_py_analyze.sh
 
   lint_checks:
     name: Run lint checks
@@ -104,33 +112,35 @@ jobs:
         run: .github/scripts/lintWhitespace.sh
       - name: Check for import Lean
         run: .github/scripts/checkLeanImport.sh
+      - name: Check Lean version consistncy
+        run: .github/scripts/check_lean_consistency.sh
 
   build_doc:
-    name: Build Documentation
+    name: Build documentation
     runs-on: ubuntu-latest
     permissions:
       contents: read
     steps:
       - uses: actions/checkout@v4
-      - name: Build documetation package
+      - name: Build documentation package
         uses: leanprover/lean-action@v1
         with:
           build-args: '--wfail'
-          lake-package-directory: 'docs/ddm'
-      - name: Build Documentation
-        run: lake exe docs 
-        working-directory: docs/ddm
+          lake-package-directory: 'docs/verso'
+      - name: Build documentation
+        run: ./generate.sh
+        working-directory: docs/verso
 
   build_python:
-    name: Build and test Python package
+    name: Build and test Python
     runs-on: ubuntu-latest
     permissions:
       contents: read
     steps:
     - uses: actions/checkout@v4
     - uses: actions/setup-python@v5
       with:
-        python-version: '3.13'
+        python-version: '3.14'
     - name: Build using pip
       run: pip install .
       working-directory: Tools/Python
@@ -143,3 +153,9 @@ jobs:
     - name: Run test script
       run: ./scripts/run_cpython_tests.sh
       working-directory: Tools/Python
+
+  cbmc:
+    needs: build_and_test_lean
+    permissions:
+      contents: read
+    uses: ./.github/workflows/cbmc.yml

.gitignore

@@ -5,3 +5,5 @@
 vcs/*.smt2
 
 Strata.code-workspace
+
+StrataTest/Internal

.kiro/settings/mcp.json

@@ -0,0 +1,29 @@
+{
+  "mcpServers": {
+    "lean-lsp": {
+      "command": "uvx",
+      "args": [
+        "lean-lsp-mcp"
+      ],
+      "disabled": false,
+      "autoApprove": [
+        "lean_build",
+        "lean_file_contents",
+        "lean_diagnostic_messages",
+        "lean_goal",
+        "lean_term_goal",
+        "lean_hover_info",
+        "lean_completions",
+        "lean_declaration_file",
+        "lean_multi_attempt",
+        "lean_run_code",
+        "loan_local_search",
+        "lean_leansearch",
+        "lean_loogle",
+        "lean_leanfinder",
+        "lean_state_search",
+        "lean_hammer_premise"
+      ]
+    }
+  }
+}

.kiro/steering/plausible-instructions.md

@@ -0,0 +1,109 @@
+---
+inclusion: fileMatch
+fileMatchPattern: ['**/StrataTest/**/*.lean', '**/Examples/**/*.lean']
+---
+
+# Plausible Property-Based Testing
+
+Use Plausible for property-based testing in Strata test files. It finds counter-examples to propositions by generating random test cases.
+
+## When to Use
+
+- Testing transformation correctness properties (e.g., `DetToNondetCorrect.lean`, `CallElimCorrect.lean`)
+- Validating semantic equivalences between program representations
+- Testing expression evaluation properties (Lambda, Imperative dialects)
+- Verifying type system properties
+- Quick sanity checks before formal proofs
+
+## Required Type Class Instances
+
+For custom types to work with Plausible, implement these three instances:
+
+1. **`Repr α`** - String representation (use `deriving Repr` when possible)
+2. **`Shrinkable α`** - Reduces counter-examples to minimal cases
+3. **`Arbitrary α`** - Random value generator
+
+## Implementation Patterns
+
+### Simple Algebraic Types
+Use automatic derivation:
+```lean
+inductive MyType where
+  | case1 : Nat → MyType
+  | case2 : Bool → MyType
+  deriving Repr, Arbitrary
+```
+
+### Dependent Types with Invariants
+Manually implement instances to maintain invariants:
+```lean
+structure BoundedNat where
+  val : Nat
+  h : val < 100
+  deriving Repr
+
+instance : Shrinkable BoundedNat where
+  shrink := fun ⟨n, _⟩ =>
+    (Shrinkable.shrink n).filterMap fun n' =>
+      if h : n' < 100 then some ⟨n', h⟩ else none
+
+instance : Arbitrary BoundedNat :=
+  ⟨do
+    let n ← SampleableExt.interpSample (Fin 100)
+    return ⟨n.val, n.isLt⟩⟩
+```
+
+### Product Types
+Shrink components independently:
+```lean
+instance : Shrinkable (α × β) where
+  shrink := fun (a, b) =>
+    (Shrinkable.shrink a).map (·, b) ++
+    (Shrinkable.shrink b).map (a, ·)
+```
+
+### Strata-Specific Types
+For Lambda expressions, Imperative statements, or Boogie constructs, ensure generators produce well-typed, valid AST nodes.
+
+## Usage Modes
+
+### Tactic Mode (Preferred)
+```lean
+example (xs ys : Array Nat) : xs.size = ys.size → xs = ys := by
+  plausible  -- Finds: xs := #[0], ys := #[1]
+```
+
+### Programmatic Mode
+```lean
+#eval Testable.check <| ∀ (x y : Nat), x + y = y + x  -- Success
+```
+
+### Configuration
+```lean
+example (a b : Bool) : a = b := by
+  plausible (config := {quiet := true, numInst := 1000})
+```
+
+## Testing Workflow
+
+1. **Write property** as a Lean proposition
+2. **Add Plausible instances** for custom types (if needed)
+3. **Run test** with `plausible` tactic or `#eval Testable.check`
+4. **Interpret results**:
+   - Counter-example found → property is false
+   - Success → property likely holds (not a proof)
+   - Use counter-examples to refine properties or fix bugs
+
+## Common Pitfalls
+
+- **Missing instances**: Ensure `Repr`, `Shrinkable`, and `Arbitrary` are all implemented
+- **Invalid generators**: Generators must respect type invariants (use guards or filtered generation)
+- **Non-decidable properties**: Plausible requires decidable propositions
+- **Over-constrained shrinking**: Shrinking should preserve the counter-example property
+
+## Integration with Strata
+
+- Place property tests in `StrataTest/` mirroring the `Strata/` structure
+- Test transformation correctness before attempting formal proofs
+- Use Plausible to validate semantic preservation properties
+- Generate test cases for edge cases in dialect implementations