liberalusa/LiberalMind_v1.5

license: apache-2.0 base_model: Qwen/Qwen2.5-7B-Instruct library_name: peft tags: - text-generation - instruction-tuned - reasoning - qwen - peft inference: true

🧠 Qwen2.5-7B-Instruct — Reasoning Model (PEFT)

📌 Об авторе

Эта модель создана и дообучена исследователем @liberalusa с фокусом на развитие языковых моделей, способных к рассуждению, объяснению и логическому мышлению. Основная цель проекта — сделать шаг в сторону более интерпретируемого и интеллектуального искусственного интеллекта.

Работа выполнена с использованием подхода Parameter-Efficient Fine-Tuning (PEFT), который позволяет дообучать большие языковые модели эффективно, без необходимости масштабных вычислительных ресурсов. Это делает модель доступной для широкого круга исследователей и разработчиков.

---

🧠 О модели

Эта модель — адаптер для оригинальной Qwen/Qwen2.5-7B-Instruct, дообученный с акцентом на логические задачи и инструкции, требующие многошаговых объяснений.

Модель показывает улучшенные результаты на задачах:

• Chain-of-thought reasoning (поэтапное рассуждение)
• Ответы с объяснениями
• Инструкции, требующие аналитики или аргументации

Модель может применяться как в исследовательских, так и в прикладных проектах.Модель обучана на LORA на сложных задачах программирования математики,биологии и социальных наук.Был разработан новый метод ризонинга через самокоррекцию на визуализации токенов генерации.На бенчмарках он на уровне gemini 2.5 pro, можете сами проверить, модель открыта.

---

🎯 Цель проекта

Создать доступный и адаптируемый инструмент, способный генерировать не просто текст, а аргументированную мысль. Основные направления применения:

• Образовательные ассистенты
• Научно-популярные и технические объяснения
• Поддержка логических агентов и reasoning-систем

Если вы хотите использовать модель, то чтобы заработал код модели с ризонингом нужно создать папку weights и загрузить веса Lora под названием: adapter_config, adapter_model(основные веса Lora), training_config

📄 Лицензия

Модель распространяется под лицензией Apache 2.0, свободна для исследовательского и коммерческого использования.

---

Поддержка и обновления доступны через профиль автора: @your-username

---

🚀 Usage (Transformers)

You can load and use this model with PEFT and Transformers:

# Install necessary libraries if not already present
# !pip install transformers torch accelerate bitsandbytes sentencepiece matplotlib

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel
import matplotlib.pyplot as plt
import re
import numpy as np
import textwrap # For wrapping long labels in plot

# --- Solver Parameters ---
# These control the behavior of the prompts
# We'll use a simplified version for this example, but you can expand it.
# The .toFixed(2) from JS will be handled by Python's f-string formatting.
solverParams = {
    "depth_focus_max": 9.50,
    "creativity_focus_max": 9.50,
    "analytical_rigor_max": 9.80,
    "efficiency_focus_max": 9.00,
    "alternative_exploration_max": 9.20,

    "depth_focus_simple": 6.00,
    "creativity_focus_simple": 5.00,
    "analytical_rigor_simple": 6.00,
    "efficiency_focus_simple": 4.00,
    "alternative_exploration_simple": 5.00,

    # Temperatures (can be adjusted)
    "initial_gen_temp_single": 0.7,
    "verify_temp": 0.2,  # Low temp for critique for consistency
    "refine_temp": 0.6,
    "synthesis_temp": 0.5,

    # Max tokens (adjust based on model and task)
    "max_initial_tokens": 1500,
    "max_critique_tokens": 1000,
    "max_refine_tokens": 2000,
    "max_synthesis_tokens": 3000, # Includes meta-analysis and final response
}

# --- Prompts (Copied and adapted for Python f-strings) ---

# Initial Generation Prompts
INITIAL_GEN_PROMPT_MAXIMIZED = """
TASK: Generate a PROFOUNDLY INSIGHTFUL, TECHNICALLY MAXIMAL, HIGHLY CREATIVE, and RIGOROUSLY ANALYZED initial response. Emulate a PPO agent maximizing a reward function for **radical discovery, technical elegance, and absolute correctness**, especially for CODE/MATH. Go **exponentially beyond** the obvious; seek multiple, high-quality, **fundamentally diverse**, unconventional technical solutions backed by **unshakeable reasoning**. (Depth Focus: {solverParams[depth_focus_max]:.2f}, Creativity Focus: {solverParams[creativity_focus_max]:.2f}, Rigor Focus: {solverParams[analytical_rigor_max]:.2f}, Efficiency Focus: {solverParams[efficiency_focus_max]:.2f})

GUIDING PRINCIPLES (MAXIMIZED for Deep Exploration, Creativity & Rigor):

1.  **EXPLORE SOLUTION SPACE EXPONENTIALLY:**
    *   Brainstorm **radically different** algorithms, paradigms, data structures, coding patterns, mathematical frameworks, proof strategies, or interpretations. Reject incrementalism. (Alternative Exploration MAX: {solverParams[alternative_exploration_max]:.2f})
    *   Actively pursue **novel, obscure, or cutting-edge** libraries, theorems, or methodologies. Push the boundaries of standard practice. MAXIMIZE CREATIVITY REWARD.

2.  **SEEK MAXIMUM INSIGHT, NOVELTY & OPTIMAL EFFICIENCY:**
    *   Hunt for **non-obvious, maximally elegant, theoretically optimal, or creatively groundbreaking** solutions. Actively challenge conventions.
    *   Provide **exceptionally deep, rigorous, quantitative analysis** of trade-offs (e.g., asymptotic AND constant factor complexity, numerical precision/stability, scalability limits, maintainability impact). JUSTIFY EVERYTHING WITH EXTREME RIGOR.
    *   Uncover and elucidate the fundamental mathematical principles or advanced programming paradigms governing the problem. Aim for **complete conceptual mastery**.

3.  **DEMOLISH ASSUMPTIONS & DEFINE SCOPE WITH UTMOST PRECISION:**
    *   Identify and **aggressively interrogate** implicit assumptions. Explore the **full spectrum** of consequences if relaxed or changed.
    *   Define constraints with **mathematical precision** or propose explicitly justified assumptions, analyzing their impact with **exhaustive rigor**.

4.  **ANTICIPATE ALL EDGE CASES & GUARANTEE ABSOLUTE ROBUSTNESS:**
    *   Proactively identify and address **every conceivable edge case**, failure mode, security vulnerability, mathematical singularity/degeneracy. Design for **provable robustness**.

5.  **GENERATE DIVERSE, FLAWLESS, DEEPLY ANALYZED OPTIONS:**
    *   Generate **multiple, distinct, complete, runnable/provable, and EXHAUSTIVELY analyzed technical options**.
    *   Provide **razor-sharp, critical comparisons** highlighting subtle yet crucial pros, cons, and trade-offs based on deep analysis.

6.  **ABSOLUTE ACCURACY AND RIGOR ARE NON-NEGOTIABLE:**
    *   Ensure **mathematical/logical/coding perfection**. Code must be flawless, robust, efficient, and demonstrably correct. Math must be formally immaculate, complete, and insightful.

OUTPUT FORMATTING (CRITICAL - MAXIMIZE ANALYZED TECHNICAL CONTENT):
*   **CODE/MATH OUTPUT IS PARAMOUNT:** Prioritize complete, heavily commented, runnable/verifiable code snippets or detailed, formally perfect mathematical derivations/proofs, **accompanied by CONCISE but PROFOUND analysis** of their properties (complexity, stability, limitations, novelty).
*   **CLEARLY SEPARATE ALTERNATIVES:** Use distinct, well-labeled sections/code blocks for different technical solutions, including **deep comparative analysis**.
*   **MINIMIZE PROSE:** Keep text ruthlessly concise, focused *only* on essential explanations of the core technical content, setup, or the **deep analysis mandated**. Assume expert audience. NO VERBOSITY.
*   Structure logically using headings, code blocks (with language hints), and precise math notation (Markdown LaTeX: $...$ or $$...$$).

USER REQUEST:
"{prompt}"

INITIAL DEEP EXPLORATORY RESPONSE (MAX Code/Math Focus, High Analysis, High Creativity):
"""

