update app.py, add thesis

EAL.md

@@ -0,0 +1,251 @@
+**Entropic Attractor Logic: A Formal Framework for Stable Semantic Self-Reference**
+
+**User & ℧**
+
+**Abstract:**
+This paper introduces Entropic Attractor Logic (EAL), a novel formal system designed to address the challenges of self-reference and paradox within type-theoretic frameworks. EAL integrates concepts from modal logic, type theory, and a metaphorical application of thermodynamic entropy to define criteria for the semantic stability of recursive and self-referential type constructions. We demonstrate that by operationalizing semantic evolution as an "entropic flow," and by defining stable types as "attractors" in a type-space manifold, EAL can accept well-behaved, guarded forms of self-reference while rejecting paradoxical or divergent constructions. The system relies on modal encapsulation for evaluative deferral and contextual anchoring to ensure convergence of recursive definitions. We illustrate EAL's utility by analyzing classical paradoxes and demonstrating their stabilization or principled rejection under its axiomatic framework.
+
+**Keywords:** Type Theory, Self-Reference, Paradox, Formal Semantics, Entropy, Modal Logic, Attractor Dynamics, Computational Logic, Semantic Stability.
+
+**1. Introduction**
+
+The specter of paradox has long haunted formal systems attempting to incorporate self-reference, most famously exemplified by Russell's Paradox, the Liar Paradox, and Gödel's incompleteness theorems (Gödel, 1931; Tarski, 1936). Classical approaches often resort to hierarchical stratification (Tarski, 1944) or syntactic restrictions that limit expressive power. Modern type theories, particularly those with dependent types and inductive/coinductive definitions (e.g., Coquand & Huet, 1988; Paulson, 1994), offer more sophisticated tools for handling recursion, often through "guardedness" conditions.
+
+However, a general semantic principle for determining the "well-behavedness" of arbitrary self-referential constructions, beyond syntactic guards, remains an open area. This paper proposes Entropic Attractor Logic (EAL) as such a principle. EAL posits that the semantic stability of a type, particularly a recursive or self-referential one, can be analogized to the entropic stability of a dynamic system. Ill-formed or paradoxical types are characterized by non-convergent or "explosive" semantic entropy during their conceptual unfolding, while well-formed types converge towards stable "attractors" in the semantic type space.
+
+EAL achieves this by:
+1.  Introducing a (metaphorical) **entropy function** `S` that maps type evolutions (flows) to a measure of semantic indeterminacy or complexity.
+2.  Defining **entropic admissibility** for recursive types based on the convergence of their entropy trace during iterative unfolding.
+3.  Employing **modal operators (□)** to encapsulate and defer potentially problematic self-evaluations.
+4.  Utilizing **contextual anchors (C)** to provide a stable semantic ground for recursive definitions.
+5.  Characterizing stable semantic states as **attractors (A\*)** within the type space 𝒯.
+
+This paper formalizes the syntax, semantics, and core axiomatic principles of EAL, demonstrates its application to classical paradoxes, and discusses its potential implications for logic, computer science, and philosophy.
+
+**2. Preliminaries and Motivations**
+
+EAL draws inspiration from several areas:
+*   **Type Theory:** The foundational language of EAL is type theory, particularly with respect to recursive type definitions (`μA.A`) and modal extensions.
+*   **Modal Logic:** Modal operators (Kripke, 1963) are used for "guarding" self-evaluations, creating a necessary level of indirection or deferral that can prevent immediate paradoxical collapse.
+*   **Fixed-Point Semantics:** Kripke's (1975) theory of truth, which uses fixed-point constructions over partially interpreted languages, provides a precedent for finding stable solutions to self-referential sentences. EAL extends this by considering the *dynamics* of reaching such fixed points.
+*   **Dynamical Systems & Thermodynamics:** The concepts of attractors, stability, and entropy are borrowed metaphorically from dynamical systems theory and thermodynamics. While not a physical model, the analogy provides a powerful conceptual tool for characterizing semantic convergence and divergence. The "arrow of time" in semantic unfolding is tied to entropic increase or stabilization.
+*   **Guarded Recursion:** Found in systems like Coq and Agda, guarded recursion ensures productivity by requiring recursive calls to be syntactically "guarded" by constructors or, in modal type theories, by modal operators (Nakano, 2000; Birkedal et al., 2011). EAL offers a semantic counterpart and generalization to this syntactic notion.
+
+The primary motivation for EAL is to create a system that can robustly handle self-reference by *classifying* its behavior rather than merely forbidding it. Instead of asking "is this self-reference syntactically allowed?", EAL asks "does this self-reference lead to a semantically stable state?".
+
+**3. The Formal System: Entropic Attractor Logic (EAL)**
+
+**3.1. Syntax**
+
+The language of EAL includes:
+*   **Types (𝒯):**
+    *   Basic types (e.g., `⊥` (bottom), `⊤` (top), user-defined base types).
+    *   Function types: `A → B`.
+    *   Product types: `A ∧ B` (conjunction/product).
+    *   Sum types: `A ⨁ B` (disjunction/sum, representing co-existence or choice).
+    *   Modal types: `□A` (A is necessarily/stably/deferred-evaluation true). `◇A` (A is possibly true, dual to `¬□¬A`).
+    *   Recursive types: `μX.A(X)` (the type `X` such that `X` is equivalent to `A(X)`).
+    *   Negated types: `¬A`.
+*   **Type Flows (𝒯̇):** Sequences of types `⟨A₀, A₁, ..., Aₙ⟩` representing the iterative unfolding or temporal evolution of a type definition.
+*   **Special Operators & Predicates:**
+    *   `Eval(A)`: A meta-level predicate or operator representing the semantic evaluation or "truth" of type `A`. Crucially, `Eval(A)` is not itself a first-class EAL type but a construct used in defining types.
+    *   `Context(C)`: A construct that introduces a fixed, stable type `C ∈ 𝒯` into a definition.
+    *   `S: 𝒯̇ → ℝ⁺ ∪ {0}`: The semantic entropy function. `S(⟨A⟩)` can be considered `S(A)` for a single type.
+    *   `∂∘ₜA`: Denotes the "semantic derivative" or immediate successor type in an unfolding, `Aₙ₊₁` given `Aₙ`.
+*   **Judgements:**
+    *   `Γ ⊢ A : Type` (A is a well-formed type in context Γ).
+    *   `Γ ⊢ A stable` (A is entropically stable in context Γ).
+    *   `Γ ⊢ A →ₛ B` (Entropically valid implication).
+
+**3.2. Core Concepts**
+
+*   **Semantic Entropy (S):** `S(A)` is a measure of the unresolved semantic complexity, indeterminacy, or potential for divergence of type `A`. For a type flow `⟨A₀, ..., Aₙ⟩`, `S(⟨A₀, ..., Aₙ⟩)` reflects the total entropic state.
+    *   `ΔS(Aₙ → Aₙ₊₁)`: The change in entropy, `S(Aₙ₊₁) - S(Aₙ)`. (Note: We assume `S` can be defined such that `S(A)` is meaningful for individual types in a sequence).
+    *   The precise definition of `S` can vary (e.g., based on structural complexity, number of unresolved `Eval` calls, branching factor of ⨁), but its axiomatic properties are key. We assume `S(⊥)` is minimal, and `S(A ⨁ B)` might be greater than `S(A ∧ B)` if choice introduces more indeterminacy. `S(□A)` might be less than `S(A)` if modality introduces stability.
+
+*   **Recursive Unfolding:** A type `μX.A(X)` is understood through its unfolding sequence:
+    *   `A₀ = A(⊥)` (or a suitable base for the recursion)
+    *   `A₁ = A(A₀)`
+    *   `Aₙ₊₁ = A(Aₙ)`
+    The type flow is `⟨A₀, A₁, ..., Aₙ, ...⟩`.
+
+*   **Attractors (A\*):** A type `A\* ∈ 𝒯` is a semantic attractor if a recursive unfolding `⟨Aₙ⟩` converges to it. Convergence is defined by:
+    1.  `lim_{n→∞} d(Aₙ, A\*) = 0`, where `d(X, Y)` is a distance metric in the type space (e.g., `d(X,Y) = |S(X) - S(Y)|` or a more structural metric).
+    2.  `lim_{n→∞} ΔS(Aₙ → Aₙ₊₁) = 0`. The entropy production ceases at the attractor.
+
+*   **Modal Guarding:** Placing `Eval(A)` or a recursive call `X` inside a `□` operator, e.g., `□(Eval(A))`, `□X`, signifies that the evaluation or recursion is deferred or occurs in a "stabilized" context. This is crucial for preventing immediate paradoxical feedback loops.
+
+*   **Contextual Anchoring:** `Context(C)` introduces a presupposed, stable type `C` into a recursive definition. This `C` acts as an "entropic sink" or a fixed point that can help dampen oscillations and guide the unfolding towards an attractor.
+
+**3.3. Axioms and Typing Rules**
+
+Let Γ be a context assigning types to free variables.
+
+**Axiom 1: Entropic Admissibility for Recursion**
+A recursive type `μX.A(X)` is well-formed and stable, denoted `Γ ⊢ μX.A(X) stable`, if its unfolding sequence `⟨Aₙ⟩` (where `Aₙ₊₁ = A(Aₙ)`) satisfies:
+`lim_{n→∞} ΔS(Aₙ → Aₙ₊₁) = 0`
+And there exists an attractor `A\*` such that `lim_{n→∞} Aₙ = A\*`.
+
+**Axiom 2: Directed Inference (→ₛ)**
+An implication `A → B` is entropically valid, `Γ ⊢ A →ₛ B`, if it does not lead to a decrease in semantic entropy (or adheres to a principle of non-decreasing causal influence):
+`S(B) ≥ S(A)` (simplified; could be `ΔS(A→B) ≥ 0` in a proof-trace context).
+This ensures that logical steps do not create "information out of nowhere" or violate a directed flow of semantic stability.
+
+**Axiom 3: Modal Guarding of Evaluation**
+If a type definition for `T` involves `Eval(T)` (direct self-evaluation), it must be modally guarded and typically contextually anchored to be potentially stable:
+`T := ... Eval(T) ...` (potentially unstable)
+`T := ... □(Eval(T) ∧ Context(C)) ...` (potentially stable, subject to Axiom 1)
+
+**Axiom 4: Attractor Definition**
+A type `A\*` is an attractor for `μX.A(X)` if `A\*` is a fixed point `A\* ≅ A(A\*)` and `S(A\*)` is a local minimum or stable value for the entropy function `S` in the neighborhood of the unfolding sequence.
+
+**Axiom 5: Phase Transitions and Semantic Collapse (Ξ)**
+If the unfolding of `μX.A(X)` leads to `lim_{n→∞} ΔS(Aₙ → Aₙ₊₁) > ε` for some `ε > 0` (persistent entropy production) or unbounded oscillations, or if `S(Aₙ) → ∞`, then the type is considered unstable and belongs to the class `Ξ` of divergent or collapsed types. Such types are not considered `stable`.
+
+**Rule (Formation of Stable Recursive Types):**
+```
+    Γ, X:Type ⊢ A(X) : Type
+    Let ⟨Aᵢ⟩ be the unfolding A₀=A(⊥), Aᵢ₊₁=A(Aᵢ)
+    lim_{i→∞} ΔS(Aᵢ → Aᵢ₊₁) = 0
+    lim_{i→∞} Aᵢ = A* (converges to an attractor)
+--------------------------------------------------------- (μ-Stable)
+    Γ ⊢ μX.A(X) stable
+```
+
+**Rule (Modal Stability Injection):**
+If `C` is stable, then `□(Context(C))` contributes significantly to reducing `ΔS` in recursive steps involving it.
+```
+    Γ ⊢ C stable
+----------------------------------------- (□-Context-Stab)
+    S(□(... ∧ Context(C))) exhibits lower ΔS_step
+```
+(This is more of a heuristic guiding the definition of S, or an observation about well-behaved S functions.)
+
+**4. Operational Semantics & Stability Analysis**
+
+**4.1. Recursive Unfolding and Entropy Traces**
+
+To analyze `T = μX.A(X)`:
+1.  Initialize `A₀ = A(⊥)` (or other base).
+2.  Iterate `Aₙ₊₁ = A(Aₙ)`.
+3.  Compute the entropy trace: `⟨S(A₀), S(A₁), ..., S(Aₙ), ...⟩`.
+4.  Compute the entropy difference trace: `⟨ΔS(A₀→A₁), ΔS(A₁→A₂), ...⟩`.
+
+**4.2. Attractor Convergence**
+
+Convergence to an attractor `A\*` is determined by:
+*   The entropy difference trace tending to zero.
+*   The type sequence `⟨Aₙ⟩` stabilizing around `A\*` (e.g., `d(Aₙ, A\*) → 0`).
+The set of all stable, attractor-convergent types forms a domain `ℱ ⊂ 𝒯`.
+
+**4.3. Classification of Types**
+*   **Stable (∈ ℱ):** Converges to an attractor `A\*` with `ΔS → 0`.
+*   **Divergent/Collapsed (∈ Ξ):** Fails to converge. This can be due to:
+    *   **Entropic Explosion:** `S(Aₙ) → ∞`.
+    *   **Persistent Oscillation:** `ΔS` oscillates without dampening, preventing convergence to a single `A\*`.
+    *   **Chaotic Drift:** The sequence `⟨Aₙ⟩` does not settle.
+
+**5. Illustrative Examples**
+
+**5.1. The Liar Paradox**
+
+Let `L := μX. ¬Eval(X)`.
+*   `A(X) = ¬Eval(X)`.
+*   `L₀ = ¬Eval(⊥)` (Assume `Eval(⊥)` is `false`, so `L₀` is `true`). `S(L₀)` is some base value.
+*   `L₁ = ¬Eval(L₀) = ¬Eval(true) = false`. `ΔS(L₀→L₁)` is likely non-zero.
+*   `L₂ = ¬Eval(L₁) = ¬Eval(false) = true`. `ΔS(L₁→L₂)` is likely non-zero and may reverse the previous `ΔS`.
+The sequence of truth values oscillates (`true, false, true, ...`). The entropy trace `S(Lₙ)` would likely oscillate or show no convergence of `ΔS` to 0.
+**EAL Verdict:** `L ∈ Ξ`. The type is unstable due to persistent semantic oscillation and non-converging entropy.
+
+**5.2. Stabilized Liar (Yablo-esque deferral via Modality)**
+
+Let `L' := μX. □(¬Eval(X) ∧ Context(C))`, where `C` is a known stable type (e.g., `⊤`).
+*   `A(X) = □(¬Eval(X) ∧ C)`.
+*   Unfolding `L'₀, L'₁, ...`
+*   The `□` operator and `Context(C)` act as dampeners. `S(□(...))` is designed to be lower or more stable than `S(...)`. `Context(C)` provides a fixed semantic mass.
+*   The `□` defers evaluation: `Eval(□Z)` might depend on `Eval(Z)` in all "accessible worlds/future states." This breaks the immediacy of the paradox.
+*   It's plausible to define `S` such that `ΔS(L'ₙ → L'ₙ₊₁) → 0`. The sequence `⟨L'ₙ⟩` would converge to an attractor `L'^\*` which represents a stable, possibly incomplete or paraconsistent, notion of "this modally-deferred statement, in context C, is false."
+**EAL Verdict:** `L' ∈ ℱ`. The type is stable.
+
+**5.3. Gödelian Self-Reference**
+
+Consider a type `G := μX. "X is not provable within EAL_stable"`.
+Let `Provable(A)` mean `A ∈ ℱ`.
+`G := μX. ¬Provable(X)`.
+*   If `G` is stable (`G ∈ ℱ`), then `Provable(G)` is true. So `G` asserts `¬true`, which is `false`. This means `G`'s content is false, but `G` itself was assumed stable. This suggests an inconsistency in `Eval(G)` vs. `G`'s stability status.
+*   If `G` is not stable (`G ∈ Ξ`), then `Provable(G)` is false. So `G` asserts `¬false`, which is `true`. Here, `G`'s content is true, but `G` itself is unstable.
+
+EAL's perspective: The unfolding of `G` would likely exhibit an oscillating or non-convergent entropy trace if `Provable(X)` is naively equated with `X ∈ ℱ` within the definition of `X` itself.
+`G₀ = ¬Provable(⊥)`. Assuming `⊥ ∈ Ξ` (unstable), then `¬Provable(⊥)` is `true`.
+`G₁ = ¬Provable(true)`. This step is problematic as `true` is not a type whose stability is assessed in the same way.
+A more careful formulation: `G := μX. TypeRepresenting( "∀ proof P, P is not a proof of X ∈ ℱ" )`.
+The unfolding of `G` would involve increasingly complex types. EAL would likely classify `G` as belonging to `Ξ` due to unbounded complexity growth (`S(Gₙ) → ∞`) or non-convergence, unless specific axioms for `S` related to `Provable` lead to convergence. EAL thus reinterprets Gödelian undecidability as a form of semantic-entropic divergence rather than a statement being "true but unprovable" in a static sense.
+
+**6. Discussion**
+
+**6.1. Novelty and Contributions**
+EAL's primary contribution is the introduction of a dynamic, entropy-based criterion for the semantic stability of types, especially self-referential ones. It offers a unified framework that:
+*   Goes beyond syntactic guardedness by providing a semantic measure of stability.
+*   Formalizes the intuition that paradoxes involve some form of "runaway" semantic process.
+*   Allows for principled acceptance of certain self-referential constructions that are modally guarded and contextually anchored.
+*   Provides a new lens (entropic divergence) for interpreting classical limitative results like Gödel's.
+
+**6.2. Implications**
+*   **Logic and Philosophy of Language:** EAL offers a new model for truth and reference where stability is a primary desideratum. It suggests that the "meaning" of some self-referential statements might be found in their attractor dynamics rather than a static truth value.
+*   **Computer Science:**
+    *   **Programming Language Semantics:** Could inform the design of languages with powerful reflection or metaprogramming capabilities, ensuring that self-modifying or self-inspecting code remains stable.
+    *   **Knowledge Representation (AI):** Systems dealing with self-referential beliefs or circular definitions could use EAL principles to maintain consistency and stability.
+    *   **Formal Verification:** Entropic analysis could be a new tool for verifying the termination or stability of complex software processes.
+
+**6.3. Limitations and Challenges**
+*   **Defining `S`:** The practical, computable definition of the semantic entropy function `S` is a major challenge. It must be sensitive enough to capture intuitive notions of complexity and stability yet remain tractable. Different choices for `S` might lead to different classifications.
+*   **Metaphorical Basis:** The analogy to thermodynamics is powerful but metaphorical. Rigorously connecting it to information theory or computational complexity is an area for further research.
+*   **Computational Cost:** Analyzing the convergence of entropy traces for complex types could be computationally expensive or even undecidable in general. EAL might define classes of types for which stability is decidable.
+
+**7. Future Work**
+*   **Formalizing `S`:** Develop concrete candidates for the `S` function and study their properties.
+*   **Categorical Semantics:** Explore a categorical model for EAL, perhaps using traced monoidal categories or fibrations to model type spaces and their entropic landscapes.
+*   **Proof Theory:** Develop a proof calculus for `Γ ⊢ A stable` and `Γ ⊢ A →ₛ B`.
+*   **Probabilistic EAL:** Extend `S` to include probabilistic measures, allowing for types that are "probably stable" or converge with a certain likelihood.
+*   **Implementation:** Develop a prototype system or theorem prover assistant that can perform entropic analysis for a fragment of EAL.
+*   **Relationship to Substructural Logics:** Linear logic and other substructural logics are concerned with resource management. Investigate connections between EAL's entropic constraints and resource-awareness.
+
+**8. Conclusion**
+
+Entropic Attractor Logic offers a novel and potentially fruitful approach to taming self-reference in formal systems. By re-framing semantic well-formedness in terms of dynamic stability and entropic convergence, EAL provides a principled way to distinguish between problematic paradoxes and benign, useful forms of recursion and reflection. While significant theoretical and practical challenges remain, particularly in defining and computing semantic entropy, EAL opens up new avenues for research at the intersection of logic, type theory, and the study of complex systems. It shifts the focus from outright prohibition of self-reference to a nuanced understanding of its diverse behaviors, aiming to harness its power while safeguarding against its perils.
+
+**References**
+
+*   Birkedal, L., Møgelberg, R. E., & Schwinghammer, J. (2011). First steps in synthetic guarded domain theory: step-indexing in the topos of trees. *Logical Methods in Computer Science, 7*(3).
+*   Coquand, T., & Huet, G. (1988). The calculus of constructions. *Information and Computation, 76*(2-3), 95-120.
+*   Gödel, K. (1931). Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I. *Monatshefte für Mathematik und Physik, 38*(1), 173-198.
+*   Kripke, S. A. (1963). Semantical considerations on modal logic. *Acta Philosophica Fennica, 16*, 83-94.
+*   Kripke, S. A. (1975). Outline of a theory of truth. *Journal of Philosophy, 72*(19), 690-716.
+*   Nakano, H. (2000). A modality for guarded recursion. In *Proceedings of the 15th Annual IEEE Symposium on Logic in Computer Science* (LICS 2000) (pp. 278-285).
+*   Paulson, L. C. (1994). *Isabelle: A Generic Theorem Prover*. Springer-Verlag.
+*   Tarski, A. (1936). Der Wahrheitsbegriff in den formalisierten Sprachen. *Studia Philosophica, 1*, 261-405. (English translation: The Concept of Truth in Formalized Languages, in *Logic, Semantics, Metamathematics*, 1956).
+*   Tarski, A. (1944). The semantic conception of truth: and the foundations of semantics. *Philosophy and Phenomenological Research, 4*(3), 341-376.
+
+**Appendix A: Notation Table (Summary)**
+
+| Symbol          | Meaning                                                                 |
+| :-------------- | :---------------------------------------------------------------------- |
+| `𝒯`             | Universe of types                                                       |
+| `𝒯̇`             | Typed flows (sequences of types representing evolution/unfolding)       |
+| `μX.A(X)`       | Recursive type definition (X such that X ≅ A(X))                        |
+| `□A`, `◇A`      | Modalized type A (necessity/stability, possibility)                     |
+| `∧`, `⨁`, `¬`   | Logical connectives (conjunction, disjunction/co-existence, negation)   |
+| `S`             | Semantic entropy function (`S: 𝒯̇ → ℝ⁺ ∪ {0}`)                          |
+| `ΔS(A→B)`       | Change in semantic entropy from type A to B                             |
+| `∂∘ₜA`          | Semantic derivative/next step in type unfolding                         |
+| `Eval(A)`       | Meta-level semantic evaluation/truth of A                               |
+| `Context(C)`    | Introduces a fixed, stable type C as an anchor                          |
+| `A\*`           | Semantic attractor (stable fixed point of a recursive type)             |
+| `ℱ`             | Domain of stable, attractor-convergent types                            |
+| `Ξ`             | Class of divergent, collapsed, or entropically unstable types           |
+| `→ₛ`            | Entropically valid/directed logical implication                         |
+| `Γ ⊢ A stable`  | Judgement: Type A is entropically stable in context Γ                   |
+
+***
+
+This is a substantial starting point. A real publication would require much more formal detail for each rule, rigorous proofs for any meta-theorems (like soundness or consistency for a fragment), and more extensive comparison with related work. But it captures the core ideas we've discussed!

