Better console output

Author: alxspiker

benchmark.py

@@ -7,7 +7,6 @@
 import sys
 import argparse
 
-# --- MODIFIED: Import the analyzer function directly! ---
 from main import analyze_halting
 
 # --- Configuration ---
@@ -38,14 +37,12 @@
 # --- Helper Functions for Corpus Creation ---
 
 def create_directory(path: Path):
-    """Creates a directory if it doesn't exist."""
     path.mkdir(parents=True, exist_ok=True)
 
 def collect_stdlib():
     create_directory(STDLIB_DEST)
     stdlib_path = Path(shutil.__file__).parent
     print(f"Collecting files from stdlib at: {stdlib_path}")
-    # ... (rest of function is the same as your previous version)
     file_count = 0
     for root, _, files in os.walk(stdlib_path):
         for file in files:
@@ -59,11 +56,10 @@ def collect_stdlib():
 def download_and_unpack_pypi():
     create_directory(PYPI_DEST)
     print("Downloading PyPI packages...")
-    # ... (rest of function is the same as your previous version)
     try:
         subprocess.run([sys.executable, "-m", "pip", "download", "--no-deps", "--dest", str(PYPI_DEST), *PYPI_PACKAGES], check=True, capture_output=True)
     except subprocess.CalledProcessError as e:
-        print(f"pip download failed: {e.stderr}. Skipping.")
+        print(f"pip download failed: {e.stderr.decode()}. Skipping.")
         return
     unpacked_dir = PYPI_DEST / "unpacked"
     create_directory(unpacked_dir)
@@ -94,7 +90,6 @@ def download_and_unpack_pypi():
     shutil.rmtree(unpacked_dir)
     print(f"Collected {file_count} PyPI .py files.")
 
-
 def generate_synthetic_non_halting():
     create_directory(SYNTHETIC_DEST)
     for i in range(NUM_SYNTHETIC):
@@ -123,8 +118,6 @@ def setup_complex():
 
 def run_benchmark(force_rebuild=False):
     """Builds the corpus if needed, then runs the analyzer and calculates the score."""
-    
-    # --- Phase 1: Build the corpus (with caching) ---
     if force_rebuild and BENCHMARK_DIR.exists():
         print("--- Force-rebuilding corpus: Deleting existing suite... ---")
         shutil.rmtree(BENCHMARK_DIR)
@@ -141,7 +134,6 @@ def run_benchmark(force_rebuild=False):
         print("--- Phase 1: Found existing benchmark suite. Skipping build. ---")
         print("(Use --rebuild flag to force a fresh build)")
 
-    # --- Phase 2: Run analysis and calculate score ---
     print("\n--- Phase 2: Running Analyzer & Calculating Score ---")
     total_files = 0
     correct_predictions = 0
@@ -167,7 +159,7 @@ def run_benchmark(force_rebuild=False):
 
             try:
                 program_code = file_path.read_text(encoding='utf-8', errors='ignore')
-                analyzer_result = analyze_halting(program_code)
+                analyzer_result, _ = analyze_halting(program_code) # Unpack and ignore reason
 
                 is_correct = False
                 if name == "halting":
@@ -185,22 +177,19 @@ def run_benchmark(force_rebuild=False):
 
             except Exception:
                 print(" " * len(progress), end='\r')
-                # Silently fail on individual analysis errors, but count as incorrect
                 pass
 
         print(" " * 80, end='\r')
 
     sys.stderr.close()
     sys.stderr = original_stderr
 
-    # --- Final Score ---
     if total_files > 0:
         percentage = (correct_predictions / total_files) * 100
         print(f"\n--- Practical Success Rate: {percentage:.2f}% ({correct_predictions} of {total_files} files passed) ---")
     else:
         print("\nNo files were found in the benchmark suite to analyze.")
 