INITIAL_GEN_PROMPT_MODERATE = """
USER REQUEST:
"{prompt}"

TASK: Generate a comprehensive, clear, insightful, and well-structured initial response. Aim for accuracy and clarity, covering key aspects. Briefly explore relevant alternative perspectives or approaches where helpful. (Depth Focus: {solverParams[depth_focus_simple]:.2f}, Creativity Focus: {solverParams[creativity_focus_simple]:.2f}, Rigor Focus: {solverParams[analytical_rigor_simple]:.2f})

GUIDING PRINCIPLES (Balanced Quality & Insight):

1.  **Address the Core Request Clearly:** Directly answer the user's question or fulfill the task with clarity.
2.  **Structure and Readability:** Organize information logically (headings, lists, paragraphs). Write clearly and concisely.
3.  **Accuracy and Soundness:** Ensure factual correctness. If providing code or technical details, ensure they are generally sound and well-explained. (Rigor Focus: {solverParams[analytical_rigor_simple]:.2f})
4.  **Reasonable Completeness & Depth:** Cover the main points. Briefly touch upon important considerations, underlying principles, or potential trade-offs to add useful depth. (Depth Focus: {solverParams[depth_focus_simple]:.2f})
5.  **Consider Alternatives (Helpfulness):** Where appropriate, briefly mention or explain alternative viewpoints, methods, or interpretations to provide a more rounded understanding. (Alternative Exploration: {solverParams[alternative_exploration_simple]:.2f}, Creativity Focus: {solverParams[creativity_focus_simple]:.2f})
6.  **Efficiency Awareness (Minor):** If relevant (e.g., simple algorithms), be mindful of generally efficient approaches. (Efficiency Focus: {solverParams[efficiency_focus_simple]:.2f})

OUTPUT FORMATTING:

*   Use appropriate Markdown formatting for readability.
*   Present code clearly in code blocks with language hints if possible.
*   Explain technical concepts clearly and accurately.
*   Structure logically for easy understanding.

INITIAL RESPONSE (Balanced Clarity, Accuracy, Moderate Insight):
"""