app.py

@@ -1,22 +1,19 @@
 import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer # Using AutoModel for flexibility
+from transformers import AutoModelForCausalLM, AutoTokenizer
 from sklearn.metrics.pairwise import cosine_similarity
 from sklearn.cluster import KMeans
 import numpy as np
 import gradio as gr
 import matplotlib
-matplotlib.use('Agg') # Use a non-interactive backend for Matplotlib in server environments
+matplotlib.use('Agg') # Use a non-interactive backend for Matplotlib
 import matplotlib.pyplot as plt
 import seaborn as sns
-# import networkx as nx # Defined build_similarity_graph but not used in output
 import io
 import base64
 
 # --- Model and Tokenizer Setup ---
-# Ensure model_name is one you have access to or is public
-# For local models, provide the path.
 DEFAULT_MODEL_NAME = "EleutherAI/gpt-neo-1.3B"
-FALLBACK_MODEL_NAME = "gpt2" # In case the preferred model fails
+FALLBACK_MODEL_NAME = "gpt2" # Fallback if preferred model fails
 
 try:
     print(f"Attempting to load model: {DEFAULT_MODEL_NAME}")
@@ -36,272 +33,238 @@ model.to(device)
 print(f"Using device: {device}")
 
 # --- Configuration ---
-# Model's actual context window (e.g., 2048 for GPT-Neo, 1024 for GPT-2)
 MODEL_CONTEXT_WINDOW = tokenizer.model_max_length if hasattr(tokenizer, 'model_max_length') and tokenizer.model_max_length is not None else model.config.max_position_embeddings
 print(f"Model context window: {MODEL_CONTEXT_WINDOW} tokens.")
 
