dsh-logicprobe 0.3.1 → 0.5.0

package/skills/logicprobe/references/verification-harness.py

@@ -1,582 +1,806 @@
-#!/usr/bin/env python3
-"""State Machine Verification Harness — generic template for logicprobe Phase 2a/2b.
-
-Fill in the MODEL section below with states, transitions, invariants extracted from the plan.
-Run: python3 verification-harness.py
-Output: structured verification report for Phase 3 gap analysis.
-"""
-import sys
-from collections import deque
-from itertools import permutations
-
-# =============================================================================
-# MODEL — fill in from plan extraction
-# =============================================================================
-
-STATES: dict[str, dict[str, str]] = {
-    # "STATE_NAME": {
-    #     "event_or_condition": "NEXT_STATE",
-    #     "another_event": "ANOTHER_STATE",
-    # },
-    # For guarded transitions, encode guard in event name:
-    #     "timeout (retry_count==0)": "RETRY",
-    #     "timeout (retry_count>=1)": "FATAL",
-}
-
-INIT: str = "INIT"
-
-TERMINALS: set[str] = set()  # States where machine intentionally stops
-
-# Invariants: list of {"desc": "human description", "check": lambda states, reachable: bool}
-INVARIANTS: list[dict] = []
-
-# Event pairs that can arrive concurrently (for A2 race interleaving)
-CONCURRENT_PAIRS: list[tuple[str, str]] = []
-
-# Counter/timer variables mentioned in guards (for A5 boundary blast)
-# Format: {"name": "variable_name", "max_valid": max_value, "type": "counter|timestamp"}
-BOUNDARY_VARS: list[dict] = []
-
-# Paired operations (for A4 pair symmetry)
-# Format: ("acquire_event_name", "release_event_name")
-PAIRS: list[tuple[str, str]] = [
-    # ("lock", "unlock"),
-    # ("alloc", "free"),
-    # ("start", "stop"),
-]
-
-# =============================================================================
-# PHASE 2a: STRUCTURAL PRIMITIVES
-# =============================================================================
-
-def all_states():
-    return set(STATES.keys())
-
-def all_events():
-    events = set()
-    for trans in STATES.values():
-        events.update(trans.keys())
-    return events
-
-def S1_reachability():
-    """BFS from INIT — find unreachable states."""
-    visited = set()
-    queue = deque([INIT])
-    while queue:
-        s = queue.popleft()
-        if s in visited:
-            continue
-        visited.add(s)
-        for nxt in STATES.get(s, {}).values():
-            if nxt not in visited:
-                queue.append(nxt)
-    unreachable = all_states() - visited
-    return {
-        "pass": len(unreachable) == 0,
-        "reachable": sorted(visited),
-        "unreachable": sorted(unreachable),
-        "detail": f"{len(unreachable)} unreachable: {sorted(unreachable)}" if unreachable else "All states reachable",
-    }
-
-def S2_deadlock():
-    """Any non-terminal state with zero outgoing transitions?"""
-    deadlocks = []
-    for s in sorted(all_states()):
-        if s not in TERMINALS and len(STATES.get(s, {})) == 0:
-            deadlocks.append(s)
-    return {
-        "pass": len(deadlocks) == 0,
-        "deadlocks": deadlocks,
-        "detail": f"Deadlocks: {deadlocks}" if deadlocks else "No deadlocks",
-    }
-
-def S3_liveness():
-    """Detect absorbing cycles that exclude expected terminal/recovery states."""
-    # Build reverse graph to find cycles
-    cycles = []
-    for start in all_states():
-        # DFS from each state to find cycles
-        def find_cycle(s, path, visited_cycle):
-            if s in visited_cycle:
-                idx = path.index(s)
-                return path[idx:]
-            visited_cycle.add(s)
-            for nxt in STATES.get(s, {}).values():
-                result = find_cycle(nxt, path + [s], visited_cycle.copy())
-                if result:
-                    return result
-            return None
-
-        cycle = find_cycle(start, [], set())
-        if cycle and cycle not in cycles:
-            cycles.append(cycle)
-
-    # An absorbing cycle is one where ALL transitions from cycle states stay in the cycle
-    absorbing = []
-    for cycle in cycles:
-        cycle_set = set(cycle)
-        is_absorbing = True
-        for s in cycle:
-            for nxt in STATES.get(s, {}).values():
-                if nxt not in cycle_set:
-                    is_absorbing = False
-                    break
-            if not is_absorbing:
-                break
-        if is_absorbing:
-            # Check if cycle excludes terminal/recovery states
-            if not (cycle_set & TERMINALS):
-                absorbing.append(cycle)
-
-    return {
-        "pass": len(absorbing) == 0,
-        "absorbing_cycles": absorbing,
-        "all_cycles": cycles,
-        "detail": f"Absorbing cycles (no exit, no terminal): {absorbing}" if absorbing else "No harmful absorbing cycles",
-    }
-
-def S4_determinism():
-    """Same (state, event) → multiple different targets?"""
-    # The dict-of-dicts structure is inherently deterministic per event key.
-    # This check verifies: for each state, event names are unambiguous (no duplicates).
-    ambiguous = []
-    for s in sorted(all_states()):
-        seen = {}
-        for event, target in STATES.get(s, {}).items():
-            base = event.split("(")[0].strip()  # Strip guard suffix for comparison
-            if base in seen and seen[base] != target:
-                ambiguous.append((s, base, seen[base], target))
-            seen[base] = target
-    return {
-        "pass": len(ambiguous) == 0,
-        "ambiguous": ambiguous,
-        "detail": f"Ambiguous transitions: {ambiguous}" if ambiguous else "Deterministic",
-    }
-
-def S5_event_completeness():
-    """States missing handlers for events that other states handle."""
-    events = all_events()
-    warnings = []
-    for s in sorted(all_states()):
-        if s in TERMINALS:
-            continue
-        handled = set(STATES.get(s, {}).keys())
-        # Only flag if a state is missing events that are relevant (handled elsewhere)
-        relevant = set()
-        for e in events - handled:
-            # Check if this event type appears in guard variants
-            base = e.split("(")[0].strip()
-            if any(base in h for h in handled):
-                pass  # Already handled via guard variant
-            else:
-                relevant.add(e)
-        if relevant:
-            warnings.append((s, sorted(relevant)))
-    return {
-        "pass": len(warnings) == 0,
-        "warnings": warnings,
-        "detail": f"Missing event handlers: {warnings}" if warnings else "All states handle all relevant events",
-    }
-
-def S6_guard_completeness():
-    """For each transition with a guard condition, are ALL branch outcomes defined?"""
-    # Group transitions by (state, base_event)
-    guard_groups = {}
-    for s in sorted(all_states()):
-        for event in STATES.get(s, {}):
-            base = event.split("(")[0].strip()
-            key = (s, base)
-            if key not in guard_groups:
-                guard_groups[key] = []
-            guard_groups[key].append(event)
-
-    incomplete = []
-    for (s, base), variants in guard_groups.items():
-        if len(variants) > 1:
-            # Guard exists — check if there's a default/else path
-            has_default = any("else" in v.lower() or "default" in v.lower() for v in variants)
-            has_explicit = len(variants) >= 2  # At minimum, two guard branches
-            # Heuristic: if we have guard variants but no explicit "else", flag it
-            if not has_default:
-                incomplete.append({
-                    "state": s,
-                    "event": base,
-                    "variants": variants,
-                    "missing": "else/default branch",
-                })
-    return {
-        "pass": len(incomplete) == 0,
-        "incomplete_guards": incomplete,
-        "detail": f"Incomplete guards: {incomplete}" if incomplete else "All guard branches defined or single-path",
-    }
-
-def S7_invariants():
-    """Verify each claimed invariant against all reachable states."""
-    # First compute reachable set
-    visited = set()
-    queue = deque([INIT])
-    while queue:
-        s = queue.popleft()
-        if s in visited:
-            continue
-        visited.add(s)
-        for nxt in STATES.get(s, {}).values():
-            if nxt not in visited:
-                queue.append(nxt)
-
-    violations = []
-    for inv in INVARIANTS:
-        try:
-            if not inv["check"](STATES, visited):
-                violations.append(inv["desc"])
-        except Exception as e:
-            violations.append(f"{inv['desc']} — ERROR: {e}")
-
-    return {
-        "pass": len(violations) == 0,
-        "violations": violations,
-        "detail": f"Invariant violations: {violations}" if violations else "All invariants hold",
-    }
-
-# =============================================================================
-# PHASE 2b: ADVERSARIAL PROBES
-# =============================================================================
-
-def step(current, events):
-    """Simulate a sequence of events from current state. Returns final state."""
-    s = current
-    for e in events:
-        if s in TERMINALS:
-            break
-        trans = STATES.get(s, {})
-        # Exact match first
-        if e in trans:
-            s = trans[e]
-        else:
-            # Try matching guard variants — pick the first matching base event
-            base_match = None
-            for evt, target in trans.items():
-                if evt.startswith(e) or e.startswith(evt.split("(")[0].strip()):
-                    base_match = target
-                    break
-            if base_match:
-                s = base_match
-            # else: event ignored (unhandled) — stay in current state
-    return s
-
-def A1_unexpected_event():
-    """Inject every event into every state that doesn't handle it."""
-    events = all_events()
-    findings = []
-    for s in sorted(all_states()):
-        if s in TERMINALS:
-            continue
-        handled = set(STATES.get(s, {}).keys())
-        unhandled = events - handled
-        if unhandled:
-            findings.append({
-                "state": s,
-                "unhandled": sorted(unhandled),
-                "risk": "Event silently ignored — may represent undefined behavior",
-            })
-    return {
-        "pass": len(findings) == 0,
-        "findings": findings,
-        "detail": f"{len(findings)} states with unhandled events" if findings else "All event/state combinations defined",
-    }
-
-def A2_race_interleaving():
-    """For each concurrent pair, test both arrival orders."""
-    if not CONCURRENT_PAIRS:
-        return {"pass": True, "findings": [], "detail": "No concurrent pairs defined — skipped"}
-
-    findings = []
-    for e1, e2 in CONCURRENT_PAIRS:
-        # Test from each state where both events are possible
-        for s in sorted(all_states()):
-            trans = STATES.get(s, {})
-            if e1 not in trans and e2 not in trans:
-                continue
-            final_e1e2 = step(s, [e1, e2])
-            final_e2e1 = step(s, [e2, e1])
-            if final_e1e2 != final_e2e1:
-                findings.append({
-                    "state": s,
-                    "pair": (e1, e2),
-                    "final_e1_then_e2": final_e1e2,
-                    "final_e2_then_e1": final_e2e1,
-                    "risk": "Order-dependent outcome",
-                })
-    return {
-        "pass": len(findings) == 0,
-        "findings": findings,
-        "detail": f"{len(findings)} order-dependent race conditions" if findings else "No race conditions detected",
-    }
-
-def A3_order_permutation():
-    """Test if different event orderings produce different terminal states."""
-    events = sorted(all_events())
-    if len(events) > 5:
-        # Too many permutations — sample subset
-        events = events[:5]
-
-    # Find event sequences that reach different terminals
-    terminal_sets = []
-    for perm in permutations(events):
-        final = step(INIT, list(perm))
-        terminal_sets.append((list(perm), final))
-
-    unique_terminals = set(t[1] for t in terminal_sets)
-
-    findings = []
-    if len(unique_terminals) > 1:
-        # Find the sequences producing each terminal
-        by_terminal = {}
-        for seq, term in terminal_sets:
-            by_terminal.setdefault(term, []).append(seq)
-        findings.append({
-            "terminal_states": sorted(unique_terminals),
-            "sequences": {t: seqs[0] for t, seqs in by_terminal.items()},
-            "risk": f"Same events produce {len(unique_terminals)} different outcomes",
-        })
-
-    return {
-        "pass": len(findings) == 0,
-        "findings": findings,
-        "detail": f"Order-dependent: {len(unique_terminals)} different outcomes" if findings else "Order-independent",
-    }
-
-def A4_pair_symmetry():
-    """Check lock/unlock, alloc/free, start/stop symmetry."""
-    if not PAIRS:
-        return {"pass": True, "findings": [], "detail": "No paired operations defined — skipped"}
-
-    events = all_events()
-    findings = []
-
-    for acquire, release in PAIRS:
-        # Check if this pair type is even used in the model
-        acquire_events = [e for e in events if acquire in e.lower()]
-        release_events = [e for e in events if release in e.lower()]
-
-        if not acquire_events and not release_events:
-            continue
-
-        # Simple check: for each acquire event, is there a corresponding release?
-        # More sophisticated: every path that contains acquire must contain release
-        # before reaching a terminal state or another acquire.
-
-        # Quick heuristic: count occurrences in transition targets
-        acquire_targets = set()
-        release_sources = set()
-        for s, trans in STATES.items():
-            for e, t in trans.items():
-                if any(ae in e.lower() for ae in acquire_events):
-                    acquire_targets.add(t)
-                if any(re in e.lower() for re in release_events):
-                    release_sources.add(s)
-
-        if acquire_targets and not release_sources:
-            findings.append({
-                "pair": (acquire, release),
-                "risk": f"'{acquire}' used but no '{release}' found — resource leak likely",
-            })
-
-    return {
-        "pass": len(findings) == 0,
-        "findings": findings,
-        "detail": f"Asymmetric pairs: {findings}" if findings else "All pairs balanced",
-    }
-
-def A5_boundary_blast():
-    """Probe counter/timer boundary values."""
-    if not BOUNDARY_VARS:
-        return {"pass": True, "findings": [], "detail": "No boundary variables defined — skipped"}
-
-    findings = []
-    for var in BOUNDARY_VARS:
-        name = var["name"]
-        max_val = var.get("max_valid", 255)
-        vtype = var.get("type", "counter")
-
-        test_values = [0, 1, max_val - 1, max_val, max_val + 1]
-        if vtype == "counter":
-            test_values += [2**8 - 1, 2**16 - 1, 2**32 - 1]
-
-        for tv in test_values:
-            if tv < 0 or tv > max_val:
-                findings.append({
-                    "variable": name,
-                    "tested_value": tv,
-                    "max_valid": max_val,
-                    "risk": f"Value {tv} exceeds max valid {max_val} — overflow possible",
-                })
-
-        if vtype == "timestamp":
-            findings.append({
-                "variable": name,
-                "risk": "Timestamp wraparound — verify elapsed_ms() / elapsed_ticks() handle wraparound correctly",
-            })
-
-    return {
-        "pass": len(findings) == 0,
-        "findings": findings,
-        "detail": f"Boundary issues: {len(findings)}" if findings else "Boundary checks passed",
-    }
-
-def A6_resource_injection():
-    """Simulate resource failures at each state."""
-    # Heuristic: identify states that likely allocate resources
-    findings = []
-    for s in sorted(all_states()):
-        if s in TERMINALS:
-            continue
-        state_lower = s.lower()
-        events_lower = [e.lower() for e in STATES.get(s, {}).keys()]
-
-        # Does this state look like it allocates resources?
-        alloc_keywords = ["alloc", "create", "init", "start", "open", "connect", "begin"]
-        has_alloc = any(kw in state_lower or any(kw in e for e in events_lower) for kw in alloc_keywords)
-
-        if not has_alloc:
-            continue
-
-        # Does it have an error recovery path?
-        error_keywords = ["error", "fail", "retry", "timeout", "recover", "fatal"]
-        has_recovery = any(any(kw in e for e in events_lower) for kw in error_keywords)
-
-        if not has_recovery:
-            findings.append({
-                "state": s,
-                "risk": f"State '{s}' may allocate resources but has no visible error recovery path",
-            })
-
-    return {
-        "pass": len(findings) == 0,
-        "findings": findings,
-        "detail": f"Resource vulnerability: {len(findings)} states" if findings else "No resource vulnerabilities detected",
-    }
-
-def A7_shortest_violation(invariant_results):
-    """Find shortest violating path for each failed invariant (requires re-running with path tracking)."""
-    if not INVARIANTS:
-        return {"pass": True, "findings": [], "detail": "No invariants defined — skipped"}
-
-    findings = []
-    for inv in INVARIANTS:
-        # BFS to find shortest path to violation
-        queue = deque([(INIT, [])])
-        visited = set()
-        found = None
-
-        while queue and not found:
-            s, path = queue.popleft()
-            if s in visited:
-                continue
-            visited.add(s)
-
-            try:
-                if not inv["check"](STATES, {s}):
-                    found = path
-                    break
-            except Exception:
-                found = path
-                break
-
-            for event, nxt in STATES.get(s, {}).items():
-                if nxt not in visited:
-                    queue.append((nxt, path + [(s, event, nxt)]))
-
-        if found:
-            findings.append({
-                "invariant": inv["desc"],
-                "violating_path": found,
-                "path_length": len(found),
-            })
-
-    return {
-        "pass": len(findings) == 0,
-        "findings": findings,
-        "detail": f"Violated invariants: {len(findings)}" if findings else "All invariants hold for all reachable paths",
-    }
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-def run_all():
-    results = {}
-    errors = 0
-    warnings = 0
-
-    print("=" * 60)
-    print("PHASE 2a: STRUCTURAL PRIMITIVES")
-    print("=" * 60)
-
-    checks_2a = [
-        ("S1 Reachability", S1_reachability),
-        ("S2 Deadlock", S2_deadlock),
-        ("S3 Liveness", S3_liveness),
-        ("S4 Determinism", S4_determinism),
-        ("S5 Event Completeness", S5_event_completeness),
-        ("S6 Guard Completeness", S6_guard_completeness),
-        ("S7 Invariants", S7_invariants),
-    ]
-
-    for name, check_fn in checks_2a:
-        result = check_fn()
-        results[name] = result
-        status = "PASS" if result["pass"] else "FAIL"
-        prefix = "  " if result["pass"] else "  [!] "
-        print(f"{prefix}[{status}] {name}: {result['detail']}")
-        if not result["pass"]:
-            if "Warning" in str(type(check_fn)):
-                warnings += 1
-            else:
-                errors += 1
-
-    print()
-    print("=" * 60)
-    print("PHASE 2b: ADVERSARIAL PROBES")
-    print("=" * 60)
-
-    probes_2b = [
-        ("A1 Unexpected Event", A1_unexpected_event),
-        ("A2 Race Interleaving", A2_race_interleaving),
-        ("A3 Order Permutation", A3_order_permutation),
-        ("A4 Pair Symmetry", A4_pair_symmetry),
-        ("A5 Boundary Blast", A5_boundary_blast),
-        ("A6 Resource Injection", A6_resource_injection),
-        ("A7 Shortest Violation", lambda: A7_shortest_violation(results.get("S7 Invariants", {}))),
-    ]
-
-    for name, probe_fn in probes_2b:
-        result = probe_fn()
-        results[name] = result
-        status = "PASS" if result["pass"] else "FAIL"
-        prefix = "  " if result["pass"] else "  [!] "
-        print(f"{prefix}[{status}] {name}: {result['detail']}")
-        if not result["pass"]:
-            warnings += 1  # Probe failures are warnings by default (may be false positives)
-
-    print()
-    print("=" * 60)
-    print(f"SUMMARY: {errors} structural errors, {warnings} probe/other warnings")
-    print("=" * 60)
-
-    if errors > 0:
-        print()
-        print("ACTION: Fix structural errors before proceeding to Phase 3.")
-        print("Structural errors indicate the plan's logic is incomplete or inconsistent.")
-
-    if warnings > 0 and errors == 0:
-        print()
-        print("ACTION: Review probe warnings — may be false positives or acceptable risks.")
-        print("Escalate confirmed findings to Phase 3 gap analysis.")
-
-    return errors, warnings, results
-
-
-if __name__ == "__main__":
-    errors, warnings, results = run_all()
-    sys.exit(1 if errors > 0 else 0)
+#!/usr/bin/env python3
+"""State Machine Verification Harness — generic template for logicprobe Phase 2a/2b.
+
+Fill in the MODEL section below with states, transitions, invariants extracted from the plan.
+Run: python3 verification-harness.py
+Output: structured verification report for Phase 3 gap analysis.
+"""
+import sys
+from collections import deque
+from itertools import permutations
+
+# =============================================================================
+# MODEL — fill in from plan extraction
+# =============================================================================
+
+STATES: dict[str, dict[str, str]] = {
+    # "STATE_NAME": {
+    #     "event_or_condition": "NEXT_STATE",
+    #     "another_event": "ANOTHER_STATE",
+    # },
+    # For guarded transitions, encode guard in event name:
+    #     "timeout (retry_count==0)": "RETRY",
+    #     "timeout (retry_count>=1)": "FATAL",
+}
+
+INIT: str = "INIT"
+
+TERMINALS: set[str] = set()  # States where machine intentionally stops
+
+# Invariants: list of {"desc": "human description", "check": lambda states, reachable: bool}
+INVARIANTS: list[dict] = []
+
+# Event pairs that can arrive concurrently (for A2 race interleaving)
+CONCURRENT_PAIRS: list[tuple[str, str]] = []
+
+# Counter/timer variables mentioned in guards (for A5 boundary blast)
+# Format: {"name": "variable_name", "max_valid": max_value, "type": "counter|timestamp"}
+BOUNDARY_VARS: list[dict] = []
+
+# Paired operations (for A4 pair symmetry)
+# Format: ("acquire_event_name", "release_event_name")
+PAIRS: list[tuple[str, str]] = [
+    # ("lock", "unlock"),
+    # ("alloc", "free"),
+    # ("start", "stop"),
+]
+
+# Monotonic variables (for S8)
+# Format: {"name": "counter", "direction": "inc|dec", "increase_events": [...], "decrease_events": [...]}
+MONOTONIC_VARS: list[dict] = []
+
+# Events that must be idempotent (for A8)
+IDEMPOTENT_EVENTS: set[str] = set()
+
+# Leads-to requirements (for A9): list of (from_state, to_state)
+LEADS_TO: list[tuple[str, str]] = []
+
+# Sequence requirements (for A10): list of event lists that must occur in order
+SEQUENCES: list[list[str]] = []
+
+# Atomic groups (for A11): {"events": [...], "commit": "...", "rollback": "..."}
+ATOMIC_GROUPS: list[dict] = []
+
+# Before model for D1-D4 comparison (optional)
+BEFORE_STATES: dict[str, dict[str, str]] = {}
+BEFORE_INIT: str = "INIT"
+BEFORE_TERMINALS: set[str] = set()
+STATE_MAPPING: dict[str, str] = {}
+
+# =============================================================================
+# PHASE 2a: STRUCTURAL PRIMITIVES
+# =============================================================================
+
+def all_states():
+    return set(STATES.keys())
+
+def all_events():
+    events = set()
+    for trans in STATES.values():
+        events.update(trans.keys())
+    return events
+
+def S1_reachability():
+    """BFS from INIT — find unreachable states."""
+    visited = set()
+    queue = deque([INIT])
+    while queue:
+        s = queue.popleft()
+        if s in visited:
+            continue
+        visited.add(s)
+        for nxt in STATES.get(s, {}).values():
+            if nxt not in visited:
+                queue.append(nxt)
+    unreachable = all_states() - visited
+    return {
+        "pass": len(unreachable) == 0,
+        "reachable": sorted(visited),
+        "unreachable": sorted(unreachable),
+        "detail": f"{len(unreachable)} unreachable: {sorted(unreachable)}" if unreachable else "All states reachable",
+    }
+
+def S2_deadlock():
+    """Any non-terminal state with zero outgoing transitions?"""
+    deadlocks = []
+    for s in sorted(all_states()):
+        if s not in TERMINALS and len(STATES.get(s, {})) == 0:
+            deadlocks.append(s)
+    return {
+        "pass": len(deadlocks) == 0,
+        "deadlocks": deadlocks,
+        "detail": f"Deadlocks: {deadlocks}" if deadlocks else "No deadlocks",
+    }
+
+def S3_liveness():
+    """Detect absorbing cycles that exclude expected terminal/recovery states."""
+    # Build reverse graph to find cycles
+    cycles = []
+    for start in all_states():
+        # DFS from each state to find cycles
+        def find_cycle(s, path, visited_cycle):
+            if s in visited_cycle:
+                idx = path.index(s)
+                return path[idx:]
+            visited_cycle.add(s)
+            for nxt in STATES.get(s, {}).values():
+                result = find_cycle(nxt, path + [s], visited_cycle.copy())
+                if result:
+                    return result
+            return None
+
+        cycle = find_cycle(start, [], set())
+        if cycle and cycle not in cycles:
+            cycles.append(cycle)
+
+    # An absorbing cycle is one where ALL transitions from cycle states stay in the cycle
+    absorbing = []
+    for cycle in cycles:
+        cycle_set = set(cycle)
+        is_absorbing = True
+        for s in cycle:
+            for nxt in STATES.get(s, {}).values():
+                if nxt not in cycle_set:
+                    is_absorbing = False
+                    break
+            if not is_absorbing:
+                break
+        if is_absorbing:
+            # Check if cycle excludes terminal/recovery states
+            if not (cycle_set & TERMINALS):
+                absorbing.append(cycle)
+
+    return {
+        "pass": len(absorbing) == 0,
+        "absorbing_cycles": absorbing,
+        "all_cycles": cycles,
+        "detail": f"Absorbing cycles (no exit, no terminal): {absorbing}" if absorbing else "No harmful absorbing cycles",
+    }
+
+def S4_determinism():
+    """Same (state, event) → multiple different targets?"""
+    # The dict-of-dicts structure is inherently deterministic per event key.
+    # This check verifies: for each state, event names are unambiguous (no duplicates).
+    ambiguous = []
+    for s in sorted(all_states()):
+        seen = {}
+        for event, target in STATES.get(s, {}).items():
+            base = event.split("(")[0].strip()  # Strip guard suffix for comparison
+            if base in seen and seen[base] != target:
+                ambiguous.append((s, base, seen[base], target))
+            seen[base] = target
+    return {
+        "pass": len(ambiguous) == 0,
+        "ambiguous": ambiguous,
+        "detail": f"Ambiguous transitions: {ambiguous}" if ambiguous else "Deterministic",
+    }
+
+def S5_event_completeness():
+    """States missing handlers for events that other states handle."""
+    events = all_events()
+    warnings = []
+    for s in sorted(all_states()):
+        if s in TERMINALS:
+            continue
+        handled = set(STATES.get(s, {}).keys())
+        # Only flag if a state is missing events that are relevant (handled elsewhere)
+        relevant = set()
+        for e in events - handled:
+            # Check if this event type appears in guard variants
+            base = e.split("(")[0].strip()
+            if any(base in h for h in handled):
+                pass  # Already handled via guard variant
+            else:
+                relevant.add(e)
+        if relevant:
+            warnings.append((s, sorted(relevant)))
+    return {
+        "pass": len(warnings) == 0,
+        "warnings": warnings,
+        "detail": f"Missing event handlers: {warnings}" if warnings else "All states handle all relevant events",
+    }
+
+def S6_guard_completeness():
+    """For each transition with a guard condition, are ALL branch outcomes defined?"""
+    # Group transitions by (state, base_event)
+    guard_groups = {}
+    for s in sorted(all_states()):
+        for event in STATES.get(s, {}):
+            base = event.split("(")[0].strip()
+            key = (s, base)
+            if key not in guard_groups:
+                guard_groups[key] = []
+            guard_groups[key].append(event)
+
+    incomplete = []
+    for (s, base), variants in guard_groups.items():
+        if len(variants) > 1:
+            # Guard exists — check if there's a default/else path
+            has_default = any("else" in v.lower() or "default" in v.lower() for v in variants)
+            has_explicit = len(variants) >= 2  # At minimum, two guard branches
+            # Heuristic: if we have guard variants but no explicit "else", flag it
+            if not has_default:
+                incomplete.append({
+                    "state": s,
+                    "event": base,
+                    "variants": variants,
+                    "missing": "else/default branch",
+                })
+    return {
+        "pass": len(incomplete) == 0,
+        "incomplete_guards": incomplete,
+        "detail": f"Incomplete guards: {incomplete}" if incomplete else "All guard branches defined or single-path",
+    }
+
+def S7_invariants():
+    """Verify each claimed invariant against all reachable states."""
+    # First compute reachable set
+    visited = set()
+    queue = deque([INIT])
+    while queue:
+        s = queue.popleft()
+        if s in visited:
+            continue
+        visited.add(s)
+        for nxt in STATES.get(s, {}).values():
+            if nxt not in visited:
+                queue.append(nxt)
+
+    violations = []
+    for inv in INVARIANTS:
+        try:
+            if not inv["check"](STATES, visited):
+                violations.append(inv["desc"])
+        except Exception as e:
+            violations.append(f"{inv['desc']} — ERROR: {e}")
+
+    return {
+        "pass": len(violations) == 0,
+        "violations": violations,
+        "detail": f"Invariant violations: {violations}" if violations else "All invariants hold",
+    }
+
+# =============================================================================
+# PHASE 2b: ADVERSARIAL PROBES
+# =============================================================================
+
+def step(current, events):
+    """Simulate a sequence of events from current state. Returns final state."""
+    s = current
+    for e in events:
+        if s in TERMINALS:
+            break
+        trans = STATES.get(s, {})
+        # Exact match first
+        if e in trans:
+            s = trans[e]
+        else:
+            # Try matching guard variants — pick the first matching base event
+            base_match = None
+            for evt, target in trans.items():
+                if evt.startswith(e) or e.startswith(evt.split("(")[0].strip()):
+                    base_match = target
+                    break
+            if base_match:
+                s = base_match
+            # else: event ignored (unhandled) — stay in current state
+    return s
+
+def A1_unexpected_event():
+    """Inject every event into every state that doesn't handle it."""
+    events = all_events()
+    findings = []
+    for s in sorted(all_states()):
+        if s in TERMINALS:
+            continue
+        handled = set(STATES.get(s, {}).keys())
+        unhandled = events - handled
+        if unhandled:
+            findings.append({
+                "state": s,
+                "unhandled": sorted(unhandled),
+                "risk": "Event silently ignored — may represent undefined behavior",
+            })
+    return {
+        "pass": len(findings) == 0,
+        "findings": findings,
+        "detail": f"{len(findings)} states with unhandled events" if findings else "All event/state combinations defined",
+    }
+
+def A2_race_interleaving():
+    """For each concurrent pair, test both arrival orders."""
+    if not CONCURRENT_PAIRS:
+        return {"pass": True, "findings": [], "detail": "No concurrent pairs defined — skipped"}
+
+    findings = []
+    for e1, e2 in CONCURRENT_PAIRS:
+        # Test from each state where both events are possible
+        for s in sorted(all_states()):
+            trans = STATES.get(s, {})
+            if e1 not in trans and e2 not in trans:
+                continue
+            final_e1e2 = step(s, [e1, e2])
+            final_e2e1 = step(s, [e2, e1])
+            if final_e1e2 != final_e2e1:
+                findings.append({
+                    "state": s,
+                    "pair": (e1, e2),
+                    "final_e1_then_e2": final_e1e2,
+                    "final_e2_then_e1": final_e2e1,
+                    "risk": "Order-dependent outcome",
+                })
+    return {
+        "pass": len(findings) == 0,
+        "findings": findings,
+        "detail": f"{len(findings)} order-dependent race conditions" if findings else "No race conditions detected",
+    }
+
+def A3_order_permutation():
+    """Test if different event orderings produce different terminal states."""
+    events = sorted(all_events())
+    if len(events) > 5:
+        # Too many permutations — sample subset
+        events = events[:5]
+
+    # Find event sequences that reach different terminals
+    terminal_sets = []
+    for perm in permutations(events):
+        final = step(INIT, list(perm))
+        terminal_sets.append((list(perm), final))
+
+    unique_terminals = set(t[1] for t in terminal_sets)
+
+    findings = []
+    if len(unique_terminals) > 1:
+        # Find the sequences producing each terminal
+        by_terminal = {}
+        for seq, term in terminal_sets:
+            by_terminal.setdefault(term, []).append(seq)
+        findings.append({
+            "terminal_states": sorted(unique_terminals),
+            "sequences": {t: seqs[0] for t, seqs in by_terminal.items()},
+            "risk": f"Same events produce {len(unique_terminals)} different outcomes",
+        })
+
+    return {
+        "pass": len(findings) == 0,
+        "findings": findings,
+        "detail": f"Order-dependent: {len(unique_terminals)} different outcomes" if findings else "Order-independent",
+    }
+
+def A4_pair_symmetry():
+    """Check lock/unlock, alloc/free, start/stop symmetry."""
+    if not PAIRS:
+        return {"pass": True, "findings": [], "detail": "No paired operations defined — skipped"}
+
+    events = all_events()
+    findings = []
+
+    for acquire, release in PAIRS:
+        # Check if this pair type is even used in the model
+        acquire_events = [e for e in events if acquire in e.lower()]
+        release_events = [e for e in events if release in e.lower()]
+
+        if not acquire_events and not release_events:
+            continue
+
+        # Simple check: for each acquire event, is there a corresponding release?
+        # More sophisticated: every path that contains acquire must contain release
+        # before reaching a terminal state or another acquire.
+
+        # Quick heuristic: count occurrences in transition targets
+        acquire_targets = set()
+        release_sources = set()
+        for s, trans in STATES.items():
+            for e, t in trans.items():
+                if any(ae in e.lower() for ae in acquire_events):
+                    acquire_targets.add(t)
+                if any(re in e.lower() for re in release_events):
+                    release_sources.add(s)
+
+        if acquire_targets and not release_sources:
+            findings.append({
+                "pair": (acquire, release),
+                "risk": f"'{acquire}' used but no '{release}' found — resource leak likely",
+            })
+
+    return {
+        "pass": len(findings) == 0,
+        "findings": findings,
+        "detail": f"Asymmetric pairs: {findings}" if findings else "All pairs balanced",
+    }
+
+def A5_boundary_blast():
+    """Probe counter/timer boundary values."""
+    if not BOUNDARY_VARS:
+        return {"pass": True, "findings": [], "detail": "No boundary variables defined — skipped"}
+
+    findings = []
+    for var in BOUNDARY_VARS:
+        name = var["name"]
+        max_val = var.get("max_valid", 255)
+        vtype = var.get("type", "counter")
+
+        test_values = [0, 1, max_val - 1, max_val, max_val + 1]
+        if vtype == "counter":
+            test_values += [2**8 - 1, 2**16 - 1, 2**32 - 1]
+
+        for tv in test_values:
+            if tv < 0 or tv > max_val:
+                findings.append({
+                    "variable": name,
+                    "tested_value": tv,
+                    "max_valid": max_val,
+                    "risk": f"Value {tv} exceeds max valid {max_val} — overflow possible",
+                })
+
+        if vtype == "timestamp":
+            findings.append({
+                "variable": name,
+                "risk": "Timestamp wraparound — verify elapsed_ms() / elapsed_ticks() handle wraparound correctly",
+            })
+
+    return {
+        "pass": len(findings) == 0,
+        "findings": findings,
+        "detail": f"Boundary issues: {len(findings)}" if findings else "Boundary checks passed",
+    }
+
+def A6_resource_injection():
+    """Simulate resource failures at each state."""
+    # Heuristic: identify states that likely allocate resources
+    findings = []
+    for s in sorted(all_states()):
+        if s in TERMINALS:
+            continue
+        state_lower = s.lower()
+        events_lower = [e.lower() for e in STATES.get(s, {}).keys()]
+
+        # Does this state look like it allocates resources?
+        alloc_keywords = ["alloc", "create", "init", "start", "open", "connect", "begin"]
+        has_alloc = any(kw in state_lower or any(kw in e for e in events_lower) for kw in alloc_keywords)
+
+        if not has_alloc:
+            continue
+
+        # Does it have an error recovery path?
+        error_keywords = ["error", "fail", "retry", "timeout", "recover", "fatal"]
+        has_recovery = any(any(kw in e for e in events_lower) for kw in error_keywords)
+
+        if not has_recovery:
+            findings.append({
+                "state": s,
+                "risk": f"State '{s}' may allocate resources but has no visible error recovery path",
+            })
+
+    return {
+        "pass": len(findings) == 0,
+        "findings": findings,
+        "detail": f"Resource vulnerability: {len(findings)} states" if findings else "No resource vulnerabilities detected",
+    }
+
+def A7_shortest_violation(invariant_results):
+    """Find shortest violating path for each failed invariant (requires re-running with path tracking)."""
+    if not INVARIANTS:
+        return {"pass": True, "findings": [], "detail": "No invariants defined — skipped"}
+
+    findings = []
+    for inv in INVARIANTS:
+        # BFS to find shortest path to violation
+        queue = deque([(INIT, [])])
+        visited = set()
+        found = None
+
+        while queue and not found:
+            s, path = queue.popleft()
+            if s in visited:
+                continue
+            visited.add(s)
+
+            try:
+                if not inv["check"](STATES, {s}):
+                    found = path
+                    break
+            except Exception:
+                found = path
+                break
+
+            for event, nxt in STATES.get(s, {}).items():
+                if nxt not in visited:
+                    queue.append((nxt, path + [(s, event, nxt)]))
+
+        if found:
+            findings.append({
+                "invariant": inv["desc"],
+                "violating_path": found,
+                "path_length": len(found),
+            })
+
+    return {
+        "pass": len(findings) == 0,
+        "findings": findings,
+        "detail": f"Violated invariants: {len(findings)}" if findings else "All invariants hold for all reachable paths",
+    }
+
+# =============================================================================
+# S8 / A8-A11 / D1-D4
+# =============================================================================
+
+def S8_monotonic_variables():
+    findings = []
+    for var in MONOTONIC_VARS:
+        direction = var.get('direction')
+        name = var.get('name', '?')
+        if direction == 'inc':
+            for event in var.get('decrease_events', []):
+                findings.append({'code': 'S8_MONOTONIC_DECREASE', 'severity': 'error', 'message': f'Monotonic inc variable {name} decreased by {event}', 'evidence': {'variable': name, 'event': event}})
+        elif direction == 'dec':
+            for event in var.get('increase_events', []):
+                findings.append({'code': 'S8_MONOTONIC_INCREASE', 'severity': 'error', 'message': f'Monotonic dec variable {name} increased by {event}', 'evidence': {'variable': name, 'event': event}})
+    return {'pass': len(findings) == 0, 'findings': findings, 'detail': 'Monotonic variables respected' if not findings else f'{len(findings)} monotonic violations'}
+
+
+def A8_idempotent_replay():
+    findings = []
+    for event in IDEMPOTENT_EVENTS:
+        for state in sorted(all_states()):
+            if event not in STATES.get(state, {}):
+                continue
+            once = STATES[state][event]
+            twice = STATES.get(once, {}).get(event)
+            if twice is None:
+                findings.append({'code': 'A8_NOT_REPLAYABLE', 'severity': 'warning', 'message': f'Idempotent event {event} not replayable from {state}', 'evidence': {'state': state, 'event': event}})
+            elif twice != once:
+                findings.append({'code': 'A8_NOT_IDEMPOTENT', 'severity': 'error', 'message': f'Idempotent event {event} changes state from {state}', 'evidence': {'state': state, 'event': event, 'once': once, 'twice': twice}})
+    return {'pass': len(findings) == 0, 'findings': findings, 'detail': 'Idempotent events replay-safe' if not findings else f'{len(findings)} idempotent findings'}
+
+
+def A9_leads_to():
+    findings = []
+    for from_state, to_state in LEADS_TO:
+        visited = set()
+        queue = deque([from_state])
+        bad = False
+        while queue:
+            state = queue.popleft()
+            if state == to_state:
+                continue
+            if state in visited:
+                bad = True
+                break
+            visited.add(state)
+            nexts = list(STATES.get(state, {}).values())
+            if not nexts:
+                bad = True
+                break
+            for nxt in nexts:
+                queue.append(nxt)
+        if bad:
+            findings.append({'code': 'A9_LEADS_TO_VIOLATION', 'severity': 'error', 'message': f'State {from_state} does not always lead to {to_state}', 'evidence': {'from': from_state, 'to': to_state}})
+    return {'pass': len(findings) == 0, 'findings': findings, 'detail': 'Leads-to invariants hold' if not findings else f'{len(findings)} leads-to violations'}
+
+
+def A10_sequence_order():
+    findings = []
+    for seq in SEQUENCES:
+        visited = set()
+        queue = deque([(INIT, 0, [])])
+        violation = None
+        while queue:
+            state, progress, path = queue.popleft()
+            key = (state, progress)
+            if key in visited:
+                continue
+            visited.add(key)
+            for event, nxt in STATES.get(state, {}).items():
+                p = progress
+                bad = False
+                if p < len(seq) and event == seq[p]:
+                    p += 1
+                else:
+                    idx = seq.index(event) if event in seq else -1
+                    if idx > p:
+                        bad = True
+                new_path = path + [event]
+                if bad:
+                    violation = new_path
+                    break
+                queue.append((nxt, p, new_path))
+            if violation:
+                break
+        if violation:
+            findings.append({'code': 'A10_SEQUENCE_VIOLATION', 'severity': 'error', 'message': f'Sequence {seq} violated by path {violation}', 'evidence': {'sequence': seq, 'path': violation}})
+    return {'pass': len(findings) == 0, 'findings': findings, 'detail': 'Sequence orders hold' if not findings else f'{len(findings)} sequence violations'}
+
+
+def A11_atomicity():
+    findings = []
+    for group in ATOMIC_GROUPS:
+        atomic = set(group.get('events', []))
+        commit = group.get('commit')
+        rollback = group.get('rollback')
+        visited = set()
+        queue = deque([(INIT, False, False, [])])
+        violation = None
+        while queue:
+            state, started, closed, path = queue.popleft()
+            key = (state, started, closed)
+            if key in visited:
+                continue
+            visited.add(key)
+            for event, nxt in STATES.get(state, {}).items():
+                ns = started or event in atomic
+                nc = closed or event == commit or (rollback is not None and event == rollback)
+                new_path = path + [event]
+                if started and not closed and event not in atomic and event != commit and event != rollback:
+                    violation = (new_path, 'left atomic scope')
+                    break
+                if ns and not nc and nxt in TERMINALS:
+                    violation = (new_path, 'terminal with incomplete atomic group')
+                    break
+                queue.append((nxt, ns, nc, new_path))
+            if violation:
+                break
+        if violation:
+            findings.append({'code': 'A11_ATOMICITY_VIOLATION', 'severity': 'error', 'message': f'Atomicity violated: {violation[1]}', 'evidence': {'group': group, 'path': violation[0]}})
+    return {'pass': len(findings) == 0, 'findings': findings, 'detail': 'Atomicity invariants hold' if not findings else f'{len(findings)} atomicity violations'}
+
+
+def D1_behavioral_preservation():
+    findings = []
+    if not BEFORE_STATES:
+        return {'pass': True, 'findings': [], 'detail': 'No before model — skipped'}
+    for state, trans in BEFORE_STATES.items():
+        mapped = STATE_MAPPING.get(state, state)
+        for event in trans:
+            if event not in STATES.get(mapped, {}):
+                findings.append({'code': 'D1_EVENT_DISABLED', 'severity': 'error', 'message': f'BEFORE event {event} disabled in AFTER state {mapped}', 'evidence': {'beforeState': state, 'mappedState': mapped, 'event': event}})
+    return {'pass': len(findings) == 0, 'findings': findings, 'detail': 'Behavior preserved' if not findings else f'{len(findings)} behavior regressions'}
+
+
+def D2_invariant_continuity():
+    if not BEFORE_STATES:
+        return {'pass': True, 'findings': [], 'detail': 'No before model — skipped'}
+    return {'pass': True, 'findings': [], 'detail': 'Invariant continuity requires structured invariants; use DSH or data-model harness for full check'}
+
+
+def D3_delta_summary():
+    findings = []
+    if not BEFORE_STATES:
+        return {'pass': True, 'findings': [], 'detail': 'No before model — skipped'}
+    before_events = {e for t in BEFORE_STATES.values() for e in t}
+    after_events = all_events()
+    before_states = set(BEFORE_STATES)
+    after_states = all_states()
+    removed_states = sorted(before_states - after_states)
+    added_states = sorted(after_states - before_states)
+    removed_events = sorted(before_events - after_events)
+    added_events = sorted(after_events - before_events)
+    for state in removed_states:
+        findings.append({'code': 'D3_REMOVED_STATE', 'severity': 'warning', 'message': f'BEFORE state {state} removed', 'evidence': {'state': state}})
+    for event in removed_events:
+        findings.append({'code': 'D3_REMOVED_EVENT', 'severity': 'warning', 'message': f'BEFORE event {event} removed', 'evidence': {'event': event}})
+    detail = f'Delta: +{len(added_states)} states, -{len(removed_states)} states, +{len(added_events)} events, -{len(removed_events)} events'
+    return {'pass': True, 'findings': findings, 'detail': detail}
+
+
+def D4_deadlock_liveness_regression():
+    findings = []
+    if not BEFORE_STATES:
+        return {'pass': True, 'findings': [], 'detail': 'No before model — skipped'}
+    def deadlock_set(states, terminals):
+        return {s for s in states if s not in terminals and len(states.get(s, {})) == 0}
+    before_dead = deadlock_set(BEFORE_STATES, BEFORE_TERMINALS)
+    after_dead = deadlock_set(STATES, TERMINALS)
+    mapped_before_dead = {STATE_MAPPING.get(s, s) for s in before_dead}
+    for state in sorted(after_dead):
+        if state not in mapped_before_dead:
+            findings.append({'code': 'D4_DEADLOCK_REGRESSION', 'severity': 'error', 'message': f'AFTER introduces deadlock in {state}', 'evidence': {'state': state}})
+    return {'pass': len(findings) == 0, 'findings': findings, 'detail': 'No deadlock regressions' if not findings else f'{len(findings)} deadlock regressions'}
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def run_all():
+    results = {}
+    errors = 0
+    warnings = 0
+
+    print("=" * 60)
+    print("PHASE 2a: STRUCTURAL PRIMITIVES")
+    print("=" * 60)
+
+    checks_2a = [
+        ("S1 Reachability", S1_reachability),
+        ("S2 Deadlock", S2_deadlock),
+        ("S3 Liveness", S3_liveness),
+        ("S4 Determinism", S4_determinism),
+        ("S5 Event Completeness", S5_event_completeness),
+        ("S6 Guard Completeness", S6_guard_completeness),
+        ("S7 Invariants", S7_invariants),
+        ("S8 Monotonic Variables", S8_monotonic_variables),
+    ]
+
+    for name, check_fn in checks_2a:
+        result = check_fn()
+        results[name] = result
+        status = "PASS" if result["pass"] else "FAIL"
+        prefix = "  " if result["pass"] else "  [!] "
+        print(f"{prefix}[{status}] {name}: {result['detail']}")
+        if not result["pass"]:
+            if "Warning" in str(type(check_fn)):
+                warnings += 1
+            else:
+                errors += 1
+
+    print()
+    print("=" * 60)
+    print("PHASE 2b: ADVERSARIAL PROBES")
+    print("=" * 60)
+
+    probes_2b = [
+        ("A1 Unexpected Event", A1_unexpected_event),
+        ("A2 Race Interleaving", A2_race_interleaving),
+        ("A3 Order Permutation", A3_order_permutation),
+        ("A4 Pair Symmetry", A4_pair_symmetry),
+        ("A5 Boundary Blast", A5_boundary_blast),
+        ("A6 Resource Injection", A6_resource_injection),
+        ("A7 Shortest Violation", lambda: A7_shortest_violation(results.get("S7 Invariants", {}))),
+        ("A8 Idempotent Replay", A8_idempotent_replay),
+        ("A9 Leads-To", A9_leads_to),
+        ("A10 Sequence Order", A10_sequence_order),
+        ("A11 Atomicity", A11_atomicity),
+    ]
+
+    for name, probe_fn in probes_2b:
+        result = probe_fn()
+        results[name] = result
+        status = "PASS" if result["pass"] else "FAIL"
+        prefix = "  " if result["pass"] else "  [!] "
+        print(f"{prefix}[{status}] {name}: {result['detail']}")
+        if not result["pass"]:
+            warnings += 1  # Probe failures are warnings by default (may be false positives)
+
+    if BEFORE_STATES:
+        print()
+        print("=" * 60)
+        print("PHASE 2c: BEFORE/AFTER REGRESSION")
+        print("=" * 60)
+        diff_checks = [
+            ("D1 Behavioral Preservation", D1_behavioral_preservation),
+            ("D2 Invariant Continuity", D2_invariant_continuity),
+            ("D3 Delta Summary", D3_delta_summary),
+            ("D4 Deadlock/Liveness Regression", D4_deadlock_liveness_regression),
+        ]
+        for name, check_fn in diff_checks:
+            result = check_fn()
+            results[name] = result
+            status = "PASS" if result["pass"] else "FAIL"
+            prefix = "  " if result["pass"] else "  [!] "
+            print(f"{prefix}[{status}] {name}: {result['detail']}")
+            if not result["pass"]:
+                errors += 1
+
+    print()
+    print("=" * 60)
+    print(f"SUMMARY: {errors} structural errors, {warnings} probe/other warnings")
+    print("=" * 60)
+
+    if errors > 0:
+        print()
+        print("ACTION: Fix structural errors before proceeding to Phase 3.")
+        print("Structural errors indicate the plan's logic is incomplete or inconsistent.")
+
+    if warnings > 0 and errors == 0:
+        print()
+        print("ACTION: Review probe warnings — may be false positives or acceptable risks.")
+        print("Escalate confirmed findings to Phase 3 gap analysis.")
+
+    return errors, warnings, results
+
+
+if __name__ == "__main__":
+    errors, warnings, results = run_all()
+    sys.exit(1 if errors > 0 else 0)