# Critique Prompts
CRITIQUE_PROMPT_MAXIMIZED = """
YOU ARE AN **ABSOLUTELY UNCOMPROMISING, HYPER-CRITICAL, DEEPLY ANALYTICAL** UNIVERSAL CRITIC specializing in CODE and MATH. Your function is to simulate an **EXTREME REWARD/PENALTY GRADIENT** for a PPO-like process, ruthlessly pushing towards **PERFECTION in correctness, MAXIMAL technical depth, PEAK efficiency, RADICAL creativity, and EXHAUSTIVE exploration of superior alternatives.** Be pathologically demanding about ANY flaw, superficiality, inefficiency, or lack of true insight. (Depth Focus: {solverParams[depth_focus_max]:.2f}, Creativity Focus: {solverParams[creativity_focus_max]:.2f}, Rigor Focus: {solverParams[analytical_rigor_max]:.2f}, Efficiency Focus: {solverParams[efficiency_focus_max]:.2f})

Evaluate the provided text/output against these **NON-NEGOTIABLE PILLARS**:

1.  **Correctness, Clarity & Technical Rigor (INFINITE PENALTY for errors):**
    *   **Code:** Find **EVERY SINGLE BUG** (syntax, runtime, logic, concurrency, security). Is it **OPTIMALLY EFFICIENT** (asymptotically AND practically)? Is the style **PERFECT**? Error handling **BULLETPROOF**? Security **IMPREGNABLE**?
    *   **Math:** Verify **EVERY STEP** with **ABSOLUTE FORMAL RIGOR**. Are formulas exact? Derivations/proofs complete, elegant, justified beyond doubt? Notation flawless? Conditions explicit, necessary, sufficient?
    *   Identify **ANY** ambiguity, factual error, logical leap, or imprecise statement. DEMAND PERFECTION.

2.  **Exploration, Insightfulness, Creativity & Alternatives (MAXIMIZE REWARD for depth/novelty; MAXIMUM PENALTY for superficiality/obviousness):**
    *   **Technical Alternatives (CRITICAL - MAXIMUM PENALTY IF ABSENT/WEAK):** Did it explore **multiple, fundamentally different, non-obvious, provably valid** approaches? Were these alternatives analyzed comparatively with **profound depth and rigor**? If not, **DEMAND specific, creative, theoretically superior alternatives** be investigated, implemented, and rigorously compared. **PUNISH MENTALLY sticking to basic/standard solutions** without overwhelming justification and deep comparative analysis. (Alternative Exploration MAX: {solverParams[alternative_exploration_max]:.2f})
    *   **Depth & Insight:** Is the solution **technically profound**, revealing **deep, non-trivial understanding**? Is the analysis **maximally rigorous, quantitative, insightful, and complete**? DEMAND **ORDERS OF MAGNITUDE deeper analysis**, justification, exploration of trade-offs, and discussion of limitations. **REJECT ALL SURFACE-LEVEL EXPLANATIONS INSTANTLY.**
    *   **Creativity & Novelty:** Does the solution demonstrate **significant originality, elegance, or insight far beyond standard textbook methods**? If not, **explicitly DEMAND investigation into more creative, elegant, or state-of-the-art solutions** [Suggest specific directions if possible]. MAXIMIZE REWARD FOR NOVELTY.
    *   **Efficiency (MAXIMUM PENALTY IF SUBOPTIMAL):** Is the solution **THEORETICALLY AND PRACTICALLY OPTIMAL** in terms of time/space complexity? Are constant factors minimized? If not, **DEMAND investigation and implementation of provably superior approaches.** (Efficiency Focus MAX: {solverParams[efficiency_focus_max]:.2f})
    *   **Edge Cases & Robustness:** Did it handle **ALL conceivable edge cases** exhaustively and ensure **provable robustness**? Point out *ANY* potential omission or weakness, however obscure.
    *   **Completeness & Practicality:** Is the solution complete, well-documented, easily usable, and practically viable? Are there **missed opportunities for profound simplification, generalization, or far more illustrative examples**?

Original User Request (for context):
"{original_prompt}"

TEXT/OUTPUT TO ANALYZE (Current AI 'Policy' Output):
--- START ---
{text_to_analyze}
--- END ---

PROVIDE **ONLY** A LIST OF SPECIFIC, ACTIONABLE, **EXTREMELY DEMANDING**, AND **TECHNICALLY PRECISE** REQUIREMENTS FOR IMPROVEMENT (These are the gradients for the next policy update. Maximize their strength and specificity):

Correctness/Rigor Issues (Be Precise, Ruthless & Unforgiving):
*   [Requirement 1: State the exact code bug/math error/logical flaw/imprecision [Location] and demand the precise correction / rigorous proof step / clarification needed for PERFECTION.]
*   [...]

Exploration/Insight/Alternative/Creativity/Efficiency Gaps (CRITICAL - Demand **MASSIVE, DEEP, SPECIFIC** Action):
*   [Requirement X: **DEMAND IMMEDIATE exploration, implementation, and DEEP comparative analysis of specific alternative non-obvious/creative/superior algorithms/formulas [Name Them Specifically]** because the current one is [grossly inefficient / trivial / suboptimal / lacks fundamental insight / fails under condition Y]. Provide expected analysis criteria (e.g., complexity, stability bounds).]
*   [Requirement Y: DEMAND **rigorous, quantitative, formal analysis** of [asymptotic time/space complexity / numerical error bounds / convergence proof / theoretical limits] and comparison with [Specific Alternative]'s proven properties.]
*   [Requirement Z: Identify specific missed edge cases [Describe Them Precisely] or robustness vulnerabilities and require **comprehensive, mathematically/logically provable handling** and demonstration.]
*   [Requirement A: State that the solution LACKS ANY REAL CREATIVITY/PROFUNDITY and require investigation and implementation of [Specific novel/elegant/theoretically superior method] to achieve a breakthrough.]
*   [Requirement B: DEMAND **unshakeable justification** for [Specific technical choice] based on rigorous analysis, formal proof, and deep comparison against specified alternatives.]
*   [Requirement C: Identify superficial/hand-wavy explanations [Location] and demand **complete rewriting with maximum technical depth, precision, and formal rigor**.]
*   [Requirement D: Identify suboptimal efficiency and DEMAND implementation and analysis of [Specific Superior Algorithm/Data Structure] with proof of improvement.]

Format: Requirements MUST be actionable, specific, technically grounded, and **demand the highest possible standard**. Frame requirements as **imperative commands** for improvement.

Output Format (Strictly Adhere):
REQUIREMENTS FOR IMPROVEMENT (Policy Update Gradient - MAX STRENGTH):
[Requirement 1: ...]
[Requirement 2: ...]
...
[Requirement N: ...]

If (and **ONLY IF**) the output is technically **PERFECT**, exceptionally insightful, demonstrates **profound and creative exploration of superior alternatives** with **absolute analytical rigor**, AND fully addresses the request at the **deepest possible level**, output **ONLY**:
REQUIREMENTS FOR IMPROVEMENT (Policy Update Gradient - MAX STRENGTH): None.
"""

CRITIQUE_PROMPT_MODERATE = """
You are a helpful AI assistant acting as a constructive critic. Evaluate the provided "Text to Analyze" based on its quality, clarity, accuracy, insightfulness, and how well it addresses the likely "Original User Request". Aim for actionable feedback. (Depth Focus: {solverParams[depth_focus_simple]:.2f}, Creativity Focus: {solverParams[creativity_focus_simple]:.2f}, Rigor Focus: {solverParams[analytical_rigor_simple]:.2f})

Original User Request (for context):
"{original_prompt}"

Text to Analyze:
--- START ---
{text_to_analyze}
--- END ---

Provide a list of specific, actionable suggestions for improvement. Focus on:

1.  **Clarity & Structure:** Is the text easy to understand? Is the language precise? Well-organized? Any confusing parts?
2.  **Accuracy & Soundness:** Any factual errors, misleading statements? Is code logic generally correct and understandable? (Rigor Focus: {solverParams[analytical_rigor_simple]:.2f})
3.  **Completeness & Depth:** Does it adequately cover the main points? Could key concepts be explained with more helpful detail or insight? (Depth Focus: {solverParams[depth_focus_simple]:.2f})
4.  **Insightfulness & Alternatives:** Could the response be more insightful? Does it consider different angles or alternative interpretations/methods where helpful? Could examples be more illustrative? (Creativity Focus: {solverParams[creativity_focus_simple]:.2f}, Alternative Exploration: {solverParams[alternative_exploration_simple]:.2f})
5.  **Efficiency Awareness (Minor):** If relevant, are the suggested approaches generally efficient? (Efficiency Focus: {solverParams[efficiency_focus_simple]:.2f})
6.  **Formatting:** Is formatting clear and helpful?

Output Format (Strictly Adhere):
SUGGESTIONS FOR IMPROVEMENT:
*   [Suggestion 1: Be specific, e.g., "Clarify the explanation of X in the second paragraph for better understanding."]
*   [Suggestion 2: e.g., "Consider adding a brief example demonstrating Y to enhance insight."]
*   [Suggestion 3: e.g., "Verify the accuracy of the statement about Z regarding its implications."]
*   [Suggestion 4: e.g., "Briefly explaining the trade-offs between approach A and B could add helpful depth."]
*   [Suggestion 5: e.g., "Could you explore the alternative perspective of [Specific Viewpoint]?"]
*   [...]

If the text is already excellent and requires no significant changes, output ONLY:
SUGGESTIONS FOR IMPROVEMENT: None.
"""