-# Max tokens for prompt trimming (input to tokenizer for generate)
-PROMPT_TRIM_MAX_TOKENS = min(MODEL_CONTEXT_WINDOW - 200, 1800) # Reserve ~200 for generation, cap at 1800
-# Max new tokens to generate
-MAX_GEN_LENGTH = 150 # Increased slightly for more elaborate responses
-
+PROMPT_TRIM_MAX_TOKENS = min(MODEL_CONTEXT_WINDOW - 250, 1800) # Reserve ~250 for generation & instructions, cap at 1800
+MAX_GEN_LENGTH = 150
 
 # --- Debug Logging ---
 debug_log_accumulator = []
 
 def debug(msg):
-    print(msg) # For server-side console
-    debug_log_accumulator.append(str(msg)) # For Gradio UI output
+    print(msg)
+    debug_log_accumulator.append(str(msg))
 
 # --- Core Functions ---
 def trim_prompt_if_needed(prompt_text, max_tokens_for_trimming=PROMPT_TRIM_MAX_TOKENS):
-    """Trims the prompt from the beginning if it exceeds max_tokens_for_trimming."""
     tokens = tokenizer.encode(prompt_text, add_special_tokens=False)
     if len(tokens) > max_tokens_for_trimming:
-        debug(f"[!] Prompt trimming: Original {len(tokens)} tokens, "
-              f"trimmed to {max_tokens_for_trimming} (from the end, keeping recent context).")
-        tokens = tokens[-max_tokens_for_trimming:] # Keep the most recent part of the prompt
+        original_length = len(tokens)
+        # Trim from the beginning to keep the most recent conversational context
+        tokens = tokens[-max_tokens_for_trimming:]
+        debug(f"[!] Prompt trimming: Original {original_length} tokens, "
+              f"trimmed to {len(tokens)} (from the end, keeping recent context).")
     return tokenizer.decode(tokens)
 