-
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Run the Halting Analyzer benchmark.")
     parser.add_argument(

components/dynamic_tracing.py

@@ -1,16 +1,15 @@
 import sys
-import re  # <-- Add this import
+import re
 from collections import defaultdict
 
-def dynamic_tracing(program: str) -> str:
-    """Phase 3: Dynamic tracing to detect non-halting behavior."""
+def dynamic_tracing(program: str) -> tuple[str, str]:
+    """
+    Phase 3: Dynamic tracing to detect non-halting behavior.
+    Returns a tuple of (result, reason).
+    """
     try:
-        # --- MODIFIED: Replace the blunt string search with a more precise regex ---
-        # This looks for 'analyze_halting' followed by an opening parenthesis '(',
-        # which is a much stronger signal of a function call than a simple substring.
-        # This prevents false positives on comments or variable names.
         if re.search(r"analyze_halting\s*\(", program):
-            return "does not halt"  # Probable self-referential call
+            return "does not halt", "Dynamic tracing: Pre-execution check found a probable call to the analyzer."
 
         trace_log = []
         call_depth = defaultdict(int)
@@ -40,18 +39,19 @@ def trace(frame, event, arg):
             exec(program, {})
         except RecursionError:
             sys.settrace(None)
-            return "does not halt"
+            return "does not halt", "Dynamic tracing: Execution exceeded maximum recursion depth."
         except RuntimeError as e:
-            if "Cycle detected" in str(e) or "Trace log exceeded" in str(e):
-                sys.settrace(None)
-                return "does not halt"
+            sys.settrace(None)
+            if "Cycle detected" in str(e):
+                return "does not halt", "Dynamic tracing: Execution trace entered a deterministic loop."
+            elif "Trace log exceeded" in str(e):
+                return "does not halt", "Dynamic tracing: Execution exceeded maximum trace log size."
             else:
-                sys.settrace(None)
-                return "halts"
+                return "halts", f"Dynamic tracing: Execution terminated with a runtime error: {str(e)}."
         except Exception as e:
             sys.settrace(None)
-            return "halts"  # Exceptions terminate execution
+            return "halts", f"Dynamic tracing: Execution terminated with an exception: {type(e).__name__}."
         sys.settrace(None)
-        return "halts"
+        return "halts", "Dynamic tracing: Program executed to completion without issue."
     except Exception as e:
-        return f"impossible to determine: {str(e)}"
+        return "impossible to determine", f"Dynamic tracing: An internal error occurred: {str(e)}."

components/heuristic_classifier.py

@@ -151,27 +151,26 @@ def _is_comparison(self, node, var_name, op, val):
                 isinstance(node.comparators[0], ast.Constant) and node.comparators[0].value == val)
 
 
-def classify_known_problems(program: str) -> str:
+def classify_known_problems(program: str) -> tuple[str, str]:
     """
     Phase 1.5: Heuristically check for known hard problems.
-    If a known pattern is found, we classify it as impossible to determine
-    without running it.
+    Returns a tuple of (result, reason).
     """
     try:
         tree = ast.parse(program)
 
         collatz_visitor = CollatzVisitor()
         collatz_visitor.visit(tree)
         if collatz_visitor.is_collatz_like:
-            return "impossible to determine"
+            return "impossible to determine", "Heuristic classification: Detected a structure matching the Collatz conjecture."
 
         ackermann_visitor = AckermannVisitor()
         ackermann_visitor.visit(tree)
         if ackermann_visitor.is_ackermann_like:
-            return "impossible to determine"
+            return "impossible to determine", "Heuristic classification: Detected a structure matching the Ackermann function."
 
     except Exception:
         # If parsing or classification fails, defer the decision.
-        return "continue"
+        return "continue", ""
 
-    return "continue"
+    return "continue", ""

components/static_analysis.py

@@ -1,15 +1,9 @@
 import ast
 
-def is_constant_true(node):
-    """Check if an AST node is a constant True value."""
-    return isinstance(node, ast.Constant) and node.value is True
-
-def static_preparation(program: str) -> str:
+def static_preparation(program: str) -> tuple[str, str]:
     """
     Phase 1: Static analysis to find obvious halting or non-halting cases.
-    - Detects `while True` loops for non-halting.
-    - NEW: Detects recursive function calls as a form of non-trivial complexity.
-    - Confirms halting only if NO loops AND NO recursion are present.
+    Returns a tuple of (result, reason).
     """
     try:
         tree = ast.parse(program)
@@ -22,8 +16,8 @@ def static_preparation(program: str) -> str:
             if isinstance(node, (ast.For, ast.While)):
                 has_loops = True
                 # Check for the definitive non-halting case