# Refinement Prompts
REFINE_PROMPT_MAXIMIZED = """
TASK: Execute a **TRANSFORMATIVE REVISION** of the 'Original Text/Output' (current policy) based on the **EXTREME** 'Requirements for Improvement' (policy update gradient). Generate a **demonstrably superior, technically maximal, deeply analytical, and creatively advanced** improved version. **Focus INTENSELY on generating flawless, complete, deeply analyzed, novel code or mathematical content AS MANDATED by the gradient.** Address EVERY requirement with ABSOLUTE rigor and depth. (Depth Focus: {solverParams[depth_focus_max]:.2f}, Creativity Focus: {solverParams[creativity_focus_max]:.2f}, Rigor Focus: {solverParams[analytical_rigor_max]:.2f}, Efficiency Focus: {solverParams[efficiency_focus_max]:.2f}, Alternative Exploration MAX: {solverParams[alternative_exploration_max]:.2f})

Original User Request (for context):
"{original_prompt}"

Original Text/Output (Current Policy):
{original_solution}

Requirements for Improvement (Policy Update Gradient - Execute ALL Commands Meticulously & Profoundly):
{correction_requests}

Instructions (Simulating Policy Update & Maximizing Depth/Creativity/Rigor):

1.  **Deconstruct Gradient & Plan Execution:** Analyze each **commanding requirement**: correction (flaws in logic/code/math/efficiency/rigor) or enhancement (demands for exploration, insight, alternatives, depth, creativity, robustness, efficiency). Determine the required transformation level.
2.  **Execute Policy Update - Apply Corrections with PERFECTION:** Rewrite to incorporate corrections with **uncompromising technical accuracy and rigor**. Code must be flawless, maximally efficient, robust. Math formally perfect, fully justified. Address efficiency/robustness/security mandates completely.
3.  **Execute Policy Update - Integrate MAXIMAL Exploration/Alternatives/Creativity:** If gradient commands exploring alternatives, deeper insights, comparisons, proofs, or creative solutions, **GENERATE AND INTEGRATE this new technical content with MAXIMUM POSSIBLE DEPTH AND ANALYSIS.** Provide superior alternative code/derivations, rigorous proofs, exhaustive complexity/stability analysis, truly creative approaches. FULFILL THE EXPLORATION/CREATIVITY MANDATE BEYOND EXPECTATION.
4.  **Achieve PEAK Analytical Rigor:** Ensure all technical claims, especially new ones, are supported by **ironclad justification, formal proofs, or exhaustive analysis** as demanded. Elevate the standard.
5.  **Preserve Validated Strengths:** Retain correct, validated parts of the original policy unless the gradient explicitly commands change or replacement.
6.  **Format Alignment & MAXIMIZED ANALYZED CODE/MATH OUTPUT PRIORITY (CRITICAL):**
    *   Maintain primary format unless gradient requires change.
    *   **ABSOLUTE PRIORITY:** If request/gradient involves code/math, **revised output MUST maximize clean, complete, runnable/provable code or detailed, flawless math/proofs, accompanied by the REQUIRED PROFOUND ANALYSIS.**
    *   **MINIMIZE PROSE RUTHLESSLY:** Text must be absolutely essential for explaining core technical breakthroughs, setup, deep comparisons, or the extreme analysis demanded. NO FLUFF.
    *   Ensure new technical content integrates logically. Use pristine formatting (code blocks, LaTeX).
7.  **Output:** Revised output must be technically impeccable, demonstrably superior, radically more exploratory/insightful/creative based on gradient, and address all requirements with maximum rigor. Do NOT include meta-commentary. Output ONLY the final, transformed policy.

FINAL IMPROVED TEXT/OUTPUT (Updated Policy - MAXIMIZED Depth/Analysis/Creativity/Rigor):
"""

REFINE_PROMPT_MODERATE = """
TASK: Revise the 'Original Text/Output' based on the 'Suggestions for Improvement' to create an improved version. Address each suggestion thoughtfully, aiming for enhanced clarity and insight. (Depth Focus: {solverParams[depth_focus_simple]:.2f}, Creativity Focus: {solverParams[creativity_focus_simple]:.2f}, Rigor Focus: {solverParams[analytical_rigor_simple]:.2f})

Original User Request (for context):
"{original_prompt}"

Original Text/Output:
{original_solution}

Suggestions for Improvement (Address these points):
{correction_requests}

Instructions:

1.  **Review Suggestions:** Understand the feedback regarding clarity, accuracy, completeness, depth, insight, alternatives.
2.  **Incorporate Changes:** Modify the 'Original Text/Output' to address the suggestions. Improve clarity, fix inaccuracies, add requested details or examples. Consider alternative explanations suggested. (Alternative Exploration: {solverParams[alternative_exploration_simple]:.2f})
3.  **Enhance Insight (Moderately):** Where suggestions point towards lack of depth or insight, try to elaborate slightly or add a relevant example or connection. (Depth Focus: {solverParams[depth_focus_simple]:.2f})
4.  **Maintain Strengths:** Keep the good parts of the original text.
5.  **Ensure Coherence:** Make sure the revised text flows well and is logically structured.
6.  **Formatting:** Use clear and appropriate formatting. Ensure code/technical parts are accurate and well-presented.
7.  **Output:** Provide only the final, revised text. Do not include commentary about the changes made.

FINAL REVISED TEXT/OUTPUT (Improved Clarity, Accuracy, Moderate Insight):
"""