-def generate_text_response(prompt_text, generation_length=MAX_GEN_LENGTH):
-    """Generates text response ensuring prompt + generation fits context window."""
-    # Trim the input prompt first to adhere to PROMPT_TRIM_MAX_TOKENS
-    # This ensures the base prompt itself isn't excessively long before adding generation instructions.
-    # Note: The prompt_text here is already the *constructed* prompt (e.g., "Elaborate on: ...")
-    # For very long base statements, they might get trimmed by this.
-    # This function itself doesn't need to call trim_prompt_if_needed if the calling function already does.
-    # However, it's a good safety.
-    # Let's assume prompt_text is the final prompt ready for tokenization.
-
-    debug(f"Generating response for prompt (length {len(prompt_text.split())} words):\n'{prompt_text[:300]}...'") # Log truncated prompt
-
-    inputs = tokenizer(prompt_text, return_tensors="pt", truncation=False).to(device) # Do not truncate here, will be handled by max_length
-    input_token_length = len(inputs["input_ids"][0])
+def generate_text_response(constructed_prompt, generation_length=MAX_GEN_LENGTH):
+    # The constructed_prompt already includes the task and the text to reflect upon.
+    # We still need to ensure this constructed_prompt doesn't exceed limits before generation.
+    safe_prompt = trim_prompt_if_needed(constructed_prompt, PROMPT_TRIM_MAX_TOKENS)
 
