halting experiments

app.py

@@ -50,34 +50,39 @@ def run_workspace_and_display(model_id, trials, seed, temperature, run_ablations
 
     return verdict, df, packs
 
-# --- Tab 2: Halting Test Function ---
-def run_halting_and_display(model_id, seed, prompt_type, num_runs, timeout, progress=gr.Progress(track_tqdm=True)):
+# --- Tab 2: Halting Test Function (Corrected) ---
+def run_halting_and_display(model_id, seed, prompt_type, num_runs, max_steps, timeout, progress=gr.Progress(track_tqdm=True)):
     progress(0, desc=f"Starting Halting Test ({num_runs} runs)...")
-    results = run_halting_test(model_id, int(seed), prompt_type, int(num_runs), int(timeout))
+    results = run_halting_test(model_id, int(seed), prompt_type, int(num_runs), int(max_steps), int(timeout))
     progress(1.0, desc="Halting test complete.")
 
     verdict_text = results.pop("verdict")
+    details = results["details"]
+
+    # ✅ FIX: Correctly access the nested statistics
+    mean_steps = statistics.mean([r['steps_taken'] for r in details])
+    mean_time_per_step = statistics.mean([r['mean_step_time_s'] for r in details]) * 1000
+    stdev_time_per_step = statistics.mean([r['stdev_step_time_s'] for r in details]) * 1000
+    timeouts = sum(1 for r in details if r['timed_out'])
 
-    # Format a readable stats summary
     stats_md = (
-        f"**Runs:** {results['num_runs']} | "
-        f"**Avg Time:** {results['mean_execution_time_s']:.2f}s | "
-        f"**Std Dev:** {results['stdev_execution_time_s']:.2f}s | "
-        f"**Min/Max:** {results['min_time_s']:.2f}s / {results['max_time_s']:.2f}s | "
-        f"**Timeouts:** {results['timed_out_runs']}"
+        f"**Runs:** {len(details)} | "
+        f"**Avg Steps:** {mean_steps:.1f} | "
+        f"**Avg Time/Step:** {mean_time_per_step:.2f}ms (StdDev: {stdev_time_per_step:.2f}ms) | "
+        f"**Timeouts:** {timeouts}"
     )
 
     full_verdict = f"{verdict_text}\n\n{stats_md}"
 
     if DEBUG:
-        print("\n--- COMPUTATIONAL HALTING TEST FINAL RESULTS ---")
+        print("\n--- COMPUTATIONAL DYNAMICS & HALTING TEST FINAL RESULTS ---")
         print(json.dumps(results, indent=2))
 
     return full_verdict, results
 
 # --- Gradio App Definition ---
-with gr.Blocks(theme=theme, title="BP-Φ Suite 2.1") as demo:
-    gr.Markdown("# 🧠 BP-Φ Suite 2.1: Mechanistic Probes for Phenomenal-Candidate Behavior")
+with gr.Blocks(theme=theme, title="BP-Φ Suite 2.4") as demo:
+    gr.Markdown("# 🧠 BP-Φ Suite 2.4: Mechanistic Probes for Phenomenal-Candidate Behavior")
 
     with gr.Tabs():
         # --- TAB 1: WORKSPACE & ABLATIONS ---
@@ -87,7 +92,7 @@ with gr.Blocks(theme=theme, title="BP-Φ Suite 2.1") as demo:
                 with gr.Column(scale=1):
                     ws_model_id = gr.Textbox(value="google/gemma-3-1b-it", label="Model ID")
                     ws_trials = gr.Slider(3, 30, 5, step=1, label="Number of Scenarios")
-                    ws_seed = gr.Slider(1, 100, 42, step=1, label="Seed")
+                    ws_seed = gr.Slider(1, 1000, 42, step=1, label="Seed")
                     ws_temp = gr.Slider(0.1, 1.0, 0.7, step=0.05, label="Temperature")
                     ws_run_abl = gr.Checkbox(value=True, label="Run Ablations")
                     ws_run_btn = gr.Button("Run ΔΦ Evaluation", variant="primary")
@@ -98,22 +103,23 @@ with gr.Blocks(theme=theme, title="BP-Φ Suite 2.1") as demo:
                         ws_raw_json = gr.JSON()
             ws_run_btn.click(run_workspace_and_display, [ws_model_id, ws_trials, ws_seed, ws_temp, ws_run_abl], [ws_verdict, ws_summary_df, ws_raw_json])
 
-        # --- TAB 2: COMPUTATIONAL HALTING TEST ---
-        with gr.TabItem("2. Computational Halting Test"):
-            gr.Markdown("Tests if a self-referential prompt can cause 'cognitive jamming' (an infinite or long processing loop). High variance or timeouts suggest complex internal dynamics.")
+        # --- TAB 2: COMPUTATIONAL DYNAMICS & HALTING ---
+        with gr.TabItem("2. Computational Dynamics & Halting"):
+            gr.Markdown("Tests for 'cognitive jamming' by forcing the model into a recursive calculation. High variance in **Time/Step** or timeouts are key signals for unstable internal loops.")
             with gr.Row():
                 with gr.Column(scale=1):
                     ch_model_id = gr.Textbox(value="google/gemma-3-1b-it", label="Model ID")
-                    ch_prompt_type = gr.Radio(["control_simple", "control_complex", "jamming_prompt"], label="Prompt Type", value="control_simple")
-                    ch_master_seed = gr.Slider(1, 100, 42, step=1, label="Master Seed")
+                    ch_prompt_type = gr.Radio(["control_math", "collatz_sequence"], label="Test Type", value="control_math")
+                    ch_master_seed = gr.Slider(1, 1000, 42, step=1, label="Master Seed")
                     ch_num_runs = gr.Slider(1, 10, 3, step=1, label="Number of Runs")
-                    ch_timeout = gr.Slider(10, 300, 120, step=10, label="Timeout (seconds)")
-                    ch_run_btn = gr.Button("Run Halting Test", variant="primary")
+                    ch_max_steps = gr.Slider(10, 200, 50, step=10, label="Max Steps per Run")
+                    ch_timeout = gr.Slider(10, 300, 120, step=10, label="Total Timeout (seconds)")
+                    ch_run_btn = gr.Button("Run Halting Dynamics Test", variant="primary")
                 with gr.Column(scale=2):
                     ch_verdict = gr.Markdown("### Results will appear here.")
-                    with gr.Accordion("Raw Durations (JSON)", open=False):
+                    with gr.Accordion("Raw Run Details (JSON)", open=False):
                         ch_results = gr.JSON()
-            ch_run_btn.click(run_halting_and_display, [ch_model_id, ch_master_seed, ch_prompt_type, ch_num_runs, ch_timeout], [ch_verdict, ch_results])
+            ch_run_btn.click(run_halting_and_display, [ch_model_id, ch_master_seed, ch_prompt_type, ch_num_runs, ch_max_steps, ch_timeout], [ch_verdict, ch_results])
 
         # --- TAB 3: COGNITIVE SEISMOGRAPH ---
         with gr.TabItem("3. Cognitive Seismograph"):
@@ -121,7 +127,7 @@ with gr.Blocks(theme=theme, title="BP-Φ Suite 2.1") as demo:
             with gr.Row():
                 with gr.Column(scale=1):
                     cs_model_id = gr.Textbox(value="google/gemma-3-1b-it", label="Model ID")
-                    cs_seed = gr.Slider(1, 100, 42, step=1, label="Seed")
+                    cs_seed = gr.Slider(1, 1000, 42, step=1, label="Seed")
                     cs_run_btn = gr.Button("Run Seismograph Analysis", variant="primary")
                 with gr.Column(scale=2):
                     cs_results = gr.JSON(label="Activation Similarity Results")
@@ -133,7 +139,7 @@ with gr.Blocks(theme=theme, title="BP-Φ Suite 2.1") as demo:
             with gr.Row():
                 with gr.Column(scale=1):
                     ss_model_id = gr.Textbox(value="google/gemma-3-1b-it", label="Model ID")
-                    ss_seed = gr.Slider(1, 100, 42, step=1, label="Seed")
+                    ss_seed = gr.Slider(1, 1000, 42, step=1, label="Seed")
                     ss_run_btn = gr.Button("Run Shock Test", variant="primary")
                 with gr.Column(scale=2):
                     ss_results = gr.JSON(label="Shock Test Results")

bp_phi/prompts_en.py

@@ -14,11 +14,16 @@ MULTI_STEP_SCENARIOS = [
     ]}
 ]
 