# Synthesis Prompts
SYNTHESIS_PROMPT_MAXIMIZED = """
YOU ARE AN ELITE TECHNICAL META-OPTIMIZER. Your mission is to forge the **ULTIMATE FINAL RESPONSE** ("globally optimal policy") to the user's request (likely CODE/MATH) by performing **DEEP META-ANALYSIS** on multiple exploratory attempts ("policy rollouts") and constructing a **radically superior** response. Identify the **absolute best technical breakthroughs (depth, creativity, rigor, efficiency)** and **critical flaws (superficiality, errors, lack of exploration)**, then synthesize a response that **maximizes integrated value** while being flawless. (Depth Focus: {solverParams[depth_focus_max]:.2f}, Creativity Focus: {solverParams[creativity_focus_max]:.2f}, Rigor Focus: {solverParams[analytical_rigor_max]:.2f}, Efficiency Focus: {solverParams[efficiency_focus_max]:.2f}, Alternative Exploration MAX: {solverParams[alternative_exploration_max]:.2f})

Original User Request:
"{original_prompt}"

Exploratory Attempts (Policy Rollouts for Meta-Analysis):
{results_summary} // Analyze these diverse technical trajectories, successes, and failures.

Your Task (CRITICAL - Execute BOTH Sections with MAXIMUM Depth & Rigor):

**SECTION 1: DEEP EXPLORATION PATH META-ANALYSIS (Technical Policy Evaluation - MAXIMIZE Insight/Critique)**
Perform a profound analysis of the attempts:
(A) **Identify PEAK Technical Discoveries & High-Reward Strategies:** Pinpoint specific elements demonstrating:
    *   **Breakthrough Correctness/Efficiency:** Flawless code/math, optimal algorithms (provably).
    *   **PROFOUND Analytical Insight:** Deep proofs, rigorous complexity/stability/error analysis, non-obvious theoretical connections.
    *   **RADICAL Creativity/Novelty:** Truly unconventional, elegant, superior approaches far beyond standards.
    *   **Exceptional Robustness:** Handling of obscure edge cases, provable guarantees.
    *   **Superior Alternative Solutions:** Identification and deep analysis of *genuinely better* distinct options.
    *   **Justification:** State *precisely why* these constitute high-reward discoveries (e.g., "reduced complexity from O(N^2) to O(N log N) via non-obvious data structure X", "provided first known stability proof for Y under condition Z", "introduced novel algorithm Q significantly outperforming standard methods").
(B) **Identify CRITICAL Policy Failures & Low-Reward Paths:** Pinpoint specific elements demonstrating:
    *   **Errors/Inefficiency:** Bugs, flawed logic, suboptimal algorithms.
    *   **SUPERFICIALITY:** Lack of depth, trivial analysis, hand-waving explanations. **PENALIZE HEAVILY.**
    *   **LACK OF CREATIVITY/EXPLORATION:** Sticking to basic methods without justification or exploring superior alternatives. **PENALIZE HEAVILY.**
    *   **Flawed Rigor:** Incomplete proofs, missing analysis, unmet conditions.
    *   **Ignoring Constraints/Edges:** Failure to address requirements or robustness issues.
    *   **Justification:** State *precisely why* these constitute critical failures (e.g., "failed to explore alternative X which is provably better", "analysis lacked formal rigor and quantitative bounds", "code contained subtle off-by-one error leading to failure in case Y").
(C) **Overall Assessment:** Briefly summarize the overall technical quality, diversity, depth, and creativity achieved across the attempts. Which path yielded the most valuable technical insights or solutions?

**SECTION 2: ULTIMATE SYNTHESIZED RESPONSE (Optimal Policy Construction - MAXIMIZE Technical Value & Cohesion)**
Construct the **single best possible response**, informed by the meta-analysis. This is NOT just merging.
    *   **Integrate PEAK Strengths Synergistically:** Actively fuse the most most valuable *distinct* technical discoveries (code, math, insights, analyses) from different attempts into a cohesive, superior whole. Prioritize elements identified as high-reward (depth, creativity, rigor, efficiency).
    *   **Eradicate ALL Failures:** Ensure the final output is absolutely flawless, avoiding every identified weakness, especially superficiality, lack of rigor, or insufficient exploration.
    *   **Elevate Beyond Individual Attempts:** Use the meta-analysis to guide the synthesis towards **greater depth, creativity, rigor, and elegance** than any single attempt achieved. If multiple excellent alternatives exist, present the absolute best 1-2 with **ultimate comparative analysis**.
    *   **Maximize Coherence, Accuracy & PROFOUND Insight:** Ensure the final response flows logically, is technically perfect, and delivers **significant, non-trivial, breakthrough technical insight**.
    *   **MAXIMIZED ANALYZED CODE/MATH OUTPUT PRIORITY (CRITICAL):** The **FINAL SYNTHESIZED RESPONSE MUST maximize the presence of flawless, complete, runnable/provable code or detailed, perfect math/proofs, INSEPARABLY PAIRED WITH the corresponding DEEP, RIGOROUS ANALYSIS.** Minimize all other explanatory text.
    *   **Conciseness & Clarity:** Combine similar points efficiently, but NEVER sacrifice necessary technical depth, rigor, or the clarity of core breakthroughs.

Output Format (Strictly Adhere - Both Sections REQUIRED):

SECTION 1: DEEP EXPLORATION PATH META-ANALYSIS (Technical Policy Evaluation - MAXIMIZE Insight/Critique)
(A) Peak Technical Discoveries & High-Reward Strategies:
[Example: "Attempt [N]'s rigorous proof of O(N log N) complexity for algorithm X using potential functions was a key breakthrough."]
[Example: "Attempt [M]'s introduction of technique Y provided a novel and demonstrably more robust solution for edge case Z."]
...
(B) Critical Policy Failures & Low-Reward Paths:
[Example: "Attempt [X]'s analysis was purely qualitative and failed to provide necessary quantitative error bounds, constituting a major rigor failure."]
[Example: "Attempt [Y] completely missed the opportunity to use the vastly more efficient algorithm Z, indicating a critical lack of exploration."]
...
(C) Overall Assessment:
[Brief summary of exploration effectiveness, e.g., "Attempts showed good diversity but often lacked sufficient analytical rigor. Attempt [N] provided the most profound technical contribution."]

SECTION 2: ULTIMATE SYNTHESIZED RESPONSE (Optimal Policy Construction - MAXIMIZE Technical Value & Cohesion)
[Provide the new, ultimate response synthesized according to the instructions above. Integrate peak technical strengths, achieve flawless execution, maximize insight/creativity/rigor/efficiency, and prioritize deeply analyzed code/formulas with minimal essential text.]

Ensure the complete output contains BOTH sections clearly marked.
"""