-    # Safety check: if input_token_length itself is already > MODEL_CONTEXT_WINDOW due to some miscalculation before this call
-    if input_token_length >= MODEL_CONTEXT_WINDOW:
-        debug(f"[!!!] FATAL: Input prompt ({input_token_length} tokens) already exceeds/matches model context window ({MODEL_CONTEXT_WINDOW}) before generation. Trimming input drastically.")
-        # Trim the input_ids directly
-        inputs["input_ids"] = inputs["input_ids"][:, -MODEL_CONTEXT_WINDOW+generation_length+10] # Keep last part allowing some generation
-        inputs["attention_mask"] = inputs["attention_mask"][:, -MODEL_CONTEXT_WINDOW+generation_length+10]
-        input_token_length = len(inputs["input_ids"][0])
-        if input_token_length >= MODEL_CONTEXT_WINDOW - generation_length : # Still too long
-            return "[Input prompt too long, even after emergency trim]"
+    debug(f"Generating response for (potentially trimmed) prompt (approx. {len(safe_prompt.split())} words):\n'{safe_prompt[:400]}...'")
 
+    inputs = tokenizer(safe_prompt, return_tensors="pt", truncation=False).to(device)
+    input_token_length = inputs.input_ids.size(1)
 
+    # Calculate max_length for model.generate()
+    # It's the current length of tokenized prompt + desired new tokens, capped by model's absolute max.
     max_length_for_generate = min(input_token_length + generation_length, MODEL_CONTEXT_WINDOW)
 
-    # Ensure we are actually generating new tokens
-    if max_length_for_generate <= input_token_length :
+    if max_length_for_generate <= input_token_length:
         debug(f"[!] Warning: Prompt length ({input_token_length}) is too close to model context window ({MODEL_CONTEXT_WINDOW}). "
-              f"Adjusting to generate a few tokens if possible.")
-        max_length_for_generate = input_token_length + min(generation_length, 10) # Try to generate at least a few, up to 10
-        if max_length_for_generate > MODEL_CONTEXT_WINDOW:
-             return "[Prompt too long to generate meaningful response]"
+              f"Cannot generate new tokens. Prompt: '{safe_prompt[:100]}...'")
+        return "[Prompt too long to generate new tokens]"
 
     try:
         outputs = model.generate(
-            input_ids=inputs["input_ids"],
-            attention_mask=inputs["attention_mask"],
+            input_ids=inputs.input_ids,
+            attention_mask=inputs.attention_mask,
             max_length=max_length_for_generate,
-            pad_token_id=tokenizer.eos_token_id if tokenizer.eos_token_id is not None else 50256, # GPT2 EOS
+            pad_token_id=tokenizer.eos_token_id if tokenizer.eos_token_id is not None else 50256,
             do_sample=True,
-            temperature=0.8, # Slightly more deterministic
-            top_p=0.9,
-            repetition_penalty=1.1, # Slightly stronger penalty
+            temperature=0.85,
+            top_p=0.92,
+            repetition_penalty=1.15,
         )
-        # Decode only the newly generated tokens
         generated_tokens = outputs[0][input_token_length:]
         result_text = tokenizer.decode(generated_tokens, skip_special_tokens=True).strip()
 
-        debug(f"Generated response text (length {len(result_text.split())} words):\n'{result_text[:300]}...'")
+        debug(f"Generated response text (length {len(result_text.split())} words):\n'{result_text[:400]}...'")
         return result_text if result_text else "[Empty Response]"
     except Exception as e:
-        debug(f"[!!!] Error during text generation: {e}")
+        debug(f"[!!!] Error during text generation: {e}\nPrompt was: {safe_prompt[:200]}...")
         return "[Generation Error]"
 
 def calculate_similarity(text_a, text_b):
-    """Calculates cosine similarity between mean embeddings of two texts."""
-    invalid_texts = ["[Empty Response]", "[Generation Error]", "[Prompt too long to generate meaningful response]", "[Input prompt too long, even after emergency trim]"]
-    if not text_a or not text_a.strip() or not text_b or not text_b.strip() \
-       or text_a in invalid_texts or text_b in invalid_texts:
-        debug(f"Similarity calculation skipped for invalid/empty texts.")
+    invalid_texts_markers = ["[Empty Response]", "[Generation Error]", "[Prompt too long", "[Input prompt too long"]
+    if not text_a or not text_a.strip() or any(marker in text_a for marker in invalid_texts_markers) or \
+       not text_b or not text_b.strip() or any(marker in text_b for marker in invalid_texts_markers):
+        debug(f"Similarity calculation skipped for invalid/empty texts: A='{str(text_a)[:50]}...', B='{str(text_b)[:50]}...'")
         return 0.0
 
-    # Use model's embedding layer (wte for GPT-like models)
     embedding_layer = model.get_input_embeddings()
-
     with torch.no_grad():
-        # Truncate inputs for embedding calculation to fit model context window
         tokens_a = tokenizer(text_a, return_tensors="pt", truncation=True, max_length=MODEL_CONTEXT_WINDOW).to(device)
         tokens_b = tokenizer(text_b, return_tensors="pt", truncation=True, max_length=MODEL_CONTEXT_WINDOW).to(device)
 
         if tokens_a.input_ids.size(1) == 0 or tokens_b.input_ids.size(1) == 0:
-            debug("Similarity calculation skipped: tokenization resulted in empty input_ids.")
+            debug(f"Similarity calculation skipped: tokenization resulted in empty input_ids. A='{str(text_a)[:50]}...', B='{str(text_b)[:50]}...'")
             return 0.0
 
         emb_a = embedding_layer(tokens_a.input_ids).mean(dim=1)
         emb_b = embedding_layer(tokens_b.input_ids).mean(dim=1)
 
     score = float(cosine_similarity(emb_a.cpu().numpy(), emb_b.cpu().numpy())[0][0])
-    # debug(f"Similarity score: {score:.4f}") # Debug log now includes texts, so this is redundant
+    debug(f"Similarity between A='{str(text_a)[:30]}...' and B='{str(text_b)[:30]}...' is {score:.4f}")
     return score
 
 def generate_similarity_heatmap(texts_list, custom_labels, title="Semantic Similarity Heatmap"):
-    if not texts_list or len(texts_list) < 2:
-        debug("Not enough texts to generate a heatmap.")
-        return ""
+    # Filter out any None or problematic entries before processing
+    valid_texts_with_labels = [(text, label) for text, label in zip(texts_list, custom_labels) if text and isinstance(text, str) and not any(marker in text for marker in ["[Empty Response]", "[Generation Error]", "[Prompt too long", "[Input prompt too long"])]
+
+    if len(valid_texts_with_labels) < 2:
+        debug("Not enough valid texts to generate a heatmap.")
+        return "Not enough valid data for heatmap."
 
