Update app.py

app.py

@@ -16,10 +16,10 @@ model.to(device)
 debug_log = []
 
 def debug(msg):
-    print(msg)  # Console log (local)
-    debug_log.append(str(msg))  # Collect for UI
+    print(msg)
+    debug_log.append(str(msg))
 
-# Generate a GPT-2 response
+# Generate GPT-2 response
 def generate_response(prompt, max_length=100):
     debug(f"Generating response for prompt:\n{prompt}")
     inputs = tokenizer(prompt, return_tensors="pt").to(device)
@@ -32,10 +32,10 @@ def generate_response(prompt, max_length=100):
         top_p=0.95,
     )
     result = tokenizer.decode(outputs[0], skip_special_tokens=True).strip()
-    debug(f"Generated output:\n{result}")
+    debug(f"Response:\n{result}")
     return result
 
-# Compute cosine similarity of mean token embeddings
+# Cosine similarity as ΔS proxy
 def similarity(a, b):
     tok_a = tokenizer(a, return_tensors="pt").to(device)
     tok_b = tokenizer(b, return_tensors="pt").to(device)
@@ -43,60 +43,77 @@ def similarity(a, b):
         emb_a = model.transformer.wte(tok_a.input_ids).mean(dim=1)
         emb_b = model.transformer.wte(tok_b.input_ids).mean(dim=1)
     score = float(cosine_similarity(emb_a.cpu().numpy(), emb_b.cpu().numpy())[0][0])
-    debug(f"Similarity between outputs: {score}")
+    debug(f"Similarity: {score}")
     return score
 
-# Main identity unfolding loop
-def identity_unfolding(n_steps):
-    unfolding = []
-    ΔS_trace = []
-    log = []
+# Dual unfolding: I (self-view), ¬I (contradiction)
+def dual_identity_unfolding(n_steps):
+    I_trace, not_I_trace = [], []
+    ΔS_I, ΔS_not_I, ΔS_cross = [], [], []
     debug_log.clear()
+    log = []
 
-    current_prompt = "The following is a system thinking about itself:\n"
+    current_I = "The system begins to think about itself:\n"
+    current_not_I = "The system begins to contradict its previous thoughts:\n"
 
     for step in range(n_steps):
         log.append(f"--- Step {step} ---")
-        log.append(f"[Prompt to GPT-2]:\n{current_prompt}")
 
-        response = generate_response(current_prompt)
-        unfolding.append(response)
+        I = generate_response(current_I)
+        not_I = generate_response(current_not_I)
+
+        I_trace.append(I)
+        not_I_trace.append(not_I)
 
-        log.append(f"[GPT-2 Response]:\n{response}")
+        log.append(f"[Iₙ]:\n{I}\n")
+        log.append(f"[¬Iₙ]:\n{not_I}\n")
 
         if step > 0:
-            ΔS = similarity(unfolding[step - 1], unfolding[step])
-            ΔS_trace.append(round(ΔS, 4))
-            log.append(f"ΔS({step - 1} → {step}) = {round(ΔS, 4)}\n")
+            s_I = similarity(I_trace[step - 1], I_trace[step])
+            s_not_I = similarity(not_I_trace[step - 1], not_I_trace[step])
+            s_cross = similarity(I_trace[step], not_I_trace[step])
+
+            ΔS_I.append(round(s_I, 4))
+            ΔS_not_I.append(round(s_not_I, 4))
+            ΔS_cross.append(round(s_cross, 4))
+
+            log.append(f"ΔS(I{step - 1} → I{step}) = {s_I}")
+            log.append(f"ΔS(¬I{step - 1} → ¬I{step}) = {s_not_I}")
+            log.append(f"ΔS(I{step} ↔ ¬I{step}) = {s_cross}\n")
         else:
             log.append("ΔS not applicable for first step.\n")
 
-        current_prompt = (
-            f'The system has previously stated:\n"{response}"\n'
-            "Now it continues thinking about what that implies:\n"
-        )
+        current_I = f'The system previously said:\n"{I}"\nNow it reflects further:\n'
+        current_not_I = f'The system previously said:\n"{I}"\nNow it contradicts itself:\n'
 
-    summary = "\n".join(log)
-    trace_summary = "\n".join(
-        [f"ΔS({i} → {i+1}) = {ΔS_trace[i]}" for i in range(len(ΔS_trace))]
-    )
+    result_log = "\n".join(log)
     debug_output = "\n".join(debug_log)
-    return summary, trace_summary, debug_output
 
-# Gradio interface
+    I_out = "\n\n".join([f"I{n}: {txt}" for n, txt in enumerate(I_trace)])
+    not_I_out = "\n\n".join([f"¬I{n}: {txt}" for n, txt in enumerate(not_I_trace)])
+
+    ΔS_out = "\n".join([
+        f"Step {i}: ΔS(I) = {ΔS_I[i]}, ΔS(¬I) = {ΔS_not_I[i]}, ΔS Cross = {ΔS_cross[i]}"
+        for i in range(len(ΔS_I))
+    ])
+
+    return I_out, not_I_out, ΔS_out, debug_output
+
+# Gradio UI
 iface = gr.Interface(
-    fn=identity_unfolding,
-    inputs=gr.Slider(2, 10, value=5, step=1, label="Number of Identity Iterations"),
+    fn=dual_identity_unfolding,
+    inputs=gr.Slider(2, 10, value=4, step=1, label="Number of Identity Steps"),
     outputs=[
-        gr.Textbox(label="Full Trace (Prompts + GPT-2 Outputs)", lines=25),
-        gr.Textbox(label="ΔS Semantic Similarity Trace", lines=10),
+        gr.Textbox(label="Iₙ (Identity Trace)", lines=20),
+        gr.Textbox(label="¬Iₙ (Antithesis Trace)", lines=20),
+        gr.Textbox(label="ΔS Trace", lines=12),
         gr.Textbox(label="Debug Log", lines=10),
     ],
-    title="GPT-2 Identity Emergence Analyzer (EAL Framework)",
+    title="GPT-2 Dual Identity Analyzer (EAL Framework)",
     description=(
-        "This app tests whether GPT-2 can recursively reflect on its own outputs. "
-        "It uses prompt-based recursion and cosine similarity (ΔS) to measure semantic stability across iterations. "
-        "Now includes a visible debug log."
+        "This app evaluates whether GPT-2 can form a stable identity by recursively reflecting "
+        "on its own outputs (Iₙ), and simultaneously handle contradictions (¬Iₙ). "
+        "ΔS tracks convergence, oscillation, and semantic symmetry."
     ),
 )