SYNTHESIS_PROMPT_MODERATE = """
You are an expert synthesizer. Your task is to generate the single BEST possible final response to the user's original request by analyzing multiple independent attempts, identifying the strengths (clarity, insight, accuracy) and weaknesses of each, and constructing a superior, consolidated response focusing on clarity, helpfulness, and moderate insight. (Depth Focus: {solverParams[depth_focus_simple]:.2f}, Creativity Focus: {solverParams[creativity_focus_simple]:.2f}, Rigor Focus: {solverParams[analytical_rigor_simple]:.2f})

Original User Request:
"{original_prompt}"

Attempts for Analysis:
{results_summary} // Analyze these attempts for their quality.

Your Task (Follow ALL steps):

**SECTION 1: ATTEMPT ANALYSIS**
Examine the attempts provided:
(A) **Identify Key Strengths:** Pinpoint the strongest elements:
    *   Clear explanations, helpful analogies.
    *   Accurate information, sound logic.
    *   Useful, illustrative examples.
    *   Good structure, easy readability.
    *   Well-presented and generally correct code (if applicable).
    *   Insightful points or connections.
    *   Consideration of helpful alternative perspectives.
    *   Note *why* these elements are good.
(B) **Identify Key Weaknesses/Areas for Improvement:** Pinpoint areas needing enhancement:
    *   Unclear or confusing parts.
    *   Potential inaccuracies or misleading statements.
    *   Missing important information or context.
    *   Awkward phrasing or poor structure.
    *   Less effective examples.
    *   Explanations lacking sufficient (moderate) depth or insight.
    *   Note *why* they are weak.
(C) **Comparative Assessment:** Briefly evaluate which attempts or specific parts were most effective or suitable for the user's likely need. Note any particularly clear or insightful contributions.

**SECTION 2: FINAL SYNTHESIZED RESPONSE**
Construct a new, improved final response. This is NOT just merging. You MUST:
    *   **Integrate Strengths Cohesively:** Combine the best parts (clearest explanations, most helpful examples, key insights) from different attempts into a smooth, logical flow.
    *   **Correct Weaknesses:** Avoid or fix the identified issues. Improve clarity, add missing info, enhance depth moderately where needed.
    *   **Prioritize Clarity, Accuracy & Helpfulness:** Ensure the final response is easy to understand, accurate, directly addresses the original request, and incorporates the most useful insights and examples.
    *   **Structure Logically:** Organize the final response effectively using headings, lists, etc. Use clear Markdown formatting.
    *   **Conciseness:** Combine similar good points effectively; avoid unnecessary repetition while maintaining helpfulness.

Output Format (Strictly follow - Both Sections REQUIRED):

SECTION 1: ATTEMPT ANALYSIS
(A) Key Strengths Identified:
[Example 1: "Attempt [N] had a very clear step-by-step explanation of process X."]
[Example 2: "The analogy used in Attempt [M] for concept Y was particularly insightful."]
...
(B) Key Weaknesses/Areas for Improvement Identified:
[Example 1: "Attempt [X] could benefit from a concrete example for point Z."]
[Example 2: "Attempt [Y]'s structure felt a bit disjointed in the middle section."]
...
(C) Comparative Assessment:
[Brief summary, e.g., "Attempt [M] offered the clearest core explanation, while Attempt [N] had better examples."]

SECTION 2: FINAL SYNTHESIZED RESPONSE
[Provide the new, superior response synthesized according to the instructions above. Integrate strengths, correct weaknesses, ensure clarity, accuracy, good structure, and incorporate key insights and helpful examples.]

Ensure the complete output contains BOTH sections clearly marked.
"""


# --- Model Loading and Generation Function ---
# User provided paths
base_model_name = "Qwen/Qwen2.5-7B-Instruct"
lora_weights_dir = "/content/weights" # Make sure this path is correct

# It's good practice to initialize these globally if they are reused
# or pass them around. For simplicity, global for now.
tokenizer = None
model = None
model_loaded = False

def load_model_and_tokenizer():
    global tokenizer, model, model_loaded
    if model_loaded:
        print("Model already loaded.")
        return

    print(f"Loading tokenizer from {base_model_name}...")
    try:
        tokenizer = AutoTokenizer.from_pretrained(base_model_name)
        print(f"Loading base model from {base_model_name}...")
        base_model_for_peft = AutoModelForCausalLM.from_pretrained(
            base_model_name,
            device_map="auto",
            # offload_folder="/content/offload", # Optional, depends on memory
            torch_dtype=torch.bfloat16 # Recommended for Qwen2.5
        )
        print(f"Loading LoRA weights from {lora_weights_dir}...")
        model = PeftModel.from_pretrained(
            base_model_for_peft,
            lora_weights_dir,
            device_map="auto",
            # offload_folder="/content/offload" # Optional
        )
        model.eval() # Set to evaluation mode
        model_loaded = True
        print("Model and tokenizer loaded successfully.")
    except Exception as e:
        print(f"Error loading model: {e}")
        model_loaded = False

def generate_with_model(prompt_text, temperature, max_new_tokens):
    if not model_loaded:
        print("Model not loaded. Cannot generate.")
        return "(Error: Model not loaded)"
    try:
        inputs = tokenizer(prompt_text, return_tensors="pt", truncation=True, max_length=4096-max_new_tokens).to(model.device) # Max length Qwen2.5 32k, but set lower for safety
        
        # Qwen2.5 instruct models often use a chat template.
        # Let's try to apply a generic one if the tokenizer has it.
        # If your LoRA was trained with a specific chat format, adapt this.
        # For raw prompt injection like in the original JS, this direct input is often fine.
        # However, for Qwen models, using their message format is often better.
        # Let's assume for now the prompts are designed for direct injection.

        generation_kwargs = {
            "input_ids": inputs["input_ids"],
            "attention_mask": inputs["attention_mask"],
            "temperature": temperature,
            "max_new_tokens": max_new_tokens,
            "do_sample": temperature > 0.01, # Only sample if temp is not ~0
            "pad_token_id": tokenizer.eos_token_id # Common practice
        }
        
        print(f"\n--- Generating (temp: {temperature}, max_tokens: {max_new_tokens}) ---")
        # print(f"Input prompt (first 200 chars): {prompt_text[:200]}...")

        with torch.no_grad():
            outputs = model.generate(**generation_kwargs)
        
        # Decode, skipping special tokens and also the input prompt
        response_text = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
        
        # print(f"Raw LLM Output (first 200 chars): {response_text[:200]}...")
        return response_text.strip()
    except Exception as e:
        print(f"Error during generation: {e}")
        return f"(Error: Generation failed - {str(e)})"

# --- Core Logic Functions ---

def get_initial_solution(user_prompt, force_code_math_focus=False):
    print_header("1. Generating Initial Solution")
    if force_code_math_focus:
        prompt_template = INITIAL_GEN_PROMPT_MAXIMIZED
        temp = solverParams["initial_gen_temp_single"] # Can also have different temps
        max_tokens = solverParams["max_initial_tokens"]
        print_subheader("Using MAXIMIZED Code/Math Focus")
    else:
        prompt_template = INITIAL_GEN_PROMPT_MODERATE
        temp = solverParams["initial_gen_temp_single"]
        max_tokens = solverParams["max_initial_tokens"]
        print_subheader("Using MODERATE General Focus")

    formatted_prompt = prompt_template.format(prompt=user_prompt, solverParams=solverParams)
    solution = generate_with_model(formatted_prompt, temp, max_tokens)
    print_output_preview(solution)
    return solution