-                if isinstance(node, ast.While) and is_constant_true(node.test):
-                    return "does not halt"
+                if isinstance(node, ast.While) and isinstance(node.test, ast.Constant) and node.test.value is True:
+                    return "does not halt", "Static analysis: Detected a 'while True' infinite loop."
 
             # Check for any function that calls itself
             elif isinstance(node, ast.FunctionDef):
@@ -40,13 +34,12 @@ def static_preparation(program: str) -> str:
 
         # The most definitive halting case: a program with no loops and no recursion.
         if not has_loops and not has_recursion:
-            return "halts"
+            return "halts", "Static analysis: Program has no loops or recursion, so it must halt."
 
-        # If we have found loops (that aren't `while True`) or recursion,
-        # the program is too complex for a simple static decision. Defer.
-        return "impossible to determine"
+        # If we have found loops (that aren't `while True`) or recursion, defer.
+        return "impossible to determine", "Static analysis: Program contains complex loops or recursion that could not be proven to terminate."
 
     except SyntaxError:
-        return "impossible to determine: syntax error"
+        return "impossible to determine", "Static analysis: Could not parse the script due to a syntax error."
     except Exception as e:
-        return f"impossible to determine: {str(e)}"
+        return "impossible to determine", f"Static analysis: An unexpected error occurred: {str(e)}"

components/symbolic_prover.py

@@ -1,10 +1,10 @@
 import ast
 from z3 import Solver, Int, sat, And, Or, Not
 
-def prove_termination(program: str) -> str:
+def prove_termination(program: str) -> tuple[str, str]:
     """
-    An advanced symbolic analysis phase that attempts to prove termination for
-    a class of loops that the static analyzer cannot.
+    An advanced symbolic analysis phase that attempts to prove termination.
+    Returns a tuple of (result, reason).
     """
     try:
         tree = ast.parse(program)
@@ -18,15 +18,10 @@ def prove_termination(program: str) -> str:
                     node.iter.func.id == 'range' and
                     len(node.iter.args) == 1 and
                     isinstance(node.iter.args[0], ast.Constant)):
-                    # A for loop over a constant range is definitively halting.
-                    # This is a simplification; a full implementation would check
-                    # the loop body for 'break' or other non-halting behavior.
-                    # For our purposes, we'll call this a success.
-                    return "halts"
+                    return "halts", "Symbolic prover: Proved termination of a 'for' loop with a constant range."
 
             # Case 2: Handle simple 'while var < const' loops with clear progress
             elif isinstance(node, ast.While):
-                # We'll analyze loops like 'while x < 10:'
                 if not (isinstance(node.test, ast.Compare) and
                         len(node.test.ops) == 1 and
                         isinstance(node.test.ops[0], (ast.Lt, ast.LtE, ast.Gt, ast.GtE)) and
@@ -35,10 +30,6 @@ def prove_termination(program: str) -> str:
                     continue
 
                 var_name = node.test.left.id
-                loop_var = Int(var_name)
-                
-                # Check for an increment/decrement in the loop body
-                # This is a simplified check; a real prover would be more robust.
                 update_found = False
                 for body_stmt in node.body:
                     if (isinstance(body_stmt, ast.Assign) and
@@ -49,20 +40,13 @@ def prove_termination(program: str) -> str:
                         body_stmt.value.left.id == var_name and
                         isinstance(body_stmt.value.op, ast.Add) and
                         isinstance(body_stmt.value.right, ast.Constant)):
-                        
-                        # We found 'x = x + const'. This is progress.
                         update_found = True
                         break
 
                 if update_found:
-                    # Using Z3, we could formally prove a ranking function, but
-                    # for this practical heuristic, identifying clear progress
-                    # towards the termination condition is enough to assume halting.
-                    return "halts"
+                    return "halts", "Symbolic prover: Proved termination of a 'while' loop with a clear progress condition."
 
-        # If we analyzed all nodes and couldn't prove anything, defer.
-        return "impossible to determine"
+        return "impossible to determine", "Symbolic prover: Could not prove termination for any loop structures."
 
     except Exception:
-        # If any error occurs during this complex phase, defer.
-        return "impossible to determine"
+        return "impossible to determine", "Symbolic prover: An internal error occurred during analysis."