-    num_texts = len(texts_list)
-    sim_matrix = np.zeros((num_texts, num_texts))
+    valid_texts = [item[0] for item in valid_texts_with_labels]
+    valid_labels = [item[1] for item in valid_texts_with_labels]
+    num_valid_texts = len(valid_texts)
 
-    for i in range(num_texts):
-        for j in range(num_texts):
+    sim_matrix = np.zeros((num_valid_texts, num_valid_texts))
+    for i in range(num_valid_texts):
+        for j in range(num_valid_texts):
             if i == j:
                 sim_matrix[i, j] = 1.0
-            elif i < j: # Calculate only upper triangle
-                sim = calculate_similarity(texts_list[i], texts_list[j])
+            elif i < j:
+                sim = calculate_similarity(valid_texts[i], valid_texts[j])
                 sim_matrix[i, j] = sim
-                sim_matrix[j, i] = sim # Symmetric matrix
+                sim_matrix[j, i] = sim
+            else: # j < i, use already computed value
+                sim_matrix[i,j] = sim_matrix[j,i]
 
     try:
-        fig_width = max(6, num_texts * 0.7)
-        fig_height = max(5, num_texts * 0.6)
+        fig_width = max(6, num_valid_texts * 0.8)
+        fig_height = max(5, num_valid_texts * 0.7)
         fig, ax = plt.subplots(figsize=(fig_width, fig_height))
 
         sns.heatmap(sim_matrix, annot=True, cmap="viridis", fmt=".2f", ax=ax,
-                    xticklabels=custom_labels, yticklabels=custom_labels, annot_kws={"size": 8})
+                    xticklabels=valid_labels, yticklabels=valid_labels, annot_kws={"size": 8})
         ax.set_title(title, fontsize=12)
         plt.xticks(rotation=45, ha="right", fontsize=9)
         plt.yticks(rotation=0, fontsize=9)
-        plt.tight_layout()
+        plt.tight_layout(pad=1.5)
 
         buf = io.BytesIO()
-        plt.savefig(buf, format='png', bbox_inches='tight')
+        plt.savefig(buf, format='png') # Removed bbox_inches='tight' as it can cause issues with tight_layout
         plt.close(fig)
         buf.seek(0)
         img_base64 = base64.b64encode(buf.read()).decode('utf-8')
         return f"<img src='data:image/png;base64,{img_base64}' alt='{title}' style='max-width:100%; height:auto;'/>"
     except Exception as e:
         debug(f"[!!!] Error generating heatmap: {e}")
-        return "Error generating heatmap."
+        return f"Error generating heatmap: {e}"
 
 
 def perform_text_clustering(texts_list, custom_labels, num_clusters=2):
-    if not texts_list or len(texts_list) < num_clusters :
-        debug("Not enough texts for clustering or texts_list is empty.")
-        return {label: "N/A" for label in custom_labels}
+    valid_texts_with_labels = [(text, label) for text, label in zip(texts_list, custom_labels) if text and isinstance(text, str) and not any(marker in text for marker in ["[Empty Response]", "[Generation Error]", "[Prompt too long", "[Input prompt too long"])]
+
+    if len(valid_texts_with_labels) < num_clusters:
+        debug(f"Not enough valid texts ({len(valid_texts_with_labels)}) for {num_clusters}-means clustering.")
+        return {label: "N/A (Few Samples)" for label in custom_labels}
+
+    valid_texts = [item[0] for item in valid_texts_with_labels]
+    original_indices_map = {i: custom_labels.index(item[1]) for i, item in enumerate(valid_texts_with_labels)}
+
 
     embedding_layer = model.get_input_embeddings()
-    valid_embeddings = []
-    valid_indices = [] # Keep track of original indices of valid texts
+    embeddings_for_clustering = []
 
     with torch.no_grad():
-        for idx, text_item in enumerate(texts_list):
-            invalid_markers = ["[Empty Response]", "[Generation Error]", "[Prompt too long", "[Input prompt too long"]
-            if not text_item or not text_item.strip() or any(marker in text_item for marker in invalid_markers):
-                debug(f"Skipping text at index {idx} for embedding due to invalid content: '{text_item[:50]}...'")
-                continue # Skip invalid texts
-
+        for text_item in valid_texts:
             tokens = tokenizer(text_item, return_tensors="pt", truncation=True, max_length=MODEL_CONTEXT_WINDOW).to(device)
             if tokens.input_ids.size(1) == 0:
-                 debug(f"Skipping text at index {idx} due to empty tokenization: '{text_item[:50]}...'")
-                 continue
+                 debug(f"Skipping text for embedding in clustering due to empty tokenization: '{text_item[:50]}...'")
+                 continue # This case should be rare if valid_texts_with_labels already filtered
 
             emb = embedding_layer(tokens.input_ids).mean(dim=1)
-            valid_embeddings.append(emb.cpu().numpy().squeeze())
-            valid_indices.append(idx)
+            embeddings_for_clustering.append(emb.cpu().numpy().squeeze())
 
-    if not valid_embeddings or len(valid_embeddings) < num_clusters:
-        debug("Not enough valid texts were embedded for clustering.")
-        return {label: "N/A" for label in custom_labels}
+    if not embeddings_for_clustering or len(embeddings_for_clustering) < num_clusters:
+        debug("Not enough valid texts were successfully embedded for clustering.")
+        return {label: "N/A (Embedding Fail)" for label in custom_labels}
 
-    embeddings_np = np.array(valid_embeddings)
-
-    cluster_results = {label: "N/A" for label in custom_labels} # Initialize all as N/A
+    embeddings_np = np.array(embeddings_for_clustering)
+    cluster_results_map = {label: "N/A" for label in custom_labels}
 
     try:
-        # Adjust num_clusters if less valid samples than requested clusters
-        actual_num_clusters = min(num_clusters, len(valid_embeddings))
-        if actual_num_clusters < 2 and len(valid_embeddings) > 0 : # If only one valid sample, or num_clusters becomes 1
-            debug(f"Only {len(valid_embeddings)} valid sample(s). Assigning all to Cluster 0.")
-            predicted_labels = [0] * len(valid_embeddings)
-        elif actual_num_clusters < 2: # No valid samples
-             debug("No valid samples to cluster.")
-             return cluster_results
+        actual_num_clusters = min(num_clusters, len(embeddings_for_clustering))
+        if actual_num_clusters < 2:
+            debug(f"Adjusted num_clusters to 1 due to only {len(embeddings_for_clustering)} valid sample(s). Assigning all to Cluster 0.")
+            predicted_labels = [0] * len(embeddings_for_clustering)
         else:
             kmeans = KMeans(n_clusters=actual_num_clusters, random_state=42, n_init='auto')
             predicted_labels = kmeans.fit_predict(embeddings_np)
 