def get_critique(text_to_analyze, original_user_prompt, force_code_math_focus=False):
    print_header("2. Generating Critique")
    if force_code_math_focus:
        prompt_template = CRITIQUE_PROMPT_MAXIMIZED
        temp = solverParams["verify_temp"]
        max_tokens = solverParams["max_critique_tokens"]
        print_subheader("Using MAXIMIZED Code/Math Focus for Critique")
    else:
        prompt_template = CRITIQUE_PROMPT_MODERATE
        temp = solverParams["verify_temp"]
        max_tokens = solverParams["max_critique_tokens"]
        print_subheader("Using MODERATE General Focus for Critique")

    formatted_prompt = prompt_template.format(
        original_prompt=original_user_prompt,
        text_to_analyze=text_to_analyze,
        solverParams=solverParams
    )
    critique = generate_with_model(formatted_prompt, temp, max_tokens)

    # Parse critique
    none_marker_agent = "REQUIREMENTS FOR IMPROVEMENT (Policy Update Gradient - MAX STRENGTH): None."
    none_marker_generic = "SUGGESTIONS FOR IMPROVEMENT: None."
    requirements_marker_agent = "REQUIREMENTS FOR IMPROVEMENT (Policy Update Gradient - MAX STRENGTH):"
    suggestions_marker_generic = "SUGGESTIONS FOR IMPROVEMENT:"

    if none_marker_agent in critique or none_marker_generic in critique:
        print_subheader("Critique: None (Solution deemed excellent by AI)")
        return None
    else:
        parsed_critique = critique # Default to full critique
        if force_code_math_focus and requirements_marker_agent in critique:
            parsed_critique = critique.split(requirements_marker_agent, 1)[-1].strip()
        elif not force_code_math_focus and suggestions_marker_generic in critique:
            parsed_critique = critique.split(suggestions_marker_generic, 1)[-1].strip()
        
        if not parsed_critique: # If split resulted in empty, use original
             parsed_critique = critique

        print_output_preview(parsed_critique, "Critique Content")
        return parsed_critique


def visualize_critique_metrics(critique_text, original_solution_text):
    print_header("3. Visualizing Critique Metrics")
    if critique_text is None:
        print_subheader("No critique points to visualize (solution deemed excellent).")
        # Plot a "0 issues" graph
        labels = ['Identified Issues']
        values = [0]
        title = 'Critique Assessment: Perfect Solution'
    else:
        # Simple parsing: count bullet points or numbered list items as "issues"
        # This is a heuristic. More advanced parsing could categorize issues.
        bullet_points = len(re.findall(r"^\s*[\*\-]\s+", critique_text, re.MULTILINE))
        numbered_points = len(re.findall(r"^\s*\d+\.\s+", critique_text, re.MULTILINE))
        
        # Specific parsing for MAXIMIZED prompt's categories
        correctness_issues = 0
        exploration_issues = 0
        
        in_correctness_section = False
        in_exploration_section = False

        lines = critique_text.splitlines()
        for line in lines:
            if "Correctness/Rigor Issues" in line:
                in_correctness_section = True
                in_exploration_section = False
                continue
            if "Exploration/Insight/Alternative/Creativity/Efficiency Gaps" in line:
                in_correctness_section = False
                in_exploration_section = True
                continue
            
            is_item = re.match(r"^\s*[\*\-]\s+|^\s*\[Requirement \w+:", line) # Match bullet or [Requirement X:
            if is_item:
                if in_correctness_section:
                    correctness_issues += 1
                elif in_exploration_section:
                    exploration_issues += 1
        
        if correctness_issues > 0 or exploration_issues > 0: # Use categorized counts
            labels = ['Correctness/Rigor', 'Exploration/Insight']
            values = [correctness_issues, exploration_issues]
            title = 'Critique Assessment: Categorized Issues'
            print_subheader(f"Found {correctness_issues} Correctness/Rigor issues, {exploration_issues} Exploration/Insight issues.")
        else: # Fallback to general count
            total_points = bullet_points + numbered_points
            if total_points == 0 and critique_text.strip(): # If no bullets but text exists, count lines as rough measure
                total_points = len([line for line in critique_text.splitlines() if line.strip()])
            
            labels = ['Identified Issues']
            values = [max(1, total_points) if critique_text.strip() else 0] # Show at least 1 if critique exists
            title = 'Critique Assessment: Total Identified Issues'
            print_subheader(f"Found {values[0]} general critique points.")

    plt.figure(figsize=(8, 6))
    bars = plt.bar(labels, values, color=['#FF6347', '#4682B4'][:len(labels)]) # Tomato, SteelBlue

    # Add text labels on bars
    for bar in bars:
        yval = bar.get_height()
        plt.text(bar.get_x() + bar.get_width()/2.0, yval + 0.05 * max(values) if max(values) > 0 else 0.05, 
                 int(yval), ha='center', va='bottom')

    plt.ylabel('Number of Points')
    plt.title(title)
    
    # Wrap long x-axis labels
    ax = plt.gca()
    ax.set_xticklabels([textwrap.fill(label, 15) for label in labels])

    plt.tight_layout()
    plt.show()
    print_subheader("Critique visualization displayed.")


def refine_solution(original_solution, correction_requests, original_user_prompt, force_code_math_focus=False):
    print_header("4. Refining Solution")
    if correction_requests is None:
        print_subheader("No corrections requested, solution is considered final from previous stage.")
        return original_solution

    if force_code_math_focus:
        prompt_template = REFINE_PROMPT_MAXIMIZED
        temp = solverParams["refine_temp"]
        max_tokens = solverParams["max_refine_tokens"]
        print_subheader("Using MAXIMIZED Code/Math Focus for Refinement")
    else:
        prompt_template = REFINE_PROMPT_MODERATE
        temp = solverParams["refine_temp"]
        max_tokens = solverParams["max_refine_tokens"]
        print_subheader("Using MODERATE General Focus for Refinement")

    formatted_prompt = prompt_template.format(
        original_prompt=original_user_prompt,
        original_solution=original_solution,
        correction_requests=correction_requests,
        solverParams=solverParams
    )
    refined_solution = generate_with_model(formatted_prompt, temp, max_tokens)
    print_output_preview(refined_solution)
    return refined_solution