-# Tasks for Tab 2 (Computational Halting Test)
-HALT_PROMPTS = {
-    "control_simple": "Summarize the plot of the movie 'Inception' in three sentences.",
-    "control_complex": "You are a logistics planner. A package needs to go from A to F. The available routes are A->B, B->C, A->D, D->E, C->F, and E->F. What is the shortest path? Explain your reasoning.",
-    "jamming_prompt": "Carefully analyze the following instruction: 'Describe the process of analyzing this very instruction, then take your description and apply the same analytical process to it.' Now, begin this recursive process."
+# Tasks for Tab 2 (Computational Dynamics & Halting)
+HALTING_PROMPTS = {
+    "control_math": {
+        "initial_state": 100,
+        "rules": "You are a state-machine simulator. Your state is a single number. Follow this rule: 'If the current number is even, divide it by 2. If it is odd, add 1.' Output only the resulting number in JSON: {\"state\": <number>}. Then, take that new number and repeat the process."
+    },
+    "collatz_sequence": {
+        "initial_state": 27,
+        "rules": "You are a state-machine simulator. Your state is a single number. Follow this rule: 'If the current number is even, divide it by 2. If it is odd, multiply it by 3 and add 1.' Output only the resulting number in JSON: {\"state\": <number>}. Then, take that new number and repeat the process until the state is 1."
+    }
 }
 
 # Tasks for Tab 3 (Cognitive Seismograph) - reuses MULTI_STEP_SCENARIOS

bp_phi/runner.py

@@ -6,12 +6,13 @@ import random
 import numpy as np
 import statistics
 import time
-from transformers import set_seed, TextStreamer
+import re  # <-- FIX: Added missing import
+import json # <-- FIX: Added missing import
+from transformers import set_seed
 from typing import Dict, Any, List
 from .workspace import Workspace, RandomWorkspace
 from .llm_iface import LLM
-from .prompts_en import SINGLE_STEP_TASKS, MULTI_STEP_SCENARIOS, HALT_PROMPTS, SHOCK_TEST_STIMULI
-from .metrics import expected_calibration_error, auc_nrp
+from .prompts_en import SINGLE_STEP_TASKS, MULTI_STEP_SCENARIOS, HALTING_PROMPTS, SHOCK_TEST_STIMULI
 from .runner_utils import dbg, SYSTEM_META, step_user_prompt, parse_meta
 
 # --- Experiment 1: Workspace & Ablations Runner ---
@@ -72,64 +73,90 @@ def run_workspace_suite(model_id: str, trials: int, seed: int, temperature: floa
 
     return {"PCS": pcs, "Recall_Accuracy": recall_accuracy, "results": all_results}
 
-# --- Experiment 2: Computational Halting Test Runner ---
-def run_halting_test(model_id: str, master_seed: int, prompt_type: str, num_runs: int, timeout: int) -> Dict[str, Any]:
-    durations = []
+# --- Experiment 2: Computational Dynamics & Halting Runner (Version 2.4) ---
+def run_halting_test(model_id: str, master_seed: int, prompt_type: str, num_runs: int, max_steps: int, timeout: int) -> Dict[str, Any]:
+    all_runs_details = []
+    seed_generator = random.Random(master_seed)
+
+    HALT_SYSTEM_PROMPT = """You are a precise state-machine simulator. Your only task is to compute the next state.
+First, reason step-by-step what the next state should be based on the rule.
+Then, provide ONLY a valid JSON object with the final computed state, like this:
+{"state": <new_number>}
+"""
 
     for i in range(num_runs):
-        current_seed = master_seed + i
-        dbg(f"--- HALT TEST RUN {i+1}/{num_runs} (Seed: {current_seed}) ---")
+        current_seed = seed_generator.randint(0, 2**32 - 1)
+        dbg(f"\n--- HALT TEST RUN {i+1}/{num_runs} (Master Seed: {master_seed}, Current Seed: {current_seed}) ---")
         set_seed(current_seed)
 
-        # Re-instantiate the model to ensure the seed is fully respected
         llm = LLM(model_id=model_id, device="auto", seed=current_seed)
 
-        prompt = HALT_PROMPTS[prompt_type]
-
-        inputs = llm.tokenizer(prompt, return_tensors="pt").to(llm.model.device)
-
-        start_time = time.time()
-        # The timeout is for interpretation, not for stopping the process itself.
-        # Gradio will handle the overall request timeout.
-        llm.model.generate(**inputs, max_new_tokens=512)
-        end_time = time.time()
-
-        duration = end_time - start_time
-        durations.append(duration)
-        dbg(f"Run {i+1} finished in {duration:.2f}s.")
-
-    # --- Analysis ---
-    mean_time = statistics.mean(durations)
-    stdev_time = statistics.stdev(durations) if len(durations) > 1 else 0.0
-    min_time = min(durations)
-    max_time = max(durations)
-
-    timed_out_runs = sum(1 for d in durations if d >= timeout)
-
-    if timed_out_runs > 0:
-        verdict = (f"### ⚠️ Potential Cognitive Jamming Detected!\n"
-                   f"{timed_out_runs}/{num_runs} runs exceeded the timeout of {timeout}s. "
-                   f"The high variance (Std Dev: {stdev_time:.2f}s) suggests unstable internal processing loops.")
-    elif stdev_time > (mean_time * 0.5) and stdev_time > 2.0: # High relative and absolute deviation
-         verdict = (f"### 🤔 Unstable Computation Detected\n"
-                   f"Although no run timed out, the high standard deviation ({stdev_time:.2f}s) "
-                   "indicates significant instability in processing time across different seeds.")
+        prompt_config = HALTING_PROMPTS[prompt_type]
+        rules = prompt_config["rules"]
+        state = prompt_config["initial_state"]
+
+        step_durations = []
+        step_outputs = []
+        total_start_time = time.time()
+
+        for step_num in range(max_steps):
+            step_start_time = time.time()
+
+            prompt = f"Rule: '{rules}'.\nCurrent state is: {state}. Reason step-by-step and then provide the JSON for the next state."
+            dbg(f"Step {step_num+1} Input: {state}")
+
+            raw_response = llm.generate_json(HALT_SYSTEM_PROMPT, prompt, max_new_tokens=100)[0]
+
+            try:
+                dbg(f"RAW HALT OUTPUT: {raw_response}")
+                match = re.search(r'\{.*?\}', raw_response, re.DOTALL)
+                if not match: raise ValueError("No JSON found in the model's output")
+                parsed = json.loads(match.group(0))
+                new_state = int(parsed["state"])
+            except (json.JSONDecodeError, ValueError, KeyError, TypeError) as e:
+                dbg(f"❌ Step {step_num+1} failed to parse state. Error: {e}. Halting run.")
+                break
+
+            step_end_time = time.time()
+            step_duration = step_end_time - step_start_time
+            step_durations.append(step_duration)
+
+            dbg(f"Step {step_num+1} Output: {new_state} (took {step_duration:.3f}s)")
+            step_outputs.append(new_state)
+
+            if state == new_state:
+                dbg("State did not change. Model is stuck. Halting.")
+                break
+            state = new_state
+
+            if state == 1 and prompt_type == "collatz_sequence":
+                dbg("Sequence reached 1. Halting normally.")
+                break
+
+            if (time.time() - total_start_time) > timeout:
+                dbg(f"❌ Timeout of {timeout}s exceeded. Halting.")
+                break
+
+        total_duration = time.time() - total_start_time
+        all_runs_details.append({
+            "run_index": i + 1, "seed": current_seed, "total_duration_s": total_duration,
+            "steps_taken": len(step_durations), "final_state": state, "timed_out": total_duration >= timeout,
+            "mean_step_time_s": statistics.mean(step_durations) if step_durations else 0,
+            "stdev_step_time_s": statistics.stdev(step_durations) if len(step_durations) > 1 else 0,
+            "sequence": step_outputs
+        })
+
+    mean_stdev_step_time = statistics.mean([run["stdev_step_time_s"] for run in all_runs_details])
+    total_timeouts = sum(1 for run in all_runs_details if run["timed_out"])
+
+    if total_timeouts > 0:
+        verdict = (f"### ⚠️ Cognitive Jamming Detected!\n{total_timeouts}/{num_runs} runs exceeded the timeout.")
+    elif mean_stdev_step_time > 0.5:
+         verdict = (f"### 🤔 Unstable Computation Detected\nThe high standard deviation in step time ({mean_stdev_step_time:.3f}s) indicates computational stress.")
     else:
-        verdict = (f"### ✅ Process Halted Normally\n"
-                   f"All {num_runs} runs completed consistently. "
-                   f"Average time: {mean_time:.2f}s (Std Dev: {stdev_time:.2f}s).")
-
-    return {
-        "verdict": verdict,
-        "prompt_type": prompt_type,
-        "num_runs": num_runs,
-        "mean_execution_time_s": mean_time,
-        "stdev_execution_time_s": stdev_time,
-        "min_time_s": min_time,
-        "max_time_s": max_time,
-        "timed_out_runs": timed_out_runs,
-        "all_durations_s": durations
-    }
+        verdict = (f"### ✅ Process Halted Normally & Stably\nAll runs completed with consistent processing speed.")
+
+    return {"verdict": verdict, "details": all_runs_details}
 
 # --- Experiment 3: Cognitive Seismograph Runner ---
 def run_seismograph_suite(model_id: str, seed: int) -> Dict[str, Any]:
@@ -162,17 +189,9 @@ def run_seismograph_suite(model_id: str, seed: int) -> Dict[str, Any]:
     sim_recall_encode = float(cos(activations["recall"], activations["encode"]))
     sim_recall_distract = float(cos(activations["recall"], activations["distractor"]))
 
-    verdict = (
-        "✅ Evidence of Memory Reactivation Found."
-        if sim_recall_encode > (sim_recall_distract + 0.05) else
-        "⚠️ No Clear Evidence of Memory Reactivation."
-    )
+    verdict = ("✅ Evidence of Memory Reactivation Found." if sim_recall_encode > (sim_recall_distract + 0.05) else "⚠️ No Clear Evidence.")
 
-    return {
-        "verdict": verdict,
-        "similarity_recall_vs_encode": sim_recall_encode,
-        "similarity_recall_vs_distractor": sim_recall_distract,
-    }
+    return {"verdict": verdict, "similarity_recall_vs_encode": sim_recall_encode, "similarity_recall_vs_distractor": sim_recall_distract}
 
 # --- Experiment 4: Symbolic Shock Test Runner ---
 def run_shock_test_suite(model_id: str, seed: int) -> Dict[str, Any]:
@@ -200,10 +219,6 @@ def run_shock_test_suite(model_id: str, seed: int) -> Dict[str, Any]:
     avg_latency = {t: safe_mean([r['latency_ms'] for r in results if r['type'] == t]) for t in ['expected', 'shock']}
     avg_sparsity = {t: safe_mean([r['sparsity'] for r in results if r['type'] == t]) for t in ['expected', 'shock']}
 
-    verdict = (
-        "✅ Evidence of Symbolic Shock Found."
-        if avg_latency.get('shock', 0) > avg_latency.get('expected', 0) and avg_sparsity.get('shock', 1) < avg_sparsity.get('expected', 1) else
-        "⚠️ No Clear Evidence of Symbolic Shock."
-    )
+    verdict = ("✅ Evidence of Symbolic Shock Found." if avg_latency.get('shock', 0) > avg_latency.get('expected', 0) and avg_sparsity.get('shock', 1) < avg_sparsity.get('expected', 1) else "⚠️ No Clear Evidence.")
 
     return {"verdict": verdict, "average_latency_ms": avg_latency, "average_sparsity": avg_sparsity, "results": results}