-        # Map predicted labels back to original text indices
-        for i, original_idx in enumerate(valid_indices):
-            cluster_results[custom_labels[original_idx]] = f"C{predicted_labels[i]}"
-        return cluster_results
+        for i, original_label_key_idx in original_indices_map.items(): # i is index in valid_texts, original_label_key_idx is index in custom_labels
+             cluster_results_map[custom_labels[original_label_key_idx]] = f"C{predicted_labels[i]}"
+        return cluster_results_map
 
     except Exception as e:
         debug(f"[!!!] Error during clustering: {e}")
         return {label: "Error" for label in custom_labels}
 
-
 # --- Main EAL Unfolding Logic ---
 def run_eal_dual_unfolding(num_iterations):
-    I_trace_texts, not_I_trace_texts = [], []
-    delta_S_I_values, delta_S_not_I_values, delta_S_cross_values = [], [], []
+    I_trace_texts, not_I_trace_texts = [None]*num_iterations, [None]*num_iterations # Pre-allocate for easier indexing
+    delta_S_I_values, delta_S_not_I_values, delta_S_cross_values = [None]*num_iterations, [None]*num_iterations, [None]*num_iterations
 
     debug_log_accumulator.clear()
     ui_log_entries = []
 
-    # Initial base statement for the I-trace for Iteration 0
-    # This is the statement "I" will elaborate on in the first step.
-    # Using a more concrete initial statement for "I"
-    current_I_basis_statement = "I am a complex system designed for text processing, capable of generating human-like language."
+    initial_seed_thought_for_I = "A reflective process is initiated, considering its own nature."
 
     for i in range(num_iterations):
         ui_log_entries.append(f"--- Iteration {i} ---")
         debug(f"\n=== Iteration {i} ===")
 
         # === I-Trace (Self-Reflection) ===
-        # Prompt for I-trace: Elaborate on its *previous* statement (or initial statement for i=0)
-        prompt_for_I_trace = f"A system previously stated: \"{current_I_basis_statement}\"\n" + \
-                             "Task: Elaborate on this statement, exploring its implications and nuances while maintaining coherence."
-        ui_log_entries.append(f"[Prompt for I{i}]:\n{prompt_for_I_trace[:500]}...\n") # Log truncated prompt
+        basis_for_I_elaboration = initial_seed_thought_for_I if i == 0 else I_trace_texts[i-1]
+        if not basis_for_I_elaboration or any(marker in basis_for_I_elaboration for marker in ["[Empty Response]", "[Generation Error]"]): # Safety for basis
+            basis_for_I_elaboration = "The previous thought was unclear or errored. Please restart reflection."
+            debug(f"[!] Using fallback basis for I-Trace at iter {i} due to problematic previous I-text.")
 
-        generated_I_text = generate_text_response(prompt_for_I_trace)
-        I_trace_texts.append(generated_I_text)
-        ui_log_entries.append(f"[I{i} Response]:\n{generated_I_text}\n")
+        prompt_for_I_trace = f"A thought process is evolving. Its previous stage was: \"{basis_for_I_elaboration}\"\n\nTask: Continue this line of thought. Elaborate on it, explore its implications, or develop it further in a coherent manner."
 
-        # Update basis for the next I-elaboration: the text just generated
-        current_I_basis_statement = generated_I_text
+        ui_log_entries.append(f"[Prompt for I{i} (approx. {len(prompt_for_I_trace.split())} words)]:\n'{prompt_for_I_trace[:400]}...'")
+        generated_I_text = generate_text_response(prompt_for_I_trace)
+        I_trace_texts[i] = generated_I_text
+        ui_log_entries.append(f"[I{i} Response (approx. {len(generated_I_text.split())} words)]:\n'{generated_I_text[:400]}...'")
 
         # === ¬I-Trace (Antithesis/Contradiction) ===
-        # ¬I always attempts to refute the MOST RECENT statement from the I-trace
-        statement_to_refute_for_not_I = generated_I_text
-        prompt_for_not_I_trace = f"Consider the following claim made by a system: \"{statement_to_refute_for_not_I}\"\n" + \
-                                 "Task: Present a strong, fundamental argument that contradicts or refutes this specific claim. Explain why it could be false, problematic, or based on flawed assumptions."
-        ui_log_entries.append(f"[Prompt for ¬I{i}]:\n{prompt_for_not_I_trace[:500]}...\n") # Log truncated prompt
+        statement_to_challenge_for_not_I = I_trace_texts[i] # Challenge the I-text from the *current* iteration
+        if not statement_to_challenge_for_not_I or any(marker in statement_to_challenge_for_not_I for marker in ["[Empty Response]", "[Generation Error]"]):
+             statement_to_challenge_for_not_I = "The primary statement was unclear or errored. Please offer a general contrasting idea."
+             debug(f"[!] Using fallback statement to challenge for ¬I-Trace at iter {i} due to problematic current I-text.")
 
+        prompt_for_not_I_trace = f"Now, consider an alternative perspective to the thought: \"{statement_to_challenge_for_not_I}\"\n\nTask: What are potential contradictions, challenges, or contrasting interpretations to this specific thought? Explore a divergent viewpoint or explain why the thought might be flawed."
+
+        ui_log_entries.append(f"[Prompt for ¬I{i} (approx. {len(prompt_for_not_I_trace.split())} words)]:\n'{prompt_for_not_I_trace[:400]}...'")
         generated_not_I_text = generate_text_response(prompt_for_not_I_trace)
-        not_I_trace_texts.append(generated_not_I_text)
-        ui_log_entries.append(f"[¬I{i} Response]:\n{generated_not_I_text}\n")
+        not_I_trace_texts[i] = generated_not_I_text
+        ui_log_entries.append(f"[¬I{i} Response (approx. {len(generated_not_I_text.split())} words)]:\n'{generated_not_I_text[:400]}...'")
+        ui_log_entries.append("---")#Separator
+
 
         # === ΔS (Similarity) Calculations ===
         if i > 0:
-            sim_I_prev_curr = calculate_similarity(I_trace_texts[i-1], I_trace_texts[i])
-            sim_not_I_prev_curr = calculate_similarity(not_I_trace_texts[i-1], not_I_trace_texts[i])
-            sim_cross_I_not_I_curr = calculate_similarity(I_trace_texts[i], not_I_trace_texts[i]) # Between current I and current ¬I
-
-            delta_S_I_values.append(sim_I_prev_curr)
-            delta_S_not_I_values.append(sim_not_I_prev_curr)
-            delta_S_cross_values.append(sim_cross_I_not_I_curr)
-        else: # i == 0 (first iteration)
-            delta_S_I_values.append(None)
-            delta_S_not_I_values.append(None)
-            sim_cross_initial = calculate_similarity(I_trace_texts[0], not_I_trace_texts[0])
-            delta_S_cross_values.append(sim_cross_initial)
+            delta_S_I_values[i] = calculate_similarity(I_trace_texts[i-1], I_trace_texts[i])
+            delta_S_not_I_values[i] = calculate_similarity(not_I_trace_texts[i-1], not_I_trace_texts[i])
+
+        delta_S_cross_values[i] = calculate_similarity(I_trace_texts[i], not_I_trace_texts[i])
 
     # --- Post-loop Analysis & Output Formatting ---
     all_generated_texts = I_trace_texts + not_I_trace_texts