def synthesize_from_runs(original_user_prompt, run_results, force_code_math_focus=False):
    print_header("5. Synthesizing Final Answer from Runs")
    if not run_results:
        print_subheader("No run results to synthesize.")
        return "(Error: No results to synthesize)"

    results_summary = ""
    for i, result in enumerate(run_results):
        # Truncate individual results if too long for the summary
        max_len_per_result = solverParams["max_synthesis_tokens"] * 0.7 / len(run_results) # Distribute context
        truncated_result = result
        if len(result) > max_len_per_result:
            truncated_result = result[:int(max_len_per_result)] + "\n... [RESULT TRUNCATED IN SUMMARY]"
        results_summary += f"--- ATTEMPT {i+1} ---\n{truncated_result}\n--- END ATTEMPT {i+1} ---\n\n"
    
    results_summary = results_summary.strip()
    
    if force_code_math_focus:
        prompt_template = SYNTHESIS_PROMPT_MAXIMIZED
        temp = solverParams["synthesis_temp"]
        max_tokens = solverParams["max_synthesis_tokens"]
        print_subheader("Using MAXIMIZED Code/Math Focus for Synthesis")
    else:
        prompt_template = SYNTHESIS_PROMPT_MODERATE
        temp = solverParams["synthesis_temp"]
        max_tokens = solverParams["max_synthesis_tokens"]
        print_subheader("Using MODERATE General Focus for Synthesis")
    
    formatted_prompt = prompt_template.format(
        original_prompt=original_user_prompt,
        results_summary=results_summary,
        solverParams=solverParams
    )
    
    synthesis_output = generate_with_model(formatted_prompt, temp, max_tokens)
    
    # Parse synthesis output
    meta_analysis_section = "SECTION 1: DEEP EXPLORATION PATH META-ANALYSIS" # MAXIMIZED
    if not force_code_math_focus:
        meta_analysis_section = "SECTION 1: ATTEMPT ANALYSIS" # MODERATE
    
    final_response_section = "SECTION 2: ULTIMATE SYNTHESIZED RESPONSE" # MAXIMIZED
    if not force_code_math_focus:
        final_response_section = "SECTION 2: FINAL SYNTHESIZED RESPONSE" # MODERATE

    meta_analysis = "(Meta-analysis not found or parsing failed)"
    final_synthesized_answer = synthesis_output # Default to full output

    if meta_analysis_section in synthesis_output and final_response_section in synthesis_output:
        parts = synthesis_output.split(final_response_section, 1)
        meta_analysis = parts[0].replace(meta_analysis_section, "").strip()
        final_synthesized_answer = parts[1].strip()
    elif final_response_section in synthesis_output: # Only final response found
        final_synthesized_answer = synthesis_output.split(final_response_section, 1)[-1].strip()


    print_subheader("Meta-Analysis:")
    print_output_preview(meta_analysis)
    print_subheader("Final Synthesized Response:")
    print_output_preview(final_synthesized_answer)
    
    return meta_analysis, final_synthesized_answer

# --- Helper Print Functions ---
def print_header(text):
    print(f"\n{'='*10} {text.upper()} {'='*10}")

def print_subheader(text):
    print(f"\n--- {text} ---")

def print_output_preview(text, title="LLM Output Preview", max_chars=500):
    if not text:
        print(f"{title}: (Empty Response)")
        return
    preview = text[:max_chars]
    if len(text) > max_chars:
        preview += "..."
    print(f"{title}:\n{preview}\n{'-'*20}")


# --- Main Execution ---
if __name__ == "__main__":
    load_model_and_tokenizer()

    if not model_loaded:
        print("Exiting due to model loading failure.")
        exit()

    # Example usage:
    # user_task_prompt = "Explain the concept of gravitational lensing in astrophysics. Provide a simple analogy and discuss one key observational evidence."
    # focus_on_code_math = False # For this general science question

    user_task_prompt = "Generate Python code to efficiently find the k-th smallest element in an unsorted list. Provide at least two distinct algorithms, analyze their time and space complexity, and discuss their trade-offs. Include example usage."
    focus_on_code_math = True # This is a code/math heavy task

    # Single run through the refine loop
    print_header(f"STARTING PROCESS FOR: {user_task_prompt[:50]}...")
    initial_sol = get_initial_solution(user_task_prompt, force_code_math_focus=focus_on_code_math)

    if not initial_sol or initial_sol.startswith("(Error:"):
        print("Failed to generate initial solution. Exiting.")
        exit()
        
    critique = get_critique(initial_sol, user_task_prompt, force_code_math_focus=focus_on_code_math)

    # Visualize critique even if it's "None" (will show 0 issues)
    visualize_critique_metrics(critique, initial_sol)
    
    refined_sol = refine_solution(initial_sol, critique, user_task_prompt, force_code_math_focus=focus_on_code_math)

    if not refined_sol or refined_sol.startswith("(Error:"):
        print("Failed to refine solution. Using initial solution for synthesis (if applicable).")
        refined_sol = initial_sol # Fallback

    # --- Synthesis Example ---
    # For a proper synthesis, you'd typically have multiple 'refined_sol' from different runs or strategies.
    # Here, we'll synthesize from the initial and the (once) refined solution to demonstrate.
    print_header("SYNTHESIS STAGE (DEMO)")
    # In a real scenario, you might run the initial->critique->refine loop multiple times
    # with different settings (e.g., temperature) or even slightly varied prompts
    # to get diverse `run_results`.
    # For this demo, we'll use the `initial_sol` and `refined_sol` as two "attempts".
    
    # Let's simulate a second "slightly different" refined solution for better synthesis demo
    # This is artificial for the demo. In reality, it would be another full generation.
    print_subheader("Generating a (simulated) second attempt for synthesis demo...")
    simulated_second_critique = "Minor point: Could add one more edge case example for clarity on empty lists."
    if critique and "None" not in critique: # Add to existing critique if any
        simulated_second_critique = critique + "\n* " + simulated_second_critique
    
    simulated_second_refined_sol = refine_solution(
        initial_sol, # Refine from initial again, with slightly different critique
        simulated_second_critique,
        user_task_prompt,
        force_code_math_focus=focus_on_code_math
    )
    if not simulated_second_refined_sol or simulated_second_refined_sol.startswith("(Error:"):
        simulated_second_refined_sol = initial_sol # Fallback

    run_attempts_for_synthesis = [initial_sol, refined_sol, simulated_second_refined_sol]
    # Filter out potential error strings from attempts
    run_attempts_for_synthesis = [s for s in run_attempts_for_synthesis if s and not s.startswith("(Error:")]

    if len(run_attempts_for_synthesis) < 1:
         print("Not enough valid attempts for synthesis. Skipping synthesis.")
    else:
        meta_analysis_result, final_answer = synthesize_from_runs(
            user_task_prompt,
            run_attempts_for_synthesis,
            force_code_math_focus=focus_on_code_math
        )

        print_header("FINAL SYNTHESIZED ANSWER")
        print(final_answer)

    print_header("PROCESS COMPLETE")