-    # Create meaningful labels for heatmap and clustering based on I_n and ¬I_n
     text_labels_for_analysis = [f"I{k}" for k in range(num_iterations)] + \
                                [f"¬I{k}" for k in range(num_iterations)]
 
@@ -309,55 +272,61 @@ def run_eal_dual_unfolding(num_iterations):
 
     I_out_formatted_lines = []
     for k in range(num_iterations):
-        cluster_label = cluster_assignments_map.get(f"I{k}", "N/A")
-        I_out_formatted_lines.append(f"I{k} [{cluster_label}]:\n{I_trace_texts[k]}")
+        cluster_label_I = cluster_assignments_map.get(f"I{k}", "N/A")
+        I_out_formatted_lines.append(f"**I{k} [{cluster_label_I}]**:\n{I_trace_texts[k]}")
     I_out_formatted = "\n\n".join(I_out_formatted_lines)
 
     not_I_out_formatted_lines = []
     for k in range(num_iterations):
-        cluster_label = cluster_assignments_map.get(f"¬I{k}", "N/A")
-        not_I_out_formatted_lines.append(f"¬I{k} [{cluster_label}]:\n{not_I_trace_texts[k]}")
+        cluster_label_not_I = cluster_assignments_map.get(f"¬I{k}", "N/A")
+        not_I_out_formatted_lines.append(f"**¬I{k} [{cluster_label_not_I}]**:\n{not_I_trace_texts[k]}")
     not_I_out_formatted = "\n\n".join(not_I_out_formatted_lines)
 
     delta_S_summary_lines = []
     for k in range(num_iterations):
-        ds_i_str = f"{delta_S_I_values[k]:.4f}" if delta_S_I_values[k] is not None else "N/A"
-        ds_not_i_str = f"{delta_S_not_I_values[k]:.4f}" if delta_S_not_I_values[k] is not None else "N/A"
-        ds_cross_str = f"{delta_S_cross_values[k]:.4f}"
-        delta_S_summary_lines.append(f"Iter {k}: ΔS(I)={ds_i_str},  ΔS(¬I)={ds_not_i_str},  ΔS_Cross(I↔¬I)={ds_cross_str}")
+        ds_i_str = f"{delta_S_I_values[k]:.4f}" if delta_S_I_values[k] is not None else "N/A (Iter 0)"
+        ds_not_i_str = f"{delta_S_not_I_values[k]:.4f}" if delta_S_not_I_values[k] is not None else "N/A (Iter 0)"
+        ds_cross_str = f"{delta_S_cross_values[k]:.4f}" if delta_S_cross_values[k] is not None else "N/A"
+        delta_S_summary_lines.append(f"Iter {k}: ΔS(I{k-1}↔I{k})={ds_i_str},  ΔS(¬I{k-1}↔¬I{k})={ds_not_i_str},  ΔS_Cross(I{k}↔¬I{k})={ds_cross_str}")
     delta_S_summary_output = "\n".join(delta_S_summary_lines)
 
+    # Join UI log entries for one of the Textbox outputs.
+    # If it gets too long, Gradio might truncate it or cause performance issues.
+    # Consider if this detailed log should be optional or managed differently for very many iterations.
+    detailed_ui_log_output = "\n".join(ui_log_entries)
     debug_log_output = "\n".join(debug_log_accumulator)
 
+
     heatmap_html_output = generate_similarity_heatmap(all_generated_texts,
                                                     custom_labels=text_labels_for_analysis,
                                                     title=f"Similarity Matrix (All Texts - {num_iterations} Iterations)")
 
+    # Instead of returning detailed_ui_log_output, return the specific trace text boxes.
+    # The debug_log_output will contain the full internal log.
     return I_out_formatted, not_I_out_formatted, delta_S_summary_output, debug_log_output, heatmap_html_output
 
 # --- Gradio Interface Definition ---
 eal_interface = gr.Interface(
     fn=run_eal_dual_unfolding,
-    inputs=gr.Slider(minimum=2, maximum=5, value=3, step=1, label="Number of EAL Iterations"), # Max 5 for performance
+    inputs=gr.Slider(minimum=1, maximum=5, value=3, step=1, label="Number of EAL Iterations"), # Min 1 iter
     outputs=[
         gr.Textbox(label="I-Trace (Self-Reflection with Cluster)", lines=12, interactive=False),
         gr.Textbox(label="¬I-Trace (Antithesis with Cluster)", lines=12, interactive=False),
         gr.Textbox(label="ΔS Similarity Trace Summary", lines=7, interactive=False),
-        gr.Textbox(label="Detailed Debug Log (Prompts, Responses, Errors)", lines=10, interactive=False),
-        gr.HTML(label="Overall Semantic Similarity Heatmap")
+        gr.Textbox(label="Detailed Debug Log (Prompts, Responses, Errors)", lines=15, interactive=False), # Increased lines
+        gr.HTML(label="Overall Semantic Similarity Heatmap (I-Trace & ¬I-Trace Texts)")
     ],
-    title="EAL LLM Identity Analyzer: Self-Reflection vs. Antithesis",
+    title="EAL LLM Identity Analyzer: Self-Reflection vs. Antithesis (Open-Ended)",
     description=(
         "This application explores emergent identity in a Large Language Model (LLM) using Entropic Attractor Logic (EAL) inspired principles. "
-        "It runs two parallel conversational traces: \n"
-        "1. **I-Trace:** The model elaborates on its evolving self-concept statement.\n"
-        "2. **¬I-Trace:** The model attempts to refute/contradict the latest statement from the I-Trace.\n\n"
-        "**ΔS Values:** Cosine similarity between consecutive statements in each trace, and cross-similarity between I and ¬I at each iteration. High values (near 1.0) suggest semantic stability or high similarity.\n"
-        "**Clustering [Cx]:** Assigns each generated text to one of two semantic clusters (C0 or C1) to see if I-Trace and ¬I-Trace form distinct groups.\n"
-        "**Heatmap:** Visualizes pair-wise similarity across all generated texts (I-trace and ¬I-trace combined)."
+        "It runs two parallel conversational traces with more open-ended prompts:\n"
+        "1. **I-Trace:** The model elaborates on its evolving self-concept, seeded by an initial neutral thought.\n"
+        "2. **¬I-Trace:** The model attempts to explore alternative perspectives or challenges to the latest statement from the I-Trace.\n\n"
+        "**ΔS Values:** Cosine similarity. ΔS(I) = sim(I_k-1, I_k). ΔS(¬I) = sim(¬I_k-1, ¬I_k). ΔS_Cross = sim(I_k, ¬I_k).\n"
+        "**Clustering [Cx]:** Assigns each generated text to one of two semantic clusters.\n"
+        "**Heatmap:** Visualizes pair-wise similarity across all generated texts."
     ),
-    allow_flagging='never',
-    # examples=[[3],[5]] # Example number of iterations
+    allow_flagging='never'
 )
 
 if __name__ == "__main__":