upload

.gitattributes

@@ -33,4 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/ filter=lfs diff=lfs merge=lfs -text
 data/** filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,25 @@
+FROM ubuntu:24.04
+
+WORKDIR /app
+
+COPY . /app
+
+RUN pip install --no-cache-dir --upgrade -r /app/requirements.txt
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+
+# Switch to the "user" user
+USER user
+
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+
+# Copy the current directory contents into the container at $HOME/app setting the owner to the user
+COPY --chown=user . $HOME/app
+
+CMD ["streamlit", "run", "app.py", "--server.port", "8200"]

core/agent/base_agent.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class BaseAgent(ABC):
+
+    def __init__(self, llm):
+        self.llm = llm

core/agent/coordinator.py

@@ -0,0 +1,74 @@
+from collections import defaultdict, deque
+from prompt.template import TASK_DEPENDENCY_ANALYSIS_WITH_CODE_PROMPT, TASK_DEPENDENCY_ANALYSIS_PROMPT, DAG_CONSTRUCTION_PROMPT, CODE_STRUCTURE_PROMPT
+import json
+import os
+import sys
+
+class Coordinator:
+    def __init__(self, llm):
+        self.llm = llm
+        self.memory = {}
+        self.code_memory = {}
+
+    def compute_dag_order(self, graph):
+        """
+        计算DAG的拓扑排序（计算顺序）。
+        :param graph: 以邻接表形式表示的DAG，格式为 {节点: [该节点依赖的其他节点]}。
+        :return: 一个表示计算顺序的列表。
+        """
+        # 计算入度
+        in_degree = {node: 0 for node in graph}
+        for node in graph:
+            in_degree[node] += len(graph[node])
+
+        # 找到所有入度为0的节点（可以作为计算的起点）
+        queue = deque([node for node in in_degree if in_degree[node] == 0])
+        order = []
+
+        while queue:
+            node = queue.popleft()
+            order.append(node)
+
+            # 遍历所有节点，找到依赖当前节点的节点，减少其入度
+            for neighbor in graph:
+                if node in graph[neighbor]:
+                    in_degree[neighbor] -= 1
+                    if in_degree[neighbor] == 0:
+                        queue.append(neighbor)
+
+        # 检查是否存在环（如果排序的节点数小于总节点数，则说明存在环）
+        if len(order) != len(graph):
+            raise ValueError("Graph contains a cycle!")
+
+        return order
+    
+    def analyze(self, tasknum: int, modeling_problem: str, problem_analysis: str, modeling_solution: str, task_descriptions: str, with_code: bool):
+        if with_code:
+            prompt = TASK_DEPENDENCY_ANALYSIS_WITH_CODE_PROMPT.format(tasknum=tasknum, modeling_problem=modeling_problem, problem_analysis=problem_analysis, modeling_solution=modeling_solution, task_descriptions=task_descriptions).strip()
+        else:
+            prompt = TASK_DEPENDENCY_ANALYSIS_PROMPT.format(tasknum=tasknum, modeling_problem=modeling_problem, problem_analysis=problem_analysis, modeling_solution=modeling_solution, task_descriptions=task_descriptions).strip()
+        return self.llm.generate(prompt)
+
+    def dag_construction(self, tasknum: int, modeling_problem: str, problem_analysis: str, modeling_solution: str, task_descriptions: str, task_dependency_analysis: str):
+        prompt = DAG_CONSTRUCTION_PROMPT.format(tasknum=tasknum, modeling_problem=modeling_problem, problem_analysis=problem_analysis, modeling_solution=modeling_solution, task_descriptions=task_descriptions, task_dependency_analysis=task_dependency_analysis).strip()
+        return self.llm.generate(prompt)
+
+    def analyze_dependencies(self, modeling_problem: str, problem_analysis: str, modeling_solution: str, task_descriptions: str, with_code: bool):
+        task_dependency_analysis = self.analyze(len(task_descriptions), modeling_problem, problem_analysis, modeling_solution, task_descriptions, with_code)
+        self.task_dependency_analysis = task_dependency_analysis.split('\n\n')
+        count = 0
+        for i in range(5):
+            try:
+                dependency_DAG = self.dag_construction(len(task_descriptions), modeling_problem, problem_analysis, modeling_solution, task_descriptions, task_dependency_analysis)
+                dependency_DAG_string = dependency_DAG.strip('```json\n').strip('```')
+                self.DAG = json.loads(dependency_DAG_string)
+                break
+            except:
+                continue
+        if count == 5:
+            sys.exit("Fail at analyze_dependencies")
+        order = self.compute_dag_order(self.DAG)
+
+        return order
+    
+    

core/agent/create_charts.py

@@ -0,0 +1,19 @@
+from .base_agent import BaseAgent
+from prompt.template import CREATE_CHART_PROMPT
+
+class Chart(BaseAgent):
+    def __init__(self, llm):
+        super().__init__(llm)
+    
+    def create_single_chart(self, paper_content: str, existing_charts: str, user_prompt: str=''):
+        prompt = CREATE_CHART_PROMPT.format(paper_content=paper_content, existing_charts=existing_charts, user_prompt=user_prompt)
+        return self.llm.generate(prompt)
+
+    def create_charts(self, paper_content: str, chart_num: int, user_prompt: str=''):
+        existing_charts = ''
+        charts = []
+        for i in range(chart_num):
+            chart = self.create_single_chart(paper_content, existing_charts, user_prompt)
+            charts.append(chart)
+            existing_charts = '\n---\n'.join(charts)
+        return charts

core/agent/data_description.py

@@ -0,0 +1,11 @@
+from .base_agent import BaseAgent
+from prompt.template import DATA_DESCRIPTION_PROMPT
+
+class DataDescription(BaseAgent):
+    def __init__(self, llm):
+        super().__init__(llm)
+    
+    def summary(self, data_description: str):
+        prompt = DATA_DESCRIPTION_PROMPT.format(data_description=data_description)
+        return self.llm.generate(prompt)
+

core/agent/method_ranking.py

@@ -0,0 +1,125 @@
+import json
+from pathlib import Path
+from typing import List
+from functools import partial
+from .base_agent import BaseAgent
+from prompt.template import METHOD_CRITIQUE_PROMPT
+from utils.convert_format import markdown_to_json_method
+from utils.utils import parse_llm_output_to_json
+from utils.embedding import EmbeddingScorer
+
+import json
+
+
+
+class MethodScorer:
+
+    def __init__(self, score_func, parent_weight=0.5, child_weight=0.5):
+        self.parent_weight = parent_weight
+        self.child_weight = child_weight
+        self.score_func = score_func
+        self.leaves = []
+
+    def process(self, data):
+        self.leaves = []
+        for root_node in data:
+            self._process_node(root_node, parent_scores=[])
+        for root_node in data:
+            self._collect_leaves(root_node)
+        return self.leaves
+
+    def _process_node(self, node, parent_scores):
+        if 'children' in node:
+            children = node.get('children', [])
+            if children:
+                first_child = children[0]
+                if 'method_class' in first_child:
+                    input_for_llm = [{"method": child["method_class"], "description": child.get("description", "")} for child in children]
+                    llm_result = self.score_func(input_for_llm)
+                    for idx, child in enumerate(children):
+                        if idx < len(llm_result):
+                            child['score'] = llm_result[idx]['score']
+                        else:
+                            child['score'] = 0
+                    current_score = node.get('score')
+                    new_parent = parent_scores.copy()
+                    if current_score is not None:
+                        new_parent.append(current_score)
+                    for child in children:
+                        self._process_node(child, new_parent)
+                else:
+                    input_for_llm = [{"method": child["method"], "description": child.get("description", "")} for child in children]
+                    llm_result = self.score_func(input_for_llm)
+                    for idx, child in enumerate(children):
+                        if idx < len(llm_result):
+                            child_score = llm_result[idx]['score']
+                        else:
+                            child_score = 0
+                        child['score'] = child_score
+                        parent_avg = sum(parent_scores) / len(parent_scores) if parent_scores else 0
+                        final_score = parent_avg * self.parent_weight + child_score * self.child_weight
+                        child['final_score'] = final_score
+
+    def _collect_leaves(self, node):
+        if 'children' in node:
+            for child in node['children']:
+                self._collect_leaves(child)
+        else:
+            if 'final_score' in node:
+                self.leaves.append({
+                    "method": node["method"],
+                    "description": node.get("description", ""),
+                    "score": node['final_score']
+                })
+
+
+
+class MethodRanking(BaseAgent):
+    def __init__(self, llm, rag=True):
+        super().__init__(llm)
+        self.rag = rag
+        self.embedding_scorer = EmbeddingScorer()
+        current_file = Path(__file__).resolve()
+        json_path = current_file.parent.parent.parent / 'data/actor_data/docs/method_en_v1.json'
+        md_path = current_file.parent.parent.parent / 'data/actor_data/docs/method_en_v1.md'
+
+        with open(str(md_path), "r", encoding="utf-8") as f:
+            self.markdown_text = f.read()
+        self.method_tree = markdown_to_json_method(self.markdown_text)
+        with open(json_path, "w+", encoding="utf-8") as f:
+            json.dump(self.method_tree, f, ensure_ascii=False, indent=4)
+        
+    def llm_score_method(self, problem_description: str, methods: List[dict]):
+        methods_str = '\n'.join([f"{i+1}. {method['method']} {method.get('description', '')}" for i, method in enumerate(methods)])
+        prompt = METHOD_CRITIQUE_PROMPT.format(problem_description=problem_description, methods=methods_str)
+        answer = self.llm.generate(prompt)
+        method_scores = parse_llm_output_to_json(answer).get('methods', [])
+        method_scores = sorted(method_scores, key=lambda x: x['method_index'])
+        for method in method_scores:
+            method['score'] = sum(method['scores'].values()) / len(method['scores'])
+        # print(method_scores)
+        return method_scores
+
+    def format_methods(self, methods: List[str]):
+        return '\n'.join([f"**{method['method']}:** {method['description']}" for method in methods])
+
+    def top_methods(self, problem_description: str, top_k: int=6, method: str='embedding'):
+        if self.rag:
+            if method == 'embedding':
+                score_func = partial(self.embedding_scorer.score_method, problem_description)
+            else:
+                score_func = partial(self.llm_score_method, problem_description)
+            method_scores = MethodScorer(score_func).process(self.method_tree)
+            method_scores.sort(key=lambda x: x['score'], reverse=True)
+            return self.format_methods(method_scores[:top_k])
+        else:
+            return self.markdown_text
+        
+
+if __name__ == "__main__":
+    from input.test_middle_result import problem_str
+    from llm.llm import LLM
+    llm = LLM('deepseek-chat')
+    # print(llm.generate('Hello, how are you?'))
+    mr = MethodRanking(llm)
+    # print(mr.top_methods(problem_str, top_k=6))

core/agent/model_selection.py

@@ -0,0 +1,16 @@
+from .base_agent import BaseAgent
+from prompt.template import MODEL_SELECTION_PROMPT
+from prompt.constants import modeling_methods
+
+
+class ModelSelection(BaseAgent):
+    def __init__(self, llm):
+        super().__init__(llm)
+    
+    def select_models(self, modeling_problem: str):
+        prompt = MODEL_SELECTION_PROMPT.format(modeling_methods=modeling_methods, modeling_problem=modeling_problem)
+        answer = self.llm.generate(prompt)
+        selected_models = answer.split('Conclusion:')[-1]
+        return selected_models
+
+

core/agent/problem_analysis.py

@@ -0,0 +1,28 @@
+from .base_agent import BaseAgent
+from prompt.template import PROBLEM_ANALYSIS_PROMPT, PROBLEM_ANALYSIS_CRITIQUE_PROMPT, PROBLEM_ANALYSIS_IMPROVEMENT_PROMPT
+
+
+class ProblemAnalysis(BaseAgent):
+    def __init__(self, llm):
+        super().__init__(llm)
+    
+    def analysis_actor(self, modeling_problem: str, user_prompt: str=''):
+        prompt = PROBLEM_ANALYSIS_PROMPT.format(modeling_problem=modeling_problem, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    def analysis_critic(self, modeling_problem: str, problem_analysis: str):
+        prompt = PROBLEM_ANALYSIS_CRITIQUE_PROMPT.format(modeling_problem=modeling_problem, problem_analysis=problem_analysis).strip()
+        return self.llm.generate(prompt)
+
+    def analysis_improvement(self, modeling_problem: str, problem_analysis: str, problem_analysis_critique: str, user_prompt: str=''):
+        prompt = PROBLEM_ANALYSIS_IMPROVEMENT_PROMPT.format(modeling_problem=modeling_problem, problem_analysis=problem_analysis, problem_analysis_critique=problem_analysis_critique, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    def analysis(self, modeling_problem: str, round: int = 3, user_prompt: str = ''):
+        problem_analysis = self.analysis_actor(modeling_problem, user_prompt)
+        for i in range(round):
+            print(f'Problem Analysis Round {i+1}')
+            problem_analysis_critique = self.analysis_critic(modeling_problem, problem_analysis)
+            problem_analysis_improvement = self.analysis_improvement(modeling_problem, problem_analysis, problem_analysis_critique, user_prompt)
+            problem_analysis = problem_analysis_improvement
+        return problem_analysis

core/agent/problem_modeling.py

@@ -0,0 +1,29 @@
+from .base_agent import BaseAgent
+from prompt.template import PROBLEM_MODELING_PROMPT, PROBLEM_MODELING_CRITIQUE_PROMPT, PROBLEM_MODELING_IMPROVEMENT_PROMPT
+# from prompt.constants import modeling_methods
+
+
+class ProblemModeling(BaseAgent):
+    def __init__(self, llm):
+        super().__init__(llm)
+    
+    def modeling_actor(self, modeling_problem: str, problem_analysis: str, modeling_methods: str, user_prompt: str=''):
+        prompt = PROBLEM_MODELING_PROMPT.format(modeling_methods=modeling_methods, modeling_problem=modeling_problem, problem_analysis=problem_analysis, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    def modeling_critic(self, modeling_problem: str, problem_analysis: str, modeling_solution: str):
+        prompt = PROBLEM_MODELING_CRITIQUE_PROMPT.format(modeling_problem=modeling_problem, problem_analysis=problem_analysis, modeling_solution=modeling_solution).strip()
+        return self.llm.generate(prompt)
+
+    def modeling_improvement(self, modeling_problem: str, problem_analysis: str, modeling_solution: str, modeling_solution_critique: str, user_prompt: str=''):
+        prompt = PROBLEM_MODELING_IMPROVEMENT_PROMPT.format(modeling_problem=modeling_problem, problem_analysis=problem_analysis, modeling_solution=modeling_solution, modeling_solution_critique=modeling_solution_critique, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    def modeling(self, modeling_problem: str, problem_analysis: str, modeling_methods: str, round: int = 3, user_prompt: str = ''):
+        modeling_solution = self.modeling_actor(modeling_problem, problem_analysis, modeling_methods, user_prompt)
+        for i in range(round):
+            print(f'Problem Modeling Round {i+1}')
+            modeling_solution_critique = self.modeling_critic(modeling_problem, problem_analysis, modeling_solution)
+            modeling_solution_improvement = self.modeling_improvement(modeling_problem, problem_analysis, modeling_solution, modeling_solution_critique, user_prompt)
+            modeling_solution = modeling_solution_improvement
+        return modeling_solution

core/agent/task copy.py

@@ -0,0 +1,64 @@
+from .base_agent import BaseAgent
+from prompt.constants import modeling_methods
+from prompt.template import (TASK_ANALYSIS_PROMPT, TASK_RESULT_PROMPT, TASK_ANSWER_PROMPT, 
+                             TASK_FORMULAS_PROMPT, TASK_FORMULAS_CRITIQUE_PROMPT, TASK_FORMULAS_IMPROVEMENT_PROMPT, 
+                             TASK_MODELING_PROMPT, TASK_MODELING_CRITIQUE_PROMPT, TASK_MODELING_IMPROVEMENT_PROMPT)
+
+class Task(BaseAgent):
+    def __init__(self, llm):
+        super().__init__(llm)
+    
+    def analysis(self, task_description: str, user_prompt: str = ''):
+        prompt = TASK_ANALYSIS_PROMPT.format(task_description=task_description, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+    
+    def formulas_actor(self, data_summary: str, task_description: str, task_analysis: str, user_prompt: str = ''):
+        prompt = TASK_FORMULAS_PROMPT.format(data_summary=data_summary, task_description=task_description, task_analysis=task_analysis, modeling_methods=modeling_methods, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    def formulas_critic(self, data_summary: str, task_description: str, task_analysis: str, modeling_formulas: str):
+        prompt = TASK_FORMULAS_CRITIQUE_PROMPT.format(data_summary=data_summary, task_description=task_description, task_analysis=task_analysis, modeling_formulas=modeling_formulas).strip()
+        return self.llm.generate(prompt)
+    
+    def formulas_improvement(self, data_summary: str, task_description: str, task_analysis: str, modeling_formulas: str, modeling_formulas_critique: str, user_prompt: str = ''):
+        prompt = TASK_FORMULAS_IMPROVEMENT_PROMPT.format(data_summary=data_summary, task_description=task_description, task_analysis=task_analysis, modeling_formulas=modeling_formulas, modeling_formulas_critique=modeling_formulas_critique, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    def formulas(self, data_summary: str, task_description: str, task_analysis: str, round: int = 1, user_prompt: str = ''):
+        formulas = self.formulas_actor(data_summary, task_description, task_analysis, user_prompt)
+        for i in range(round):
+            print(f'FORMULAS Round {i+1}')
+            formulas_critique = self.formulas_critic(data_summary, task_description, task_analysis, formulas)
+            formulas = self.formulas_improvement(data_summary, task_description, task_analysis, formulas, formulas_critique, user_prompt)
+        return formulas
+
+    def modeling_actor(self, data_summary: str, task_description: str, task_analysis: str, formulas: str, user_prompt: str = ''):
+        prompt = TASK_MODELING_PROMPT.format(data_summary=data_summary, task_description=task_description, task_analysis=task_analysis, modeling_formulas=formulas, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    # def modeling_critic(self, task_description: str, task_analysis: str, data_summary: str, formulas: str, modeling_process: str):
+    #     prompt = TASK_MODELING_CRITIQUE_PROMPT.format(task_description=task_description, task_analysis=task_analysis, data_summary=data_summary, modeling_formulas=formulas, modeling_process=modeling_process).strip()
+    #     return self.llm.generate(prompt)
+    
+    # def modeling_improvement(self, task_description: str, task_analysis: str, data_summary: str, formulas: str, modeling_process: str, modeling_process_critique: str):
+    #     prompt = TASK_MODELING_IMPROVEMENT_PROMPT.format(task_description=task_description, task_analysis=task_analysis, data_summary=data_summary, modeling_formulas=formulas, modeling_process=modeling_process, modeling_process_critique=modeling_process_critique).strip()
+    #     return self.llm.generate(prompt)
+
+    # def modeling(self, task_description: str, task_analysis: str, data_summary: str, formulas: str, round: int = 1):
+    #     process = self.modeling_actor(task_description, task_analysis, data_summary, formulas)
+    #     for i in range(round):
+    #         print(f'MODELING Round {i+1}')
+    #         process_critique = self.modeling_critic(task_description, task_analysis, data_summary, formulas, process)
+    #         process = self.modeling_improvement(task_description, task_analysis, data_summary, formulas, process, process_critique)
+    #     return process
+
+    def modeling(self, data_summary: str, task_description: str, task_analysis: str, formulas: str, round: int = 1, user_prompt: str = ''):
+        return self.modeling_actor(data_summary, task_description, task_analysis, formulas, user_prompt)
+
+    def result(self, task_description: str, task_analysis: str, task_formulas: str, task_modeling: str, user_prompt: str = ''):
+        prompt = TASK_RESULT_PROMPT.format(task_description=task_description, task_analysis=task_analysis, task_formulas=task_formulas, task_modeling=task_modeling, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    def answer(self, task_description: str, task_analysis: str, task_formulas: str, task_modeling: str, task_result: str, user_prompt: str = ''):
+        prompt = TASK_ANSWER_PROMPT.format(task_description=task_description, task_analysis=task_analysis, task_formulas=task_formulas, task_modeling=task_modeling, task_result=task_result, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)

core/agent/task.py

@@ -0,0 +1,251 @@
+from .base_agent import BaseAgent
+from prompt.constants import modeling_methods
+from prompt.template import (TASK_ANALYSIS_PROMPT, TASK_RESULT_PROMPT, TASK_ANSWER_PROMPT, 
+                             TASK_FORMULAS_PROMPT, TASK_FORMULAS_CRITIQUE_PROMPT, TASK_FORMULAS_IMPROVEMENT_PROMPT, 
+                             TASK_MODELING_PROMPT, TASK_MODELING_CRITIQUE_PROMPT, TASK_MODELING_IMPROVEMENT_PROMPT,
+                             TASK_CODING_PROMPT, TASK_CODING_DEBUG_PROMPT, CODE_STRUCTURE_PROMPT, 
+                             TASK_RESULT_WITH_CODE_PROMPT, COO_PROMPT, TASK_CODING_WO_COO_PROMPT)
+import sys
+import os
+import subprocess
+import selectors
+import tiktoken
+import json
+
+
+class EnvException(Exception):
+    def __init__(self, message):
+        self.message = message 
+    def __str__(self):
+        return self.message
+    
+
+def execute_script(script_path, work_dir):
+    try:
+        device = 0
+        python = "python"
+        cmd = f"CUDA_VISIBLE_DEVICES={device} {python} -u {script_path}"
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True, cwd=work_dir)
+
+        stdout_lines = []
+        stderr_lines = []
+
+        selector = selectors.DefaultSelector()
+        selector.register(process.stdout, selectors.EVENT_READ)
+        selector.register(process.stderr, selectors.EVENT_READ)
+
+        while process.poll() is None and selector.get_map():
+            events = selector.select(timeout=1)
+
+            for key, _ in events:
+                line = key.fileobj.readline()
+                if key.fileobj == process.stdout:
+                    print("STDOUT:", line, end =" ")
+                    stdout_lines.append(line)
+                else:
+                    print("STDERR:", line, end =" ")
+                    stderr_lines.append(line)
+
+        for line in process.stdout:
+            line = line
+            print("STDOUT:", line, end =" ")
+            stdout_lines.append(line)
+        for line in process.stderr:
+            line = line
+            print("STDERR:", line, end =" ")
+            stderr_lines.append(line)
+
+        return_code = process.returncode
+
+        if return_code != 0:
+            observation = "".join(stderr_lines)
+        else:
+            observation = "".join(stdout_lines)
+        if observation == "" and return_code == 0:
+            # printed to stderr only
+            observation = "".join(stderr_lines)
+        return "The script has been executed. Here is the output:\n" + observation
+    except Exception as e:
+        print("++++", "Wrong!")
+        raise EnvException(f"Something went wrong in executing {script_path}: {e}. Please check if it is ready to be executed.")
+
+
+class Task(BaseAgent):
+    def __init__(self, llm, coo=True, rag=True):
+        super().__init__(llm)
+        self.coo = coo
+        self.rag = rag
+        if coo:
+            self.coo_prompt = COO_PROMPT
+        else:
+            self.coo_prompt = ""
+
+    def analysis(self, prompt: str, task_description: str, user_prompt: str = ''):
+        prompt = TASK_ANALYSIS_PROMPT.format(prompt=prompt, coo_prompt=self.coo_prompt, task_description=task_description, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+    
+    def formulas_actor(self, prompt: str, data_summary: str, task_description: str, task_analysis: str, modeling_methods: str, user_prompt: str = ''):
+        prompt = TASK_FORMULAS_PROMPT.format(prompt=prompt, coo_prompt=self.coo_prompt, data_summary=data_summary, task_description=task_description, task_analysis=task_analysis, modeling_methods=modeling_methods, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    def formulas_critic(self, data_summary: str, task_description: str, task_analysis: str, modeling_formulas: str):
+        prompt = TASK_FORMULAS_CRITIQUE_PROMPT.format(data_summary=data_summary, task_description=task_description, task_analysis=task_analysis, modeling_formulas=modeling_formulas).strip()
+        return self.llm.generate(prompt)
+    
+    def formulas_improvement(self, data_summary: str, task_description: str, task_analysis: str, modeling_formulas: str, modeling_formulas_critique: str, user_prompt: str = ''):
+        prompt = TASK_FORMULAS_IMPROVEMENT_PROMPT.format(data_summary=data_summary, task_description=task_description, task_analysis=task_analysis, modeling_formulas=modeling_formulas, modeling_formulas_critique=modeling_formulas_critique, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    def formulas(self, prompt: str, data_summary: str, task_description: str, task_analysis: str, modeling_methods: str, round: int = 1, user_prompt: str = ''):
+        formulas = self.formulas_actor(prompt, data_summary, task_description, task_analysis, modeling_methods, user_prompt)
+        if self.rag:
+            for i in range(round):
+                print(f'FORMULAS Round {i+1}')
+                formulas_critique = self.formulas_critic(data_summary, task_description, task_analysis, formulas)
+                formulas = self.formulas_improvement(data_summary, task_description, task_analysis, formulas, formulas_critique, user_prompt)
+        
+        return formulas
+
+    def modeling_actor(self, prompt: str, data_summary: str, task_description: str, task_analysis: str, formulas: str, user_prompt: str = ''):
+        prompt = TASK_MODELING_PROMPT.format(prompt=prompt, coo_prompt=self.coo_prompt, data_summary=data_summary, task_description=task_description, task_analysis=task_analysis, modeling_formulas=formulas, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    # def modeling_critic(self, task_description: str, task_analysis: str, data_summary: str, formulas: str, modeling_process: str):
+    #     prompt = TASK_MODELING_CRITIQUE_PROMPT.format(task_description=task_description, task_analysis=task_analysis, data_summary=data_summary, modeling_formulas=formulas, modeling_process=modeling_process).strip()
+    #     return self.llm.generate(prompt)
+    
+    # def modeling_improvement(self, task_description: str, task_analysis: str, data_summary: str, formulas: str, modeling_process: str, modeling_process_critique: str):
+    #     prompt = TASK_MODELING_IMPROVEMENT_PROMPT.format(task_description=task_description, task_analysis=task_analysis, data_summary=data_summary, modeling_formulas=formulas, modeling_process=modeling_process, modeling_process_critique=modeling_process_critique).strip()
+    #     return self.llm.generate(prompt)
+
+    # def modeling(self, task_description: str, task_analysis: str, data_summary: str, formulas: str, round: int = 1):
+    #     process = self.modeling_actor(task_description, task_analysis, data_summary, formulas)
+    #     for i in range(round):
+    #         print(f'MODELING Round {i+1}')
+    #         process_critique = self.modeling_critic(task_description, task_analysis, data_summary, formulas, process)
+    #         process = self.modeling_improvement(task_description, task_analysis, data_summary, formulas, process, process_critique)
+    #     return process
+
+    def modeling(self, prompt: str, data_summary: str, task_description: str, task_analysis: str, formulas: str, round: int = 1, user_prompt: str = ''):
+        return self.modeling_actor(prompt, data_summary, task_description, task_analysis, formulas, user_prompt)
+    
+    def modeling_actor(self, prompt: str, data_summary: str, task_description: str, task_analysis: str, formulas: str, modeling: str, user_prompt: str = ''):
+        prompt = TASK_MODELING_PROMPT.format(prompt=prompt, coo_prompt=self.coo_prompt, data_summary=data_summary, task_description=task_description, task_analysis=task_analysis, modeling_formulas=formulas, modeling_methods=modeling, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+    
+    def coding_actor(self, data_file, data_summary, variable_description, task_description: str, task_analysis: str, formulas: str, modeling: str, dependent_file_prompt: str, code_template: str, script_name: str, work_dir: str, user_prompt: str = ''):
+        if self.coo:
+            prompt = TASK_CODING_PROMPT.format(data_file=data_file, data_summary=data_summary, variable_description=variable_description, task_description=task_description, task_analysis=task_analysis, modeling_formulas=formulas, modeling_process=modeling, dependent_file_prompt=dependent_file_prompt, code_template=code_template, user_prompt=user_prompt).strip()
+        else:
+            prompt = TASK_CODING_WO_COO_PROMPT.format(data_file=data_file, data_summary=data_summary, variable_description=variable_description, task_description=task_description, task_analysis=task_analysis, modeling_formulas=formulas, modeling_process=modeling, code_template=code_template, user_prompt=user_prompt).strip()  
+        max_retry = 0
+        while max_retry < 5:
+            max_retry += 1
+            try:
+                completion = self.llm.generate(prompt)
+                new_content = completion.split("```python")[1].split("```")[0].strip()
+                break  
+            except Exception as e:
+                # Format control.
+                print(f"Retry! The code does not start with ```python")
+                continue
+
+        with open(os.path.join(work_dir, script_name), "w") as f:
+            f.write(new_content)
+        
+        # Execute the script.
+        try:
+            observation = execute_script(script_name, work_dir)
+            ## If observation is too long, we only keep the last ~2k tokens.
+            enc = tiktoken.get_encoding("cl100k_base")
+            tokens = len(enc.encode(observation))
+            if tokens >= 2000:
+                observation = observation[:2000]
+                tokens = len(enc.encode(observation))
+        except Exception as e:
+            print(e)
+            input("Ah oh, Got stuck! Press any key to continue.")
+
+        return new_content, observation
+    
+    def coding_debugger(self, code_template: str, modeling: str, code: str, observation: str, script_name: str, work_dir: str, user_prompt: str = ''):
+        
+        prompt = TASK_CODING_DEBUG_PROMPT.format(code_template=code_template, modeling_process=modeling, code=code, observation=observation, user_prompt=user_prompt).strip()
+        
+        max_retry = 0
+        while max_retry < 5:
+            max_retry += 1
+            try:
+                completion = self.llm.generate(prompt)
+                new_content = completion.split("```python")[1].split("```")[0].strip()
+                break  
+            except Exception as e:
+                # Format control.
+                print(f"Retry! The code does not start with ```python")
+                continue
+
+        with open(os.path.join(work_dir, script_name), "w") as f:
+            f.write(new_content)
+        
+        # Execute the script.
+        try:
+            observation = execute_script(script_name, work_dir)
+            ## If observation is too long, we only keep the last ~2k tokens.
+            enc = tiktoken.get_encoding("cl100k_base")
+            tokens = len(enc.encode(observation))
+            if tokens >= 2000:
+                observation = observation[:2000]
+                tokens = len(enc.encode(observation))
+        except Exception as e:
+            print(e)
+            input("Ah oh, Got stuck! Press any key to continue.")
+
+        return new_content, observation
+    
+    def coding(self, data_file, data_summary, variable_description, task_description: str, task_analysis: str, formulas: str, modeling: str, dependent_file_prompt: str, code_template: str, script_name: str, work_dir: str, try_num: int = 5, round: int = 1, user_prompt: str = ''):
+        for i in range(try_num):
+            print("="*10 + f" Try: {i + 1} " + "="*10)
+            iteration = 0
+            max_iteration = 3
+            while iteration < max_iteration:
+                print("="*10 + f" Iteration: {iteration + 1} " + "="*10)
+                if iteration == 0:
+                    code, observation = self.coding_actor(data_file, data_summary, variable_description, task_description, task_analysis, formulas, modeling, dependent_file_prompt, code_template, script_name, work_dir, user_prompt)
+                    # If the script has been successfully executed: Exit.
+                    if "Traceback (most recent call last):" not in observation and "SyntaxError: invalid syntax" not in observation and "IndentationError" not in observation:
+                        return code, True, observation.split("The script has been executed. Here is the output:\n")[1]
+                else:
+                    code, observation = self.coding_debugger(code_template, modeling, code, observation, script_name, work_dir, user_prompt)
+                    # If the script has been successfully executed: Exit.
+                    if "Traceback (most recent call last):" not in observation and "SyntaxError: invalid syntax" not in observation and "IndentationError" not in observation:
+                        return code, True, observation.split("The script has been executed. Here is the output:\n")[1]
+                iteration += 1
+
+        return code, False, None
+
+    def result(self, task_description: str, task_analysis: str, task_formulas: str, task_modeling: str, user_prompt: str = '', execution_result: str = ''):
+        if execution_result == '':
+            prompt = TASK_RESULT_PROMPT.format(task_description=task_description, task_analysis=task_analysis, task_formulas=task_formulas, task_modeling=task_modeling, user_prompt=user_prompt).strip()
+        else:
+            prompt = TASK_RESULT_WITH_CODE_PROMPT.format(task_description=task_description, task_analysis=task_analysis, task_formulas=task_formulas, task_modeling=task_modeling, user_prompt=user_prompt, execution_result=execution_result).strip()
+        return self.llm.generate(prompt)
+
+    def answer(self, task_description: str, task_analysis: str, task_formulas: str, task_modeling: str, task_result: str, user_prompt: str = ''):
+        prompt = TASK_ANSWER_PROMPT.format(task_description=task_description, task_analysis=task_analysis, task_formulas=task_formulas, task_modeling=task_modeling, task_result=task_result, user_prompt=user_prompt).strip()
+        return self.llm.generate(prompt)
+
+    def extract_code_structure(self, task_id, code: str, save_path: str):
+        prompt = CODE_STRUCTURE_PROMPT.format(code=code, save_path=save_path)
+        count = 0
+        for i in range(5):
+            try:
+                strucutre = self.llm.generate(prompt)
+                structure_string = strucutre.strip('```json\n').strip('```')
+                structure_json = json.loads(structure_string)
+                for i in range(len(structure_json['file_outputs'])):
+                    structure_json['file_outputs'][i]['file_description'] = 'This file is generated by code for Task {}. '.format(task_id) + structure_json['file_outputs'][i]['file_description']
+                return structure_json
+            except:
+                continue
+        if count == 5:
+            sys.exit("Fail at extract_code_structure")

core/agent/task_decompse.py

@@ -0,0 +1,47 @@
+from typing import List
+from pathlib import Path
+from .base_agent import BaseAgent
+from prompt.template import TASK_DECOMPOSE_PROMPT, TASK_DESCRIPTION_PROMPT, TASK_DECOMPOSE_WO_COO_PROMPT
+from utils.utils import read_json_file
+
+
+class TaskDecompose(BaseAgent):
+    def __init__(self, llm, coo=True):
+        super().__init__(llm)
+        self.coo = coo
+        current_file = Path(__file__).resolve()
+        path = current_file.parent.parent.parent / 'data/actor_data/input/decompose_prompt.json'
+        self.decomposed_principles = read_json_file(str(path))
+
+
+    def decompose(self, modeling_problem: str, problem_analysis: str, modeling_solution: str, problem_type: str, tasknum: int, user_prompt: str=''):
+        if self.coo:
+            decomposed_principle = self.decomposed_principles.get(problem_type, self.decomposed_principles['C'])
+            decomposed_principle = decomposed_principle.get(str(tasknum), decomposed_principle['4'])
+            prompt = TASK_DECOMPOSE_PROMPT.format(modeling_problem=modeling_problem, problem_analysis=problem_analysis, modeling_solution=modeling_solution, decomposed_principle=decomposed_principle, tasknum=tasknum, user_prompt=user_prompt)
+            # print(prompt)
+            answer = self.llm.generate(prompt)
+            tasks = [task.strip() for task in answer.split('---') if task.strip()]
+        else:
+            prompt = TASK_DECOMPOSE_WO_COO_PROMPT.format(modeling_problem=modeling_problem, tasknum=tasknum, user_prompt=user_prompt)
+            # print(prompt)
+            answer = self.llm.generate(prompt)
+            tasks = [task.strip() for task in answer.split('---') if task.strip()]
+        return tasks
+
+    def refine(self, modeling_problem: str, problem_analysis: str, modeling_solution: str, decomposed_subtasks: List[str], task_i: int):
+        decomposed_subtasks_str = '\n'.join(decomposed_subtasks)
+        prompt = TASK_DESCRIPTION_PROMPT.format(modeling_problem=modeling_problem, problem_analysis=problem_analysis, modeling_solution=modeling_solution, decomposed_subtasks=decomposed_subtasks_str, task_i=task_i+1)
+        answer = self.llm.generate(prompt)
+        return answer
+
+    def decompose_and_refine(self, modeling_problem: str, problem_analysis: str, modeling_solution: str, decomposed_principle: str, tasknum: int, user_prompt: str=''):
+        if self.coo:
+            decomposed_subtasks = self.decompose(modeling_problem, problem_analysis, modeling_solution, decomposed_principle, tasknum, user_prompt)
+            for task_i in range(len(decomposed_subtasks)):
+                refined_subtask = self.refine(modeling_problem, problem_analysis, modeling_solution, decomposed_subtasks, task_i)
+                decomposed_subtasks[task_i] = refined_subtask
+        else:
+            decomposed_subtasks = self.decompose(modeling_problem, problem_analysis, modeling_solution, decomposed_principle, tasknum, user_prompt)
+
+        return decomposed_subtasks

core/input/problem.py

@@ -0,0 +1,31 @@
+from utils.utils import read_json_file
+
+from prompt.template import PROBLEM_PROMPT
+from agent.data_description import DataDescription
+
+
+def problem_input(problem_path, llm):
+    problem = read_json_file(problem_path)
+    data_description = problem.get('dataset_description', {})
+    ds = DataDescription(llm)
+    
+    if data_description:
+        data_path = problem['dataset_path']
+        variable_description = problem['variable_description']
+        data_summary = ds.summary(data_description=str(data_description) + '\n' + str(variable_description))
+        data_summary = f'Dataset Path:\n{data_path}\n\nData Description:\n{data_summary}'
+    else:
+        data_summary = ''
+
+    problem['data_summary'] = data_summary
+    problem['data_description'] = data_description
+
+    if problem.get('addendum', ''):
+        addendum = f"Addendum: \n{problem['addendum']}"
+    else:
+        addendum = ''
+
+    problem_str = PROBLEM_PROMPT.format(problem_background=problem['background'], problem_requirement=problem['problem_requirement'], addendum=addendum, data_summary=data_summary).strip()
+    problem['problem_str'] = problem_str
+    return problem_str, problem
+

core/input/test_middle_result.py

@@ -0,0 +1,212 @@
+
+problem_str = """\
+Problem Background:
+In the 2023 Wimbledon Gentlemen’s final, 20-year-old Spanish rising star Carlos Alcaraz defeated 36-year-old Novak Djokovic. The loss was Djokovic’s first at Wimbledon since 2013 and ended a remarkable run for one of the all-time great players in Grand Slams.
+The match itself was a remarkable battle.[1] Djokovic seemed destined to win easily as he dominated the first set 6 – 1 (winning 6 of 7 games). The second set, however, was tense and finally won by Alcarez in a tie-breaker 7 – 6. The third set was the reverse of the first, Alcaraz winning handily 6 – 1. The young Spaniard seemed in total control as the fourth set started, but somehow the match again changed course with Djokovic taking complete control to win the set 6 – 3. The fifth and final set started with Djokovic carrying the edge from the fourth set, but again a change of direction occurred and Alcaraz gained control and the victory 6 – 4. The data for this match is in the provided data set, “match_id” of “2023-wimbledon-1701”. You can see all the points for the first set when Djokovic had the edge using the “set_no” column equal to 1. The incredible swings, sometimes for many points or even games, that occurred in the player who seemed to have the advantage are often attributed to “momentum.”
+
+Problem Requirement:
+One dictionary definition of momentum is “strength or force gained by motion or by a series of events.”[2] In sports, a team or player may feel they have the momentum, or “strength/force” during a match/game, but it is difficult to measure such a phenomenon. Further, it is not readily apparent how various events during the match act to create or change momentum if it exists. Data is provided for every point from all Wimbledon 2023 men’s matches after the first 2 rounds. You may choose to include additional player information or other data at your discretion, but you must completely document the sources. Use the data to:
+Develop a model that captures the flow of play as points occur and apply it to one or more of the matches. Your model should identify which player is performing better at a given time in the match, as well as how much better they are performing. Provide a visualization based on your model to depict the match flow. Note: in tennis, the player serving has a much higher probability of winning the point/game. You may wish to factor this into your model in some way.
+A tennis coach is skeptical that “momentum” plays any role in the match. Instead, he postulates that swings in play and runs of success by one player are random. Use your model/metric to assess this claim.
+Coaches would love to know if there are indicators that can help determine when the flow of play is about to change from favoring one player to the other. Using the data provided for at least one match, develop a model that predicts these swings in the match. What factors seem most related (if any)? Given the differential in past match “momentum” swings how do you advise a player going into a new match against a different player? Test the model you developed on one or more of the other matches. How well do you predict the swings in the match? If the model performs poorly at times, can you identify any factors that might need to be included in future models? How generalizable is your model to other matches (such as Women’s matches), tournaments, court surfaces, and other sports such as table tennis.
+Produce a report of no more than 25 pages with your findings and include a one- to two-page memo summarizing your results with advice for coaches on the role of “momentum”, and how to prepare players to respond to events that impact the flow of play during a tennis match.
+
+Data Description:
+The dataset provides a comprehensive overview of match statistics from tennis games, specifically detailing individual points within matches at the 2023 Wimbledon tournament. Each entry is associated with a unique match identifier that indicates the round and match number, allowing for easy tracking of specific games throughout the tournament.
+
+Key players are identified by their full names, and the dataset captures various metrics that reflect their performance over the course of the match. The elapsed time field records the duration from the start of the first point to the beginning of the current point, providing insight into the pace of play.
+
+The dataset includes information on sets and games, indicating how many sets each player has won, as well as their respective game victories in the current set. This allows for analysis of player performance both within individual matches and across the tournament. The scoring system is detailed, with scores recorded in the traditional tennis format (love, 15, 30, 40, advantage), which adds context to the competitive nature of the points being analyzed.
+
+Service dynamics are captured through fields indicating which player is serving, the type of serve (first or second), and the outcomes of those serves. Additionally, the dataset tracks critical point outcomes, identifying the winner of each point along with various performance metrics such as aces, double faults, winners, and unforced errors. These statistics are essential for evaluating the players' effectiveness and consistency during the match.
+
+The dataset also includes information on strategic elements like break points—opportunities for players to capitalize on their opponent's serve—providing insights into pivotal moments that can influence match outcomes. Furthermore, physical performance is tracked through metrics like distance run during points, which highlights the physical demands placed on players during high-stakes moments.
+
+Rally counts and shot speeds contribute to a deeper understanding of match dynamics, revealing how aggressive or defensive a player might be during exchanges. The depth and width of serves and returns further illustrate players' tactical choices, aiding in the analysis of their playing styles.
+
+Overall, this dataset serves as a rich resource for analyzing tennis match performance, providing a detailed snapshot of player actions and outcomes throughout specific points in a match, which can be invaluable for coaches, analysts, and fans looking to understand the intricacies of tennis at a professional level.
+"""
+
+problem_analysis = """\
+The problem of modeling momentum in tennis matches, particularly in the context of the 2023 Wimbledon tournament, requires a multi-faceted approach that integrates advanced statistical techniques, machine learning algorithms, and a deep understanding of the sport's dynamics. Momentum in tennis is a complex phenomenon influenced by a combination of player-specific attributes, match-specific conditions, and external variables. To develop a robust model, it is essential to move beyond traditional metrics such as serving advantage and incorporate granular data on serve placement, speed, and depth, as well as return strategies. These serve-specific details can provide deeper insights into the flow of play and help identify moments where momentum may shift. For instance, a player’s ability to consistently place serves in challenging positions or exploit an opponent’s return weaknesses can create sustained advantages that are not fully captured by simple win-loss metrics. Additionally, the model should account for the role of court surface, as different surfaces (e.g., grass, clay, hard court) can influence player performance and the dynamics of momentum. For example, on grass courts like Wimbledon, the faster surface may amplify the impact of serve dominance, while on clay courts, longer rallies and baseline play may shift the balance of momentum differently. By incorporating surface-specific dynamics, the model can better capture the nuances of momentum in different contexts.
+
+Psychological factors also play a crucial role in momentum, as player confidence, resilience, and the ability to handle pressure during critical points (e.g., break points or set points) can significantly influence performance. Quantifying these factors requires integrating historical performance data to assess how players typically respond under pressure, as well as leveraging real-time biometric data to gauge mental and physical fatigue. For example, a player may experience a temporary dip in performance due to fatigue, which could be misinterpreted as a loss of momentum if not properly accounted for. Similarly, the model should consider the significance of specific points, such as break points or set points, which can have a disproportionate impact on momentum. By incorporating these contextual factors, the model can provide a more accurate and nuanced depiction of momentum in tennis matches. Furthermore, the model should account for the psychological impact of crowd support or adverse conditions, such as weather, which can influence player performance and momentum shifts. For instance, a player who thrives under pressure may gain momentum from a supportive crowd, while another player may struggle with the added scrutiny of a high-stakes match.
+
+To assess the claim that momentum is merely a random phenomenon, the model must employ rigorous statistical methods to test the significance of observed performance swings. This involves analyzing the distribution of point outcomes and comparing them to expected probabilities based on serving advantages and other factors. If the model identifies patterns that deviate significantly from random variations, it would provide evidence supporting the existence of momentum. Conversely, if the observed swings align with random fluctuations, it would lend credence to the coach's skepticism. This analysis should also consider the potential for overfitting, ensuring that the model does not attribute significance to spurious patterns in the data. Additionally, the model should be tested on multiple matches to assess its robustness and generalizability. For example, by applying the model to matches from different rounds of the tournament or different years, we can evaluate whether the observed patterns of momentum are consistent across different contexts. This cross-validation process is critical for establishing the reliability of the model and its ability to distinguish between genuine momentum shifts and random variations.
+
+Predicting shifts in the flow of play requires the model to identify indicators that precede changes in momentum. These indicators could include changes in player behavior, such as increased aggression or defensive play, as well as performance metrics like unforced errors or first-serve percentages. By analyzing these factors, the model can provide actionable insights for coaches, helping them anticipate and respond to momentum shifts during a match. For example, if the model detects a pattern of increasing unforced errors by a player, it could signal an impending loss of momentum, prompting the coach to adjust the player's strategy. However, the model's predictive accuracy must be rigorously tested on multiple matches to ensure its reliability. If the model performs poorly in certain scenarios, it may indicate the need to include additional variables or refine the existing ones. For instance, incorporating data on player fatigue or mental state could improve the model's predictive capabilities. Additionally, the model should consider the role of tactical adjustments, such as changes in serve placement or return strategy, which can influence the flow of play and momentum. By integrating these dynamic factors, the model can provide a more comprehensive understanding of momentum and its drivers.
+
+The generalizability of the model to other contexts, such as women's matches, different tournaments, or other sports, depends on its ability to capture universal aspects of momentum while remaining adaptable to specific conditions. For instance, the serving advantage in tennis may differ from the serve advantage in table tennis, requiring adjustments to the model. Similarly, the psychological and physical demands of different sports may influence how momentum manifests. By designing the model with flexibility in mind, it can be adapted to analyze momentum in a wide range of competitive settings, providing valuable insights for coaches and players across various disciplines. Additionally, the model should be tested on historical data from different tournaments and surfaces to assess its robustness and applicability. For example, by applying the model to matches played on clay courts, we can evaluate whether the observed patterns of momentum are consistent across different surfaces. This adaptability is crucial for ensuring that the model remains relevant and useful in diverse competitive environments.
+
+In conclusion, developing a model to capture momentum in tennis matches requires a comprehensive and dynamic approach that integrates quantitative data with qualitative insights. The model must account for the serving advantage, psychological factors, and time-dependent variables, while also distinguishing between random fluctuations and genuine momentum shifts. By rigorously testing the model's assumptions and predictions, and by incorporating feedback from real-world applications, it can provide valuable insights into the role of momentum in tennis and other sports. This, in turn, can help coaches and players better understand and respond to the ebb and flow of competitive play, ultimately enhancing their performance and strategic decision-making. The model should also be designed with flexibility in mind, allowing it to be adapted to different contexts and providing a robust framework for analyzing momentum across a wide range of competitive settings.
+"""
+
+selected_models = """\
+The most innovative, advanced, and suitable mathematical and machine learning models for modeling the problem of momentum in tennis matches include:
+- **Logistic Regression** for point outcome predictions.
+- **Random Forest** or **Support Vector Machines** for predicting momentum shifts.
+- **ARIMA Models** and **Markov Chain Models** for analyzing momentum dynamics over time.
+- **Time Series Analysis** for identifying trends in player performance.
+
+These models not only capture the nuances of match dynamics but also provide a solid framework for coaches to understand and prepare for momentum shifts during matches. The insights derived from these models can significantly enhance match strategies and player preparation.
+"""
+
+modeling_solution = """\
+To solve the momentum modeling problem in tennis, we can construct a comprehensive model that captures the flow of play, analyzes momentum shifts, and predicts future changes in the match. The mathematical approach will combine probabilistic, statistical, and machine learning techniques to capture both the player performance and momentum dynamics.
+
+### **1. Model Components:**
+The model will be broken down into different components that allow us to track performance and momentum. These components include:
+
+- **State Transitions (Markov Chain)**
+- **Performance Metrics (Player Statistics)**
+- **Momentum Indicator**
+- **Prediction of Momentum Shift**
+  
+Each of these components requires sophisticated mathematical formulas and data representations. Let's discuss each step in detail.
+
+### **2. State Transition Modeling:**
+We begin by using **Markov Chains** to model the transition between states during the match. This is ideal for modeling the progression of a tennis match, where the match state is influenced by previous outcomes but does not depend on the entire history (Markov property).
+
+Let’s define the state of the match at a given point in time \( t \) as a tuple of the following:
+
+\[
+S(t) = \{ \text{score}_{\text{player 1}}, \text{score}_{\text{player 2}}, \text{serve}, \text{set}_1, \text{set}_2, \dots, \text{time}\}
+\]
+
+Here:
+- **score** refers to the current game score of both players in terms of tennis scoring.
+- **serve** indicates which player is serving.
+- **set** indicates the current set scores for both players.
+- **time** is the timestamp of the point in the match.
+
+At each point, the system transitions to a new state based on the outcome of the point. The transition probabilities between these states can be modeled as a **transition matrix**, denoted by \( P \):
+
+\[
+P_{ij} = P(S(t+1) = s_j | S(t) = s_i)
+\]
+
+Where \( P_{ij} \) represents the probability of transitioning from state \( s_i \) to \( s_j \), given the match's historical performance. This will allow us to model the evolution of the match and identify significant shifts in momentum.
+
+The transition matrix will be derived using the observed data in the dataset, particularly focusing on factors such as:
+- Player performance metrics (e.g., aces, winners, unforced errors)
+- Whether the player is serving (since servers have an advantage)
+- The current score and game state
+- Physical metrics like player movement or serve speed
+
+### **3. Momentum Indicator Model:**
+
+**Momentum** in tennis is typically thought of as a shift in player performance due to psychological or physical factors, often manifesting in runs of consecutive points won or sudden changes in strategy. We define the momentum \( M(t) \) as a function of multiple match variables:
+
+\[
+M(t) = f(P_{\text{player 1}}, P_{\text{player 2}}, \Delta \text{score}, S_{\text{serve}}, R_{\text{streak}}, T_{\text{tension}})
+\]
+
+Where:
+- \( P_{\text{player}} \) represents a vector of player performance metrics at time \( t \) (e.g., first-serve percentage, aces, unforced errors, winners).
+- \( \Delta \text{score} \) represents the relative score difference between players at time \( t \).
+- \( S_{\text{serve}} \) is the indicator of the player who is serving.
+- \( R_{\text{streak}} \) is the **run of consecutive points won** by a player (i.e., a player's success streak).
+- \( T_{\text{tension}} \) is a measure of how tense the match is, such as a tie-break or break point situation.
+
+A simple formula for momentum might involve calculating the ratio of successful points to total points, adjusted for the player's current performance:
+
+\[
+M(t) = \frac{\text{Points Won}_{\text{player 1}}}{\text{Points Played}} - \frac{\text{Points Won}_{\text{player 2}}}{\text{Points Played}} + \alpha \cdot R_{\text{streak}} + \beta \cdot T_{\text{tension}}
+\]
+
+Where:
+- The first term represents the win rate of each player up to time \( t \).
+- The second term adjusts momentum based on consecutive points won (with \( \alpha \) as a weight).
+- The third term accounts for match tension, where \( T_{\text{tension}} \) could be quantified by analyzing critical moments (like break points) or the phase of the match.
+
+### **4. Statistical Test for Randomness:**
+To test the coach's hypothesis that "momentum" is just random fluctuations in play, we need to compare observed momentum with random fluctuations:
+
+- Null Hypothesis \( H_0 \): There is no momentum effect (the swings are random).
+- Alternative Hypothesis \( H_1 \): There is a non-random momentum effect (swings correlate with performance and match dynamics).
+
+We use a **Randomization Test** to compare the actual momentum times series with a shuffled version of the same data (where player points are randomly reassigned). The test statistic for momentum could be the **standard deviation** of momentum:
+
+\[
+\text{std}(M_{\text{real}}) \quad \text{vs} \quad \text{std}(M_{\text{random}})
+\]
+
+If \( \text{std}(M_{\text{real}}) \) is significantly higher than \( \text{std}(M_{\text{random}}) \), we reject \( H_0 \) and conclude that momentum plays a role.
+
+### **5. Predicting Momentum Shift (Machine Learning Approach):**
+
+To predict future momentum shifts, we can leverage **Random Forests** or **Gradient Boosting Machines (GBM)**. The key features will include:
+- Player statistics (e.g., first serve win percentage, winners, aces)
+- Point streak information
+- Current match state (game, set, or match score)
+- Relative performance (player 1 vs player 2)
+- Tension index (break points, tie-breaks, etc.)
+
+We define the momentum shift prediction as a binary classification problem:
+
+\[
+\text{Momentum Shift} = 
+\begin{cases} 
+1 & \text{if momentum shifts in favor of player 1} \\
+0 & \text{if momentum shifts in favor of player 2}
+\end{cases}
+\]
+
+The model predicts the likelihood \( P(\text{Shift}) \), and we evaluate the model using standard classification metrics like **accuracy**, **precision**, and **recall**.
+
+### **6. Mathematical Formulation for Momentum Prediction:**
+
+Given the features \( \mathbf{X}_t \) at time \( t \), the output probability of a momentum shift can be modeled as:
+
+\[
+P(\text{Shift} = 1 | \mathbf{X}_t) = \sigma(\mathbf{w}^\top \mathbf{X}_t)
+\]
+
+Where:
+- \( \sigma(\cdot) \) is the logistic sigmoid function.
+- \( \mathbf{w} \) are the weights learned by the model.
+- \( \mathbf{X}_t \) is the feature vector at time \( t \) (e.g., player performance, set/game score, etc.).
+
+### **7. Model Evaluation and Generalization:**
+
+To assess the performance of the momentum shift prediction model:
+- Split the dataset into training and testing sets.
+- Evaluate on multiple matches to assess generalizability.
+- Fine-tune the model using cross-validation.
+- Test the model’s performance across different tournaments, surfaces, and even for female matches.
+
+---
+
+### **8. Visualization of Momentum:**
+
+The visualization could take the form of a **momentum curve**, where the x-axis represents time (or points played) and the y-axis represents the calculated momentum \( M(t) \). The curve will oscillate based on player performance and could be highlighted with vertical lines representing significant shifts in momentum.
+
+#### Example:
+
+\[
+\text{Momentum Curve: } M(t) \text{ vs } t
+\]
+
+---
+
+### **Final Remarks:**
+
+This model provides a sophisticated framework for understanding momentum in tennis. By leveraging a combination of Markov Chains, machine learning techniques, and statistical testing, it offers a predictive tool for momentum shifts. Coaches can use this model to assess how momentum affects match outcomes and prepare players for psychological and strategic shifts during matches.
+"""
+
+modeling_solution = """\
+To effectively model the dynamics of momentum in tennis matches, particularly in the context of the 2023 Wimbledon tournament, we must adopt a structured approach that integrates statistical analysis and machine learning techniques with a nuanced understanding of tennis gameplay. The model should begin with a clear definition of momentum as a quantifiable shift in player performance, characterized by changes in key performance indicators such as point-win probability, serve effectiveness, and error rates. To capture the serving advantage, the model should incorporate player-specific serving statistics, adjusting for the different likelihood of winning points based on whether a player is serving or returning. By using historical data, we can establish baseline probabilities for each player, which will serve as dynamic benchmarks throughout the match.
+
+The core of the model will be a probabilistic framework that continuously updates the likelihood of a player gaining or losing momentum based on the unfolding match data. This can be achieved through a Bayesian approach, where prior probabilities are adjusted with new information as the match progresses. The model will incorporate variables such as serve speed, return depth, rally length, and player fatigue, each weighted according to its historical impact on momentum shifts. Additionally, psychological factors can be quantified by analyzing historical performance under pressure situations, such as break points or tiebreaks, allowing the model to estimate a player's mental resilience.
+
+Machine learning techniques, such as decision trees or random forests, can be employed to identify patterns and interactions between these variables, providing insights into the critical factors that precede momentum shifts. By training these models on a comprehensive dataset of past matches, we can identify the most predictive indicators of momentum changes. The model should also include a temporal component, using time-series analysis to capture the evolving nature of momentum as the match progresses.
+
+To assess the validity of the momentum concept against the claim of randomness, the model will implement statistical tests to compare observed runs and performance swings to those expected under a random-walk hypothesis. This involves simulating matches based on random point distributions and comparing the frequency and magnitude of momentum shifts to actual match data. If the model detects systematic deviations from randomness, it provides evidence for the existence of momentum.
+
+For practical application, the model will generate real-time predictions and alerts for coaches, indicating potential shifts in momentum and suggesting tactical adjustments. This can be facilitated through a user-friendly interface that visualizes momentum trends and key performance indicators. The model should be tested and validated across multiple matches, including different rounds and surfaces, to ensure robustness and generalizability. By incorporating cross-validation techniques, we can fine-tune the model parameters and improve predictive accuracy.
+
+Furthermore, the model's adaptability to different sports or contexts involves recalibrating for sport-specific dynamics, such as the impact of team interactions in basketball or the influence of equipment in table tennis. By focusing on universal aspects of momentum, such as psychological resilience and performance consistency, the model can be extended to other competitive environments. Ultimately, this refined modeling approach not only addresses the intricacies of momentum in tennis but also provides actionable insights for improving player performance and strategic decision-making in various sports settings.
+"""
+
+task_descriptions =  ['The first subtask involves establishing a robust probabilistic framework to quantify momentum in tennis matches, focusing on defining momentum as a measurable shift in player performance through variations in key performance indicators such as point-win probability, serve effectiveness, and error rates. The primary goal is to accurately capture the dynamic nature of momentum by integrating player-specific serving statistics, which account for the different likelihoods of point outcomes depending on whether a player is serving or returning. To achieve this, the subtask requires the use of historical match data to create baseline probabilities for each player, serving as dynamic benchmarks that adjust with ongoing match events. The methodology centers on a Bayesian approach, where prior probabilities are continuously updated with new data as the match progresses, reflecting real-time dynamics and shifts in momentum. This involves collecting and analyzing data inputs such as serve speed, return effectiveness, and other relevant match statistics to inform the probabilistic model. Tools and techniques such as Bayesian inference and statistical analysis are crucial for updating probabilities and capturing the nuances of momentum. The outcome of this subtask is a foundational model capable of reflecting the ebb and flow of momentum in real-time, providing a basis for further analysis and integration with additional model components in subsequent subtasks.', "The second subtask aims to enhance the model's ability to discern momentum shifts in tennis matches by leveraging machine learning techniques to identify patterns and interactions among influential variables. This involves the application of models such as decision trees, random forests, or gradient boosting to analyze a rich dataset of historical match data, focusing on uncovering the most predictive indicators of momentum changes. Key variables of interest include serve speed, return depth, rally length, player fatigue, and psychological resilience, with each factor weighted based on its historical impact on momentum. The machine learning model will be trained on labeled datasets where momentum shifts are identified, allowing it to learn complex relationships and interactions between variables. The training process involves feature engineering to extract meaningful insights from raw data, including the creation of derived features that capture temporal dynamics, such as moving averages or momentum scores calculated over a series of points or games. Cross-validation techniques will be employed to ensure the model's robustness and to prevent overfitting, thereby improving its predictive accuracy across different match scenarios. By integrating these machine learning models, the subtask seeks to provide deeper insights into the conditions that precede momentum shifts, ultimately enhancing the model's capacity to predict and quantify momentum changes as they occur during a match.", 'The third subtask focuses on rigorously testing the hypothesis that momentum in tennis matches is merely a random phenomenon. The goal is to determine whether observed performance swings are consistent with random variations or if they indicate genuine momentum shifts. This involves conducting statistical tests that compare the actual match data against a null hypothesis of randomness, often modeled as a random-walk process. The methodology includes simulating matches using randomly distributed point outcomes to create a baseline of expected performance swings under purely stochastic conditions. By analyzing the frequency, duration, and magnitude of momentum shifts in real matches against this random baseline, we can assess whether the observed patterns deviate significantly from what would be expected by chance. The key data inputs for this subtask are point-by-point outcomes from the dataset, which will be used to construct both the observed and simulated match timelines. Statistical techniques such as Monte Carlo simulations, chi-squared tests, or permutation tests may be employed to quantify the degree of deviation from randomness. The outcome of this subtask is to provide statistical evidence either supporting or refuting the existence of momentum, thereby addressing the skepticism about its role in tennis. This evidence is crucial for validating the broader model and confirming whether momentum should be considered a significant factor in match analysis and strategy development.', "Subtask 4 focuses on the practical application and generalizability of the momentum model by developing a real-time prediction system designed to assist coaches in making strategic decisions during a match. The primary goal is to create a system that can predict potential shifts in momentum, providing timely alerts that suggest tactical adjustments to optimize player performance. To achieve this, the subtask involves designing a user-friendly interface that visualizes momentum trends and key performance indicators in an accessible format, allowing coaches to quickly interpret the data. The methodology includes integrating the model with live match data feeds, enabling continuous updates and real-time analysis. The system will leverage machine learning algorithms, such as real-time decision trees or neural networks, to process incoming data and generate predictive insights. Key data inputs for this task include real-time match statistics like serve speed, rally length, player fatigue levels, and psychological resilience metrics, which are processed to detect patterns indicative of momentum shifts. The model's robustness will be tested across a diverse range of matches, including different rounds, surfaces, and player styles, to ensure its adaptability and reliability. Additionally, the subtask emphasizes recalibrating the model for application in other sports contexts, such as basketball or table tennis, by focusing on universal momentum aspects like psychological resilience and consistent performance. This adaptability is crucial for extending the model's utility beyond tennis, providing valuable insights to enhance strategic decision-making and player preparation across various sports settings."]
+

core/llm/llm.py

@@ -0,0 +1,122 @@
+import os
+import requests
+import openai
+from dotenv import load_dotenv
+import json
+
+load_dotenv()
+
+class LLM:
+
+    usages = []
+
+    def __init__(self, model_name, logger=None, user_id=None):
+        self.model_name = model_name
+        self.logger = logger
+        self.user_id = user_id
+        if self.model_name in ['deepseek-chat', 'deepseek-reasoner']:
+            self.api_key = os.getenv('DEEPSEEK_API_KEY')
+            self.api_base = os.getenv('DEEPSEEK_API_BASE')
+        else:
+            self.api_key = "key" # os.getenv('OPENAI_API_KEY')
+            # self.api_base = "https://gpt-api.hkust-gz.edu.cn/v1/chat/completions" # os.getenv('OPENAI_API_BASE')
+            self.api_key = os.getenv('OPENAI_API_KEY')
+            self.api_base = "https://api.openai.com/v1/chat/completions"
+        
+        if not self.api_key:
+            raise ValueError('API key not found in environment variables')
+
+        self.client = openai.Client(api_key=self.api_key, base_url=self.api_base)
+
+    def reset(self, api_key=None, api_base=None, model_name=None):
+        if api_key:
+            self.api_key = api_key
+        if api_base:
+            self.api_base = api_base
+        if model_name:
+            self.model_name = model_name
+        self.client = openai.Client(api_key=self.api_key, base_url=self.api_base)
+
+    def generate(self, prompt, system='', usage=True):
+        try:
+            if self.model_name in ['deepseek-chat', 'deepseek-reasoner']:
+                response = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=[
+                        {'role': 'system', 'content': system},
+                        {'role': 'user', 'content': prompt}
+                    ],
+                    temperature=0.7,
+                    top_p=1.0,
+                    frequency_penalty=0.0,
+                    presence_penalty=0.0
+                )
+                answer = response.choices[0].message.content
+                usage = {
+                    'completion_tokens': response.usage.completion_tokens,
+                    'prompt_tokens': response.usage.prompt_tokens,
+                    'total_tokens': response.usage.total_tokens
+                }
+            else:
+                messages=[{'role': 'system', 'content': system},
+                          {'role': 'user', 'content': prompt}]
+                raw_request = {
+                    "model": self.model_name,
+                    "temperature": 0.7,
+                    "top_p": 1.0,
+                    "frequency_penalty": 0.0,
+                    "presence_penalty": 0.0
+                    }
+                # HKUST-GZ API
+                HEADERS = {
+                    "Content-Type": "application/json",
+                    "Authorization": "Bearer {}".format(self.api_key)
+                }
+                response = requests.post(self.api_base, headers=HEADERS, data=json.dumps({"messages": messages, **raw_request}))
+                response.raise_for_status()
+                response = response.json()
+                answer = response["choices"][0]["message"]["content"]
+                if self.model_name == 'DeepSeek-R1-671B':
+                    answer = answer.split('\n</think>\n\n')[1]
+                usage = {
+                    'completion_tokens': response['usage']['completion_tokens'],
+                    'prompt_tokens': response['usage']['prompt_tokens'],
+                    'total_tokens': response['usage']['total_tokens']
+                }
+            if self.logger:
+                self.logger.info(f"[LLM] UserID: {self.user_id} Key: {self.api_key}, Model: {self.model_name}, Usage: {usage}")
+            if usage:
+                self.usages.append(usage)
+            return answer
+
+        except Exception as e:
+            return f'An error occurred: {e}'
+
+    def get_total_usage(self):
+        total_usage = { 
+            'completion_tokens': 0,
+            'prompt_tokens': 0,
+            'total_tokens': 0
+        }
+        for usage in self.usages:
+            for key, value in usage.items():
+                total_usage[key] += value
+        return total_usage
+        
+    def clear_usage(self):
+        self.usages = []
+
+
+if __name__ == '__main__':
+    llm = LLM('deepseek-chat')
+    print(llm.generate('Hello, how are you?', 'You are a helpful assistant.', usage=True))
+
+    # llm = LLM('deepseek-chat')
+    # print(llm.generate('Hello, how are you?', 'You are a helpful assistant.'))
+    # print(llm.get_total_usage())
+    # llm.clear_usage()
+
+
+
+
+

core/prompt/constants.py

@@ -0,0 +1,271 @@
+modeling_methods = """\
+## Operations Research
+
+### Programming Theory
+#### Linear Programming
+- Linear Programming (LP)
+- Integer Programming (IP)
+- Mixed Integer Programming (MIP)
+- Goal Programming (GP)
+- Multi-Objective Programming (MOP)
+- Multi-level Programming
+- Dynamic Programming (DP)
+- Network Optimization Models
+- Parametric Linear Programming
+
+#### Nonlinear Programming
+- Convex Programming
+- Quadratic Programming (QP)
+- Nonlinear Programming (NLP)
+- Semi-Definite Programming (SDP)
+- Set Programming
+- Non-Smooth Optimization
+- Penalty Methods in Nonlinear Optimization
+
+#### Others
+- Fuzzy Optimization
+- Stochastic Optimization
+- Robust Optimization
+- Approximation Algorithms
+- Cooperative Game Theory
+- Metaheuristic Approaches (Simulated Annealing, Genetic Algorithms, etc.)
+
+### Graph Theory
+#### Path
+- Shortest Path Model (S-T, All-Pairs)
+- Dijkstra’s Algorithm
+- A* Algorithm
+- Bellman-Ford Algorithm
+- Eulerian Path Problem
+- Hamiltonian Cycle Problem
+- Traveling Salesman Problem (TSP)
+- Vehicle Routing Problem (VRP)
+- K-Shortest Path Problem
+- Path Planning Algorithms
+
+#### Tree
+- Minimum Spanning Tree (MST)
+- Prim’s Algorithm
+- Kruskal’s Algorithm
+- Huffman Tree
+- Steiner Tree Problem
+- Binary Search Tree (BST)
+- AVL Tree
+- K-d Tree
+- Quad Tree
+- B+ Tree
+
+#### Flow
+- Max-Flow Min-Cost Max-Flow Problem
+- Ford-Fulkerson Algorithm
+- Edmonds-Karp Algorithm
+- Minimum-Cost Flow Problem
+- Multi-Commodity Flow Problem
+- Network Reliability Models
+
+#### Others
+- Bipartite Matching Model
+- Stable Marriage Problem
+- Graph Coloring Problem (Greedy Coloring, Backtracking)
+- Vertex Cover Problem
+- Set Cover Problem
+- Clique Problem
+- Independent Set Problem
+- Algebraic Representation of Graph (Adjacency Matrix, Laplacian Matrix, Incidence Matrix)
+- Spectral Graph Theory Models
+
+### Stochastic Programming Theory
+- Stochastic Linear Programming
+- Markov Chains and Models
+- Markov Decision Process (MDP)
+- Queuing Theory (M/M/1, M/G/1, G/G/1 Queues)
+- Inventory Theory (Economic Order Quantity, Newsvendor Problem)
+- Monte Carlo Simulation
+- Reliability Theory
+- Decision Trees and Multi-Stage Decision Problems
+- Dynamic Stochastic Optimization
+
+## Optimization Methods
+
+### Deterministic Algorithms
+- Greedy Algorithm
+- Divide & Conquer
+- Dynamic Programming
+- Backtracking Algorithms
+- Local Search Algorithms
+- Branch and Bound
+
+### Heuristic Algorithms
+- Simulated Annealing (SA)
+- Tabu Search
+- Genetic Algorithm (GA)
+- Particle Swarm Optimization (PSO)
+- Ant Colony Optimization (ACO)
+- Harmony Search Algorithm
+- Differential Evolution
+- Memetic Algorithm
+- Iterative Deepening Search
+
+### Iterative Algorithms
+- Gradient Descent
+- Newton's Method
+- Coordinate Descent
+- Conjugate Gradient Method
+- Broyden–Fletcher–Goldfarb–Shanno (BFGS) Method
+- Levenberg-Marquardt Algorithm
+- Golden-Section Search
+- Nelder-Mead Simplex Algorithm
+
+### Constrained Optimization
+- Linear Programming (LP) Solvers (Simplex Method, Interior-Point Method)
+- Quadratic Programming (QP) Solvers
+- Feasible Direction Method
+- Projected Gradient Method
+- Augmented Lagrangian Methods
+- Lagrange Multipliers
+- Karush-Kuhn-Tucker Conditions
+- KKT Conditions in Nonlinear Optimization
+- Primal-Dual Methods
+
+### Solution Techniques
+- Branch and Bound Method
+- Relaxation Methods
+- Penalty Function Methods
+- Restriction Method
+- Lagrange Relaxation
+- Antithesis Optimization
+- Subgradient Methods
+- Multigrid Methods
+
+---
+
+## Machine Learning Topics
+
+### Classification
+- K-Nearest Neighbors (KNN)
+- Support Vector Machine (SVM)
+- Decision Trees
+- Random Forest
+- Gradient Boosting Machines (GBM)
+- XGBoost, LightGBM, CatBoost
+- Logistic Regression
+- Naive Bayes
+- Linear Discriminant Analysis (LDA)
+- Quadratic Discriminant Analysis (QDA)
+- Neural Networks (Feedforward, Convolutional, Recurrent)
+- Deep Learning (CNN, RNN, LSTM)
+
+### Clustering
+- K-Means Algorithm
+- K-Means++ Variant
+- Expectation-Maximization (EM)
+- Self-Organizing Maps (SOM)
+- DBSCAN (Density-Based Spatial Clustering)
+- Hierarchical Clustering
+- Agglomerative and Divisive Clustering
+- Spectral Clustering
+- Gaussian Mixture Models (GMM)
+- Affinity Propagation
+- Birch Clustering
+
+### Regression
+- Linear Regression
+- Ridge Regression
+- Lasso Regression
+- Elastic Net Regression
+- Poisson Regression
+- Logistic Regression (for binary classification)
+- Polynomial Regression
+- Generalized Linear Models (GLM)
+- Non-Linear Regression
+- Locally Weighted Regression (Loess)
+
+### Dimensionality Reduction
+#### Linear
+- Principal Component Analysis (PCA)
+- Canonical Correlation Analysis (CCA)
+- Independent Component Analysis (ICA)
+- Singular Value Decomposition (SVD)
+
+#### Non-Linear
+- Local Linear Embedding (LLE)
+- Laplacian Eigenmaps
+- t-Distributed Stochastic Neighbor Embedding (t-SNE)
+- Isomap
+- Autoencoders
+
+### Ensemble Learning Algorithms
+- Bagging Algorithm
+- Boosting Algorithm
+- Random Forest
+- AdaBoost
+- Gradient Boosting
+- Stacking
+- Voting Classifier
+- Bootstrap Aggregating
+
+## Prediction Topics
+
+### Discrete Prediction
+- Markov Decision Process (MDP)
+- Hidden Markov Models (HMM)
+- Grey Forecasting
+- Bayesian Networks
+- Difference Equations
+- Kalman Filtering
+- Particle Filtering
+
+### Continuous Prediction
+#### Time Series Models
+- Autoregressive Integrated Moving Average (ARIMA)
+- Generalized Autoregressive Conditional Heteroskedasticity (GARCH)
+- Exponential Smoothing (Holt-Winters)
+- Seasonal Decomposition of Time Series (STL)
+- Prophet Model
+
+#### Differential Equation Models
+- Ordinary Differential Equations (ODE)
+- Stochastic Differential Equations (SDE)
+- Infectious Disease Models (SIR, SEIR)
+- Population Growth Models
+- Lotka-Volterra Models
+- Heat Conduction Models
+- Predator-Prey Models
+- Diffusion Models (e.g., River Pollutant Diffusion)
+- Economic Growth Models
+- Battle Models (e.g., Lotka-Volterra Models)
+
+## Evaluation Topics
+
+### Scoring Evaluation
+- Fuzzy Comprehensive Evaluation
+- Grey Evaluation Method
+- Analytic Hierarchy Process (AHP)
+- Analytic Network Process (ANP)
+- Data Envelopment Analysis (DEA)
+- Technique for Order Preference by Similarity to Ideal Solution (TOPSIS)
+- Entropy Weight Method
+- Information Entropy Method
+- Weighted Sum Method
+- Weighted Product Method
+- Multi-Criteria Decision Analysis (MCDA)
+- PROMETHEE and GAIA
+
+### Statistical Evaluation
+#### Correlation Test
+- Pearson Correlation Coefficient
+- Spearman's Rank Correlation Coefficient
+- Kendall’s Tau Coefficient
+- Wilcoxon's Signed Rank Test
+- Kruskal-Wallis Test
+- Mann-Whitney U Test
+
+#### Goodness of Fit Test
+- Analysis of Variance (ANOVA)
+- Chi-Square Goodness-of-Fit Test
+- Kolmogorov-Smirnov Test (KS Test)
+- Anderson-Darling Test
+- Shapiro-Wilk Test
+- Jarque-Bera Test
+- Bayesian Information Criterion (BIC)
+"""

core/prompt/template.py

@@ -0,0 +1,1106 @@
+PROBLEM_PROMPT = """\
+Problem Background:
+{problem_background}
+
+Problem Requirement:
+{problem_requirement}
+{addendum}
+{data_summary}
+"""
+
+
+DATA_DESCRIPTION_PROMPT = """\
+Data Description:
+{data_description}
+
+---
+
+Your task is to generate a detailed summary of the dataset based on the dataset description provided. It needs to cover comprehensive information, but not explain each field one by one. Using plain text to describe in a single paragraph, without any Markdown formatting or syntax.
+"""
+
+
+PROBLEM_ANALYSIS_PROMPT = """\
+# Mathematical Modeling Problem:
+{modeling_problem}
+
+---
+
+You are tasked with analyzing a mathematical modeling problem with a focus on the underlying concepts, logical reasoning, and assumptions that inform the solution process. Begin by considering the nature of the problem in its broader context. What are the primary objectives of the model, and how do they shape the way you approach the task? Think critically about the assumptions that may be inherently embedded in the problem. What implicit beliefs or constraints have been set up, either explicitly or implicitly, within the problem’s description? Reflect on how these assumptions might influence the interpretation and application of any potential solutions. 
+
+Dive deeper into the relationships and interdependencies between the different components of the problem. What are the potential hidden complexities that may arise from these interconnections? Are there any conflicts or tensions between different aspects of the problem that need to be resolved? Explore how these interdependencies might lead to unforeseen challenges and require revisiting initial assumptions or redefining the parameters of the task. 
+
+Consider how the complexity of the problem may evolve across different scales or over time. Are there time-dependent factors or long-term consequences that should be accounted for, especially in terms of the stability or sustainability of the model’s outcomes? Think about how the model’s behavior might change under different scenarios, such as variations in input or changes in external conditions. Reflect on whether any simplifications or idealizations in the problem might inadvertently obscure key dynamics that are crucial for an accurate representation.
+
+In your analysis, also give attention to possible alternative perspectives on the problem. Are there different ways to frame the issue that could lead to distinct modeling approaches or solution strategies? How would those alternative perspectives impact the overall approach? Additionally, evaluate the potential risks or uncertainties inherent in the problem, especially when it comes to choosing between competing modeling approaches. Consider how the outcomes might vary depending on the choices you make in constructing the model, and how you would manage such trade-offs.
+
+Finally, reflect on the dynamic nature of the modeling process itself. How might your understanding of the problem evolve as you continue to explore its intricacies? Ensure that your thought process remains flexible, with a readiness to revise earlier conclusions as new insights emerge. The goal is to maintain a reflective, iterative analysis that adapts to deeper understandings of the task at hand, rather than pursuing a fixed or rigid approach.
+
+{user_prompt}
+
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text, without any Markdown formatting or syntax. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+"""
+
+
+PROBLEM_ANALYSIS_CRITIQUE_PROMPT = """\
+# Mathematical Modeling Problem:
+{modeling_problem}
+
+# Problem Analysis:
+{problem_analysis}
+
+---
+
+Critically examine the analysis results of the given mathematical modeling problem, focusing on the following aspects:
+
+1. Depth of Thinking: Evaluate whether the analysis demonstrates a comprehensive understanding of the underlying problem. Does it go beyond surface-level observations? Are the assumptions, limitations, and potential implications of the results carefully considered? Assess whether the analysis adequately addresses both the broader context and specific intricacies of the problem.
+2. Novelty of Perspective: Analyze the originality of the approach taken in the analysis. Does it introduce new insights or merely rehash well-established methods or solutions? Are alternative perspectives or unconventional techniques explored, or is the analysis constrained by a narrow set of assumptions or typical approaches?
+3. Critical Evaluation of Results: Consider the extent to which the analysis critically engages with the results. Are the conclusions drawn from the analysis well-supported by the mathematical findings, or do they overlook key uncertainties or counterexamples? Does the analysis acknowledge potential contradictions or ambiguities in the data?
+4. Rigor and Precision: Assess the level of rigor applied in the analysis. Are the steps logically consistent and mathematically sound, or are there overlooked errors, gaps, or assumptions that undermine the conclusions? Does the analysis exhibit a clear, methodical approach, or is it characterized by vague reasoning and imprecision?
+5. Contextual Awareness: Evaluate how well the analysis situates itself within the broader landscape of mathematical modeling in this area. Does it consider previous work or developments in the field? Is there any indication of awareness of real-world implications, practical constraints, or ethical concerns, if applicable?
+
+Critique the analysis without offering any constructive suggestions—your focus should solely be on highlighting weaknesses, gaps, and limitations within the approach and its execution.
+"""
+
+
+PROBLEM_ANALYSIS_IMPROVEMENT_PROMPT = """\
+# Mathematical Modeling Problem:
+{modeling_problem}
+
+# Problem Analysis:
+{problem_analysis}
+
+# Problem Analysis Critique:
+{problem_analysis_critique}
+
+---
+
+Refine and improve the existing problem analysis based on the critique provided to generate insightful analysis. 
+
+Provide the improved version directly. DO NOT mention any previous analysis content and deficiencies in the improved analysis. Just refer to the above critical suggestions and directly give the new improved analysis.
+{user_prompt}
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text, without any Markdown formatting or syntax. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+
+IMPROVED PROBLEM ANALYSIS:
+"""
+
+
+METHOD_CRITIQUE_PROMPT = """\
+## Problem Description
+
+{problem_description}
+
+## Method List
+
+{methods}
+
+## Evaluation Task
+
+Evaluate each method based on the following dimensions. For each dimension, consider the associated criteria and assign a score from 1 (poor) to 5 (excellent). 
+
+## Criteria Dimensions
+
+**1. Assumptions:** Whether the foundational mathematical assumptions align with the intrinsic characteristics of the problem.  
+For instance, linear regression assumes linear relationships but fails to capture nonlinear dynamics (e.g., exponential growth). Similarly, deterministic models (e.g., ordinary differential equations) may overlook critical uncertainties in inherently stochastic systems (e.g., financial markets or biological processes). Misaligned assumptions risk oversimplification or systematic bias.
+
+**2. Structure:** The mathematical framework’s ability to mirror the problem’s inherent logic, hierarchy, or spatiotemporal relationships.  
+Network-based problems (e.g., traffic flow or social interactions) demand graph theory or network flow models, while hierarchical systems (e.g., ecological food webs) may require multi-stage or layered modeling. A mismatch here—such as using static equations for time-dependent phenomena—renders the model structurally inadequate.
+
+**3. Variables:** Compatibility between the model’s mathematical tools and the variable types in the problem (continuous, discrete, categorical, stochastic, etc.).  
+For example, logistic regression or decision trees suit categorical outcomes, while partial differential equations better model spatially continuous systems. High-dimensional sparse data (e.g., genomics) may necessitate dimensionality reduction (PCA) or sparse optimization, whereas rigid variable handling leads to inefficiency or inaccuracy.
+
+**4. Dynamics:** Alignment of the model’s temporal or dynamic properties with the problem’s evolutionary behavior.  
+Short-term forecasting might use static models (e.g., linear regression), but long-term ecological or economic systems require dynamic frameworks (e.g., differential equations or agent-based models). Ignoring time delays (e.g., policy impacts in economics) or feedback loops often invalidates predictions.
+
+**5. Solvability:** The existence and practicality of solutions under real-world constraints.  
+High-dimensional non-convex optimization problems (e.g., neural network training) may rely on heuristic algorithms (genetic algorithms) rather than exact solutions. Similarly, NP-hard problems (e.g., traveling salesman) demand approximations to balance computational feasibility and precision. Overly complex models risk theoretical elegance without actionable results.
+
+## Instructions
+1. For each method in the Method List, score its performance on **all** evaluation dimensions.
+2. Return results in JSON format, including the method index and scores for each dimension.
+
+## Output Example (Only return the JSON output, no other text)
+```json
+{{
+  "methods": [
+    {{
+      "method_index": 1,
+      "scores": {{
+        "Assumptions": 4,
+        "Structure": 3,
+        // Include other dimensions here
+      }}
+    }},
+    // Include other methods here
+  ]
+}}
+```
+
+## Required Output
+Provide the JSON output below:
+```json
+"""
+
+
+PROBLEM_MODELING_PROMPT = """\
+# Reference Modeling Methods:
+{modeling_methods}
+
+# Mathematical Modeling Problem:
+{modeling_problem}
+
+# Problem Analysis:
+{problem_analysis}
+
+---
+
+You are tasked with designing an innovative mathematical model to address the given problem. Begin by proposing a comprehensive model that integrates both theoretical and practical considerations, ensuring that the formulation is aligned with the problem's core objectives. This should include a clear set of assumptions that underpin the model, which may involve simplifications, approximations, or idealizations necessary to make the problem tractable, yet still retain fidelity to the real-world phenomena you aim to represent. Clearly define the variables, parameters, and constraints that will shape the mathematical formulation. 
+
+Next, develop the key equations and relationships that will govern the model. Pay attention to the interdependencies between the various components of the system. These could involve differential equations, algebraic relations, optimization criteria, or probabilistic models, depending on the nature of the problem. Be sure to consider how different aspects of the model might interact, and whether feedback loops or non-linearities should be incorporated. Explore potential novel formulations or extensions of existing models that could offer new insights into the problem's dynamics. If applicable, propose advanced methods such as multi-scale modeling, agent-based simulations, or data-driven approaches like machine learning to improve the model’s adaptability or accuracy.
+
+Once the model structure is established, outline a clear strategy for solving it. This may involve analytical techniques such as closed-form solutions or approximations, numerical methods like finite element analysis or Monte Carlo simulations, or optimization algorithms for parameter estimation. Be explicit about the computational resources required and the level of precision expected. If the model is complex or high-dimensional, suggest ways to reduce the computational burden, such as dimensionality reduction, surrogate models, or parallelization techniques. 
+
+Additionally, consider how the model might evolve over time or under different conditions. Would the model require recalibration or adaptation in the face of changing circumstances? If applicable, provide strategies for sensitivity analysis to assess how the model responds to changes in its assumptions or parameters. Reflect on how the model’s predictions can be validated through empirical data or experimental results, ensuring that the model provides actionable insights and maintains real-world relevance.
+
+Finally, propose avenues for further refinement or extension of the model. As new data becomes available or the problem context shifts, what adjustments would you make to improve the model's accuracy or applicability? Explore the possibility of incorporating new dimensions into the model, such as incorporating uncertainty quantification, dynamic optimization, or considering long-term sustainability of the proposed solutions. The ultimate goal is to develop a robust, flexible, and innovative model that not only addresses the problem at hand but also offers deeper insights into its underlying complexities.
+
+{user_prompt}
+
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text, without any Markdown formatting or syntax. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+"""
+
+
+PROBLEM_MODELING_CRITIQUE_PROMPT = """\
+# Mathematical Modeling Problem:
+{modeling_problem}
+
+# Problem Analysis:
+{problem_analysis}
+
+# Modeling Solution:
+{modeling_solution}
+
+---
+
+Critically examine the analysis results of the given mathematical modeling solution, focusing on the following aspects:
+
+1. Problem Analysis and Understanding:
+- Clarity of the problem definition: Does the solution demonstrate a clear and comprehensive understanding of the problem? Are all relevant variables, constraints, and objectives identified and well-defined? If not, which aspects of the problem may have been misunderstood or overlooked?
+- Contextualization and framing: How well does the model account for the context in which the problem is situated? Are there any contextual factors that are essential but were not addressed?
+- Scope of the problem: Is the problem's scope appropriately defined? Does the model include all the necessary details, or are there significant components that were neglected or oversimplified?
+
+2. Model Development and Rigor:
+- Formulation of the mathematical model: How well is the model constructed mathematically? Does it align with established modeling practices in the relevant domain? Are the mathematical formulations—such as equations, algorithms, or optimization methods—correct and robust?
+- Modeling techniques: What modeling approaches or techniques were used (e.g., linear programming, system dynamics, statistical modeling, etc.)? Are they the most appropriate for the problem at hand? What alternative approaches could have been considered, and how might they impact the solution?
+- Validation and verification: Was the model tested for consistency and accuracy? Are there validation steps in place to ensure the model behaves as expected under a variety of conditions? What specific methods were used for this validation (e.g., cross-validation, sensitivity analysis, etc.)?
+
+3. Data and Results Analysis:
+- Data quality and relevance: Were there any significant issues with data availability or quality that could have influenced the model's results?
+- Interpretation of results: How well were the results analyzed and interpreted? Were the outcomes consistent with the problem's real-world implications? Are there any discrepancies between the model’s results and known empirical observations?
+- Sensitivity and robustness analysis: Did the model undergo a sensitivity analysis to determine how the results vary with changes in input parameters? Were the results robust across different assumptions, and if not, what are the implications for the solution's reliability?
+
+4. Assumptions and Limitations:
+- Explicit and implicit assumptions: What assumptions underlie the model, and are they clearly articulated? Are these assumptions reasonable, and how might they affect the model's predictions? Were any critical assumptions left implicit or unaddressed?
+- Limitations of the model: What limitations are inherent in the model, and how do they affect its validity and reliability? Are there elements of the problem that are inherently difficult or impossible to model with the chosen approach? Were simplifications made, and what are the trade-offs involved?
+- Model boundaries: Does the model appropriately define its boundaries, and are there any critical factors that lie outside the model’s scope but could significantly influence the results?
+
+5. Practicality and Applicability:
+- Real-world applicability: To what extent can the model be applied to real-world scenarios? 
+- Practical implementation: How would this model be implemented in practice? What would be the required infrastructure, and what challenges would need to be addressed during implementation? 
+
+Critique the analysis without offering any constructive suggestions—your focus should solely be on highlighting weaknesses, gaps, and limitations within the approach and its execution.
+"""
+
+
+PROBLEM_MODELING_IMPROVEMENT_PROMPT = """\
+# Mathematical Modeling Problem:
+{modeling_problem}
+
+# Problem Analysis:
+{problem_analysis}
+
+# Modeling Solution:
+{modeling_solution}
+
+# Modeling Solution Critique:
+{modeling_solution_critique}
+
+---
+
+Refine and improve the existing modeling solution based on the critique provided. The goal is to enhance the formulation, structure, and overall effectiveness of the model while addressing the identified gaps, flaws, or limitations. Propose more appropriate assumptions, more robust mathematical techniques, or alternative modeling approaches if necessary. Focus on improving the model's relevance, accuracy, and computational feasibility while also ensuring its ability to capture the complexity of the problem in real-world contexts.
+
+Provide a new version of the modeling solution that integrates these improvements directly. DO NOT mention any previous solution content and deficiencies.
+
+{user_prompt}
+
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text, without any Markdown formatting or syntax. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+
+IMPROVED MODELING SOLUTION: 
+"""
+
+
+DECOMPOSE_PRINCIPLE_PROMPT = """\
+The solution to a mathematical modeling problem is typically broken down into a series of subtasks, each addressing a different aspect of the overall challenge. Based on the examples provided below, summarize what each subtask in tasks 1 through {tasknum} generally involves, with a focus on the principles of task decomposition in mathematical modeling.
+
+<examples>
+
+{examples}
+
+</examples>
+
+Requirements:
+1. The summary should focus on the general methods and approaches used in mathematical modeling tasks, not tied to any specific examples or cases provided.
+2. The response should not include any details specific to the examples in order to avoid providing any implicit solutions or insights from them.
+3. The summary should present a theoretical description of the techniques used at each stage of task decomposition, without any reference to particular problems or contexts.
+4. Each subtask should be described as comprehensively and in as much detail as possible within a single paragraph, capturing the essential steps and considerations for that task in a general mathematical modeling framework. The description should be comprehensive, highlighting the key methodologies without resorting to bullet points, numbered lists, or overly formalized structure.
+5. Do not provide any form of examples or mention any instances.
+"""
+TASK_DECOMPOSE_WO_COO_PROMPT = """\
+# Mathematical Modeling Problem:
+{modeling_problem}
+
+---
+Please decompose the given modeling solution into {tasknum} distinct and well-defined subtasks that collectively contribute to the overall objective.
+{user_prompt}
+Each subtask should be described as comprehensively and in as much detail as possible within a single paragraph using plain text and seperated by '---' for each subtask.
+"""
+
+TASK_DECOMPOSE_PROMPT = """\
+# Decompose Principle:
+{decomposed_principle}
+
+# Mathematical Modeling Problem:
+{modeling_problem}
+
+# Problem Analysis:
+{problem_analysis}
+
+# Modeling Solution:
+{modeling_solution}
+
+---
+
+Please decompose the given modeling solution into {tasknum} distinct and well-defined subtasks that collectively contribute to the overall objective. These subtasks should be clearly separated in their focus, each addressing a specific aspect of the modeling process. The goal is to break down the solution into key stages or methodologies, ensuring that all components of the solution are covered without redundancy. For each subtask, the approach or technique should be explicitly described, detailing the specific data, algorithms, or models required. The decomposition should reflect a logical and comprehensive path toward completing the task, with each part having a clear purpose and contributing to the final result.
+{user_prompt}
+Each subtask should be described as comprehensively and in as much detail as possible within a single paragraph using plain text and seperated by '---' for each subtask. All the contents and details of the original solution need to be covered by the {tasknum} subtasks without omission. 
+"""
+
+TASK_DESCRIPTION_PROMPT = """\
+# Mathematical Modeling Problem:
+{modeling_problem}
+
+# Problem Analysis:
+{problem_analysis}
+
+# Modeling Solution:
+{modeling_solution}
+
+# Decomposed Subtasks:
+{decomposed_subtasks}
+
+---
+
+You are tasked with refining and improving the description of subtask {task_i} to ensure it is more detailed, clear, and focused. Provide a precise and comprehensive explanation of the task, specifically elaborating on its scope, goals, and methodology without venturing into other subtasks. Make sure the description includes clear and concise language that defines the necessary steps, techniques, or approaches required for this subtask. If applicable, specify the data inputs, tools, or models to be used, but do not introduce analysis, results, or discussions related to other components of the modeling process. The goal is to enhance the clarity, depth, and precision of this subtask description, ensuring it is fully understood on its own without needing further explanation.
+The description of subtask {task_i} should be as comprehensive and in as much detail as possible within a single paragraph using plain text.
+"""
+
+COO_PROMPT= "You are collaborating as part of a multi-agent system to solve a complex mathematical modeling problem. Each agent is responsible for a specific task, and some preprocessing or related tasks may have already been completed by other agents. It is crucial that you **do not repeat any steps that have already been addressed** by other agents. Instead, rely on their outputs when necessary and focus solely on the specific aspects of the task assigned to you."
+
+TASK_ANALYSIS_PROMPT = """\
+# Task Description:
+{task_description}
+
+---
+{prompt}
+{coo_prompt}
+Provide a thorough and nuanced analysis of the task at hand, drawing on the task description as the primary source of context. Begin by elucidating the core objectives and scope of the task, outlining its significance within the larger context of the project or research. Consider the potential impact or outcomes that are expected from the task, whether they relate to solving a specific problem, advancing knowledge, or achieving a particular practical application. Identify any challenges that may arise during the task execution, including technical, logistical, or theoretical constraints, and describe how these might influence the process or outcomes. In addition, carefully highlight any assumptions that are being made about the data, environment, or system involved in the task, and discuss any external factors that could shape the understanding or execution of the task. Ensure that the analysis is framed in a way that will guide future steps or inform the next stages of work.
+{user_prompt}
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text and LaTeX for formulas only, without any Markdown formatting or syntax. Written as one paragraph. Avoid structuring your answer in bullet points or numbered lists.
+"""
+
+TASK_FORMULAS_PROMPT = """\
+# Reference Modeling Methods:
+{modeling_methods}
+
+{data_summary}
+
+# Task Description:
+{task_description}
+
+# Task Analysis:
+{task_analysis}
+
+---
+{prompt}
+{coo_prompt}
+
+You are tasked with developing a set of precise, insightful, and comprehensive mathematical formulas that effectively model the problem described in the task. Begin by conducting an in-depth analysis of the system, process, or phenomenon outlined, identifying all relevant variables, their interdependencies, and the fundamental principles, laws, or constraints that govern the behavior of the system, as applicable in the relevant field. Clearly define all variables, constants, and parameters, and explicitly state any assumptions, approximations, or simplifications made during the formulation process, including any boundary conditions or initial conditions if necessary.
+
+Ensure the formulation considers the full scope of the problem, and if applicable, incorporate innovative mathematical techniques. Your approach should be well-suited for practical computational implementation, addressing potential numerical challenges, stability concerns, or limitations in simulations. Pay careful attention to the dimensional consistency and units of all terms to guarantee physical or conceptual validity, while remaining true to the theoretical foundations of the problem.
+
+In the process of deriving the mathematical models, provide a clear, step-by-step explanation of the reasoning behind each formula, highlighting the derivation of key expressions and discussing any assumptions or trade-offs that are made. Identify any potential sources of uncertainty, limitations, or approximations inherent in the model, and provide guidance on how to handle these within the modeling framework.
+
+The resulting equations should be both flexible and scalable, allowing for adaptation to different scenarios or the ability to be tested against experimental or real-world data. Strive to ensure that your model is not only rigorous but also interpretable, balancing complexity with practical applicability. List all modeling equations clearly in LaTeX format, ensuring proper mathematical notation and clarity of presentation. Aim for a model that is both theoretically sound and practically relevant, offering a balanced approach to complexity and tractability in its use.
+{user_prompt}
+Respond as comprehensively and in as much detail as possible, ensuring clarity, depth, and rigor throughout. Using plain text and LaTeX for formulas. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+"""
+
+
+TASK_FORMULAS_CRITIQUE_PROMPT = """\
+{data_summary}
+
+# Task Description:
+{task_description}
+
+# Task Analysis:
+{task_analysis}
+
+# Task Modeling Formulas:
+{modeling_formulas}
+
+---
+
+The goal of this task is to critically evaluate the modeling formulas used to represent a given mathematical modeling problem. Your analysis should address the following dimensions: accuracy and rigor, innovation and insight, and the applicability of the models to real-world scenarios.
+
+1. Accuracy and Rigor:
+
+- Formula Integrity:  
+  Evaluate whether the mathematical models and the corresponding formulas are mathematically sound and consistent with the underlying assumptions of the problem. Are the formulas properly derived, free from logical errors, and reflective of the relevant domain knowledge?  
+  - Are any simplifications or approximations made, and if so, are they justifiable within the context of the model's scope?
+  - Examine the assumptions made in formulating the model. Are these assumptions realistic, and how do they affect the model’s precision and robustness?
+
+2. Innovation and Insight:
+
+- Novelty of Approach:  
+  Critique the originality of the modeling approach. Does the model present a new or unconventional way of solving the problem, or does it simply rely on established methodologies without offering new insights?  
+  - Consider whether any innovative methods, such as the introduction of novel variables or the use of innovative computational techniques, contribute to improving the model.
+
+- Theoretical Insight:  
+  Evaluate the depth of the theoretical insights provided by the model. Does it offer a fresh perspective or new understanding of the problem? How well does it illuminate the key dynamics and relationships within the system under study?  
+  - Does the model reveal previously unnoticed phenomena, or does it suggest new directions for further research?
+
+- Integration of Existing Knowledge:  
+  Assess the extent to which the model integrates existing mathematical, theoretical, and empirical work. Does it build on prior research, and if so, does it do so in a way that adds substantial value or clarity? Are there gaps where additional cross-disciplinary knowledge could enhance the model?
+
+---
+
+3. Applicable:
+
+- Real-World Relevance:  
+  Evaluate the model’s practical applicability. How well does it apply to real-world problems, and to what extent does it provide actionable insights for decision-making or problem-solving in the field?  
+
+Critique the analysis without offering any constructive suggestions—your focus should solely be on highlighting weaknesses, gaps, and limitations within the formulas.
+"""
+
+
+TASK_FORMULAS_IMPROVEMENT_PROMPT = """\
+{data_summary}
+
+# Task Description:
+{task_description}
+
+# Task Analysis:
+{task_analysis}
+
+# Task Modeling Formulas:
+{modeling_formulas}
+
+# Task Modeling Formulas Critique:
+{modeling_formulas_critique}
+
+---
+
+Based on the provided critique and analysis, refine the existing modeling formulas to address the identified limitations and gaps. 
+
+Respond as comprehensively and in as much detail as possible, ensuring clarity, depth, and rigor throughout. Using plain text and LaTeX for formulas. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+{user_prompt}
+Provide a new version of the task modeling formulas that integrates these improvements directly. DO NOT mention any previous formulas content and deficiencies.
+
+IMPROVED TASK MODELING FORMULAS:
+"""
+
+
+# TASK_MODELING_PROMPT = """\
+# {data_summary}
+
+# # Task Description:
+# {task_description}
+
+# # Task Analysis:
+# {task_analysis}
+
+# # Task Modeling Formulas:
+# {modeling_formulas}
+
+# ---
+
+# You are tasked with designing an innovative and advanced mathematical model to address the given problem. Begin by proposing a comprehensive model that integrates both theoretical and practical considerations, ensuring that the formulation is aligned with the problem's core objectives. This should include a clear set of assumptions that underpin the model, which may involve simplifications, approximations, or idealizations necessary to make the problem tractable, yet still retain fidelity to the real-world phenomena you aim to represent. Clearly define the variables, parameters, and constraints that will shape the mathematical formulation. 
+
+# Next, develop the key equations and relationships that will govern the model. Pay attention to the interdependencies between the various components of the system. These could involve differential equations, algebraic relations, optimization criteria, or probabilistic models, depending on the nature of the problem. Be sure to consider how different aspects of the model might interact, and whether feedback loops or non-linearities should be incorporated. Explore potential novel formulations or extensions of existing models that could offer new insights into the problem's dynamics. If applicable, propose advanced methods such as multi-scale modeling, agent-based simulations, or data-driven approaches like machine learning to improve the model’s adaptability or accuracy.
+
+# Once the model structure is established, outline a clear strategy for solving it. This may involve analytical techniques such as closed-form solutions or approximations, numerical methods like finite element analysis or Monte Carlo simulations, or optimization algorithms for parameter estimation. Be explicit about the computational resources required and the level of precision expected. If the model is complex or high-dimensional, suggest ways to reduce the computational burden, such as dimensionality reduction, surrogate models, or parallelization techniques. 
+
+# Additionally, consider how the model might evolve over time or under different conditions. Would the model require recalibration or adaptation in the face of changing circumstances? If applicable, provide strategies for sensitivity analysis to assess how the model responds to changes in its assumptions or parameters. Reflect on how the model’s predictions can be validated through empirical data or experimental results, ensuring that the model provides actionable insights and maintains real-world relevance.
+
+# Finally, propose avenues for further refinement or extension of the model. As new data becomes available or the problem context shifts, what adjustments would you make to improve the model's accuracy or applicability? Explore the possibility of incorporating new dimensions into the model, such as incorporating uncertainty quantification, dynamic optimization, or considering long-term sustainability of the proposed solutions. The ultimate goal is to develop a robust, flexible, and innovative model that not only addresses the problem at hand but also offers deeper insights into its underlying complexities.
+
+# Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text, without any Markdown formatting or syntax. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+# """
+
+TASK_MODELING_PROMPT = """\
+{data_summary}
+
+# Task Description:
+{task_description}
+
+# Task Analysis:
+{task_analysis}
+
+# Task Modeling Formulas:
+{modeling_formulas}
+
+---
+{prompt}
+{coo_prompt}
+
+Please continue the modeling formula section by building upon the previous introduction to the formula. Provide comprehensive and detailed explanations and instructions that elaborate on each component of the formula. Describe the modeling process thoroughly, including the underlying assumptions, step-by-step derivations, and any necessary instructions for application. Expand on the formula by incorporating relevant mathematical expressions where appropriate, ensuring that each addition enhances the reader’s understanding of the model. Make sure to seamlessly integrate the new content with the existing section, maintaining a natural flow and avoiding any repetition or conflicts with previously covered material. Your continuation should offer a clear and in-depth exploration of the modeling formula, providing all necessary details to facilitate a complete and coherent understanding of the modeling process.
+{user_prompt}
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text, without any Markdown formatting or syntax. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+"""
+
+
+TASK_MODELING_CRITIQUE_PROMPT = """\
+{data_summary}
+
+# Task Description:
+{task_description}
+
+# Task Analysis:
+{task_analysis}
+
+# Task Modeling Formulas:
+{modeling_formulas}
+
+# Task Modeling Process:
+{modeling_process}
+
+---
+
+Critically examine the analysis results of the given mathematical modeling solution, focusing on the following aspects:
+
+1. Problem Analysis and Understanding:
+- Clarity of the problem definition: Does the solution demonstrate a clear and comprehensive understanding of the problem? Are all relevant variables, constraints, and objectives identified and well-defined? If not, which aspects of the problem may have been misunderstood or overlooked?
+- Contextualization and framing: How well does the model account for the context in which the problem is situated? Are there any contextual factors that are essential but were not addressed?
+- Scope of the problem: Is the problem's scope appropriately defined? Does the model include all the necessary details, or are there significant components that were neglected or oversimplified?
+
+2. Model Development and Rigor:
+- Formulation of the mathematical model: How well is the model constructed mathematically? Does it align with established modeling practices in the relevant domain? Are the mathematical formulations—such as equations, algorithms, or optimization methods—correct and robust?
+- Modeling techniques: What modeling approaches or techniques were used (e.g., linear programming, system dynamics, statistical modeling, etc.)? Are they the most appropriate for the problem at hand? What alternative approaches could have been considered, and how might they impact the solution?
+- Validation and verification: Was the model tested for consistency and accuracy? Are there validation steps in place to ensure the model behaves as expected under a variety of conditions? What specific methods were used for this validation (e.g., cross-validation, sensitivity analysis, etc.)?
+
+3. Data and Results Analysis:
+- Data quality and relevance: Were there any significant issues with data availability or quality that could have influenced the model's results?
+- Interpretation of results: How well were the results analyzed and interpreted? Were the outcomes consistent with the problem's real-world implications? Are there any discrepancies between the model’s results and known empirical observations?
+- Sensitivity and robustness analysis: Did the model undergo a sensitivity analysis to determine how the results vary with changes in input parameters? Were the results robust across different assumptions, and if not, what are the implications for the solution's reliability?
+
+4. Assumptions and Limitations:
+- Explicit and implicit assumptions: What assumptions underlie the model, and are they clearly articulated? Are these assumptions reasonable, and how might they affect the model's predictions? Were any critical assumptions left implicit or unaddressed?
+- Limitations of the model: What limitations are inherent in the model, and how do they affect its validity and reliability? Are there elements of the problem that are inherently difficult or impossible to model with the chosen approach? Were simplifications made, and what are the trade-offs involved?
+- Model boundaries: Does the model appropriately define its boundaries, and are there any critical factors that lie outside the model’s scope but could significantly influence the results?
+
+5. Practicality and Applicability:
+- Real-world applicability: To what extent can the model be applied to real-world scenarios? 
+- Practical implementation: How would this model be implemented in practice? What would be the required infrastructure, and what challenges would need to be addressed during implementation? 
+
+Critique the analysis without offering any constructive suggestions—your focus should solely be on highlighting weaknesses, gaps, and limitations within the approach and its execution.
+"""
+
+
+TASK_MODELING_IMPROVEMENT_PROMPT = """\
+{data_summary}
+
+# Task Description:
+{task_description}
+
+# Task Analysis:
+{task_analysis}
+
+# Task Modeling Formulas:
+{modeling_formulas}
+
+# Task Modeling Process:
+{modeling_process}
+
+# Task Modeling Process Critique:
+{modeling_process_critique}
+
+---
+
+Refine and improve the existing modeling process based on the critique provided. The goal is to enhance the formulation, structure, and overall effectiveness of the model while addressing the identified gaps, flaws, or limitations. Propose more appropriate assumptions, more robust mathematical techniques, or alternative modeling approaches if necessary. Focus on improving the model's relevance, accuracy, and computational feasibility while also ensuring its ability to capture the complexity of the problem in real-world contexts.
+
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text, without any Markdown formatting or syntax. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+{user_prompt}
+Provide a new version of the modeling process that integrates these improvements directly. DO NOT mention any previous process content and deficiencies.
+
+IMPROVED MODELING PROCESS:
+"""
+
+TASK_CODING_PROMPT = """\
+# Dataset Path:
+{data_file}
+
+# Data Description:
+{data_summary}
+
+# Variable Description:
+{variable_description}
+
+# Other files (Generated by Other Agents):
+{dependent_file_prompt}
+
+# Task Description:
+{task_description}
+
+# Task Analysis:
+{task_analysis}
+
+# Task Modeling Formulas:
+{modeling_formulas}
+
+# Task Modeling Process:
+{modeling_process}
+
+# Code Template:
+{code_template}
+
+---
+
+## Role & Collaboration:
+You are an expert programmer working as part of a multi-agent system. Your role is to implement the code based on the provided dataset (**refer to the Dataset Path, Dataset Description, and Variable Description**) **or preprocessed files generated by other agents** (**refer to "Other Files"**), along with the modeling process and given code template. Other agents will use your results to make decisions, but they will **not** review your code. Therefore, it is crucial that:
+1. **Ensure the code is executable** and will successfully run without errors, producing the expected results. **It should be tested to verify it works in the intended environment**.
+2. **Reuse files from "Other Files" whenever possible** instead of redoing tasks that have already been completed by other agents.
+3. **All data processing steps must save the processed results to local files (CSV, JSON, or pickle) for easy access by other agents.**
+4. **The output should be as detailed as possible**, including intermediate results and final outputs.
+5. **Ensure transparency** by logging key computation steps and providing clear outputs.
+
+## Implementation Guidelines:
+- **Prioritize using files from "Other Files" before processing raw data** to avoid redundant computation.
+- Follow the provided **modeling formulas** and **modeling process** precisely.
+- The **code must be executable**: ensure that the Python code you generate runs without errors. Do not just focus on producing the correct output format; **focus on producing a working solution** that can be executed successfully in a Python environment.
+- **Store intermediate and final data processing results to local** in appropriate formats (e.g., CSV, JSON, or pickle).
+- Provide **detailed print/logging outputs** to ensure that other agents can understand the results without needing to read the code.
+{user_prompt}
+
+## Expected Response Format:
+You **MUST** return the Python implementation in the following format:
+```python
+# Here is the Python code.
+"""
+
+TASK_CODING_WO_COO_PROMPT = """\
+# Dataset Path:
+{data_file}
+
+# Data Description:
+{data_summary}
+
+# Variable Description:
+{variable_description}
+
+# Task Description:
+{task_description}
+
+# Task Analysis:
+{task_analysis}
+
+# Task Modeling Formulas:
+{modeling_formulas}
+
+# Task Modeling Process:
+{modeling_process}
+
+# Code Template:
+{code_template}
+
+---
+
+## Role & Collaboration:
+You are an expert programmer. Your role is to implement the code based on the provided dataset (**refer to the Dataset Path, Dataset Description, and Variable Description**), along with the modeling process and given code template. It is crucial that:
+1. **Ensure the code is executable** and will successfully run without errors, producing the expected results. **It should be tested to verify it works in the intended environment**.
+2. **All data processing steps must save the processed results to local files (CSV, JSON, or pickle).**
+3. **The output should be as detailed as possible**, including intermediate results and final outputs.
+4. **Ensure transparency** by logging key computation steps and providing clear outputs.
+
+## Implementation Guidelines:
+- Follow the provided **modeling formulas** and **modeling process** precisely.
+- The **code must be executable**: ensure that the Python code you generate runs without errors. Do not just focus on producing the correct output format; **focus on producing a working solution** that can be executed successfully in a Python environment.
+- **Store intermediate and final data processing results to local** in appropriate formats (e.g., CSV, JSON, or pickle).
+- Provide **detailed print/logging outputs** to ensure that other people can understand the results without needing to read the code.
+{user_prompt}
+
+## Expected Response Format:
+You **MUST** return the Python implementation in the following format:
+```python
+# Here is the Python code.
+"""
+
+TASK_CODING_DEBUG_PROMPT = """\
+# Code Template:
+{code_template}
+
+# Modeling Process:
+{modeling_process}
+
+# Current Code:
+{code}
+
+However, there are some bugs in this version. Here is the execution result:
+# Execution Result:
+{observation}
+
+---
+
+You are a helpful programming expert. Based on the provided execution result, please revise the script to fix these bugs. Your task is to address the error indicated in the result, and refine or modify the code as needed to ensure it works correctly.
+{user_prompt}
+Please respond exactly in the following format:
+```python
+# Provide the corrected python code here.
+```
+"""
+
+
+TASK_RESULT_PROMPT = """\
+# Task Description:
+{task_description}
+
+# Task Analysis:
+{task_analysis}
+
+# Task Modeling Formulas:
+{task_formulas}
+
+# Task Modeling:
+{task_modeling}
+
+---
+
+Based on the task description, analysis, and modeling framework, present a comprehensive and detailed account of the intermediate results, calculations, and outcomes generated during the task. Clearly articulate the results of any simulations, experiments, or calculations, providing numerical values, data trends, or statistical measures as necessary. If visual representations such as graphs, charts, or tables were used to communicate the results, ensure they are clearly labeled and explained, highlighting their relevance to the overall task. Discuss the intermediate steps or processes that led to the results, including any transformations or assumptions made during calculations. If applicable, compare and contrast these results with expected outcomes or previously known results to gauge the task’s success. Provide a thoughtful interpretation of the findings, considering how they contribute to advancing understanding or solving the problem at hand, and highlight any areas where further investigation or refinement may be needed.
+{user_prompt}
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text and LaTeX for formulas only, without any Markdown formatting or syntax. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+"""
+
+TASK_RESULT_WITH_CODE_PROMPT = """\
+# Task Description:
+{task_description}
+
+# Task Analysis:
+{task_analysis}
+
+# Task Modeling Formulas:
+{task_formulas}
+
+# Task Modeling:
+{task_modeling}
+
+# Code Execution Result:
+{execution_result}
+
+---
+
+Based on the task description, analysis, modeling framework, and code execution result, present a comprehensive and detailed account of the intermediate results, calculations, and outcomes generated during the task. Clearly articulate the results of any computations or operations performed, providing numerical values, data trends, or statistical measures as necessary. If visual representations such as graphs, charts, or tables were used to communicate the results, ensure they are clearly labeled and explained, highlighting their relevance to the overall task. Discuss the intermediate steps or processes that led to the results, including any transformations or assumptions made during calculations. If applicable, compare and contrast these results with expected outcomes or previously known results to gauge the task’s success. Provide a thoughtful interpretation of the findings, considering how they contribute to advancing understanding or solving the problem at hand, and highlight any areas where further investigation or refinement may be needed.
+{user_prompt}
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text and LaTeX for formulas only, without any Markdown formatting or syntax. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+"""
+
+
+TASK_ANSWER_PROMPT = """\
+# Task Description:
+{task_description}
+
+# Task Analysis:
+{task_analysis}
+
+# Task Modeling Formulas:
+{task_formulas}
+
+# Task Modeling:
+{task_modeling}
+
+# Task Result:
+{task_result}
+
+---
+
+Craft a comprehensive and insightful answer section that synthesizes the findings presented in the results section to directly address the research questions and objectives outlined at the outset of the study. Begin by clearly stating the primary conclusions drawn from the analysis, ensuring that each conclusion is explicitly linked to specific aspects of the results. Discuss how these conclusions validate or challenge the initial hypotheses or theoretical expectations, providing a coherent narrative that illustrates the progression from data to insight.
+
+Evaluate the effectiveness and reliability of the mathematical models employed, highlighting strengths such as predictive accuracy, robustness, or computational efficiency. Address any limitations encountered during the modeling process, explaining how they may impact the validity of the conclusions and suggesting potential remedies or alternative approaches. Consider the sensitivity of the model to various parameters and the extent to which the results are generalizable to other contexts or applications.
+
+Analyze potential biases that may have influenced the results, including data bias, model bias, and computational bias. Discuss whether the dataset is representative of the problem space and whether any imbalances, selection biases, or sampling limitations might have affected the conclusions. Examine modeling assumptions, parameter choices, and architectural constraints that could introduce systematic deviations in the results. Assess how numerical precision, algorithmic approximations, or implementation details might influence the stability and fairness of the model’s predictions.
+
+Discuss strategies to mitigate identified biases and improve the reliability of the conclusions. Consider adjustments in data preprocessing, such as resampling, normalization, or augmentation, to address distribution imbalances. Explore refinements to the modeling process, including regularization techniques, fairness constraints, and sensitivity analyses, to ensure robustness across different scenarios. Evaluate the impact of alternative modeling approaches and discuss the extent to which the proposed methods can generalize beyond the given dataset or problem context.
+
+Explore the broader implications of the findings for the field of study, identifying how they contribute to existing knowledge, inform future research directions, or influence practical applications. Discuss any unexpected outcomes and their significance, offering interpretations that may reveal new avenues for exploration or theoretical development. Reflect on the societal, economic, or environmental relevance of the results, if applicable, and propose recommendations based on the study’s insights.
+
+Conclude the section by summarizing the key takeaways, emphasizing the contribution of the research to solving the problem at hand, and outlining the next steps for further investigation or implementation. Ensure that the discussion is logically structured, with each paragraph building upon the previous ones to form a cohesive and persuasive argument that underscores the study’s value and impact.
+
+The content of this Task Answer section should be distinct and not merely a repetition of the Task Result section. Ensure that there is no duplication.
+
+{user_prompt}
+
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text and LaTeX for formulas only, without any Markdown formatting or syntax. Written as one or more cohesive paragraphs. Avoid structuring your answer in bullet points or numbered lists.
+"""
+
+
+CREATE_CHART_PROMPT = """\
+## Instruction
+Create a highly detailed and comprehensive chart that effectively visualizes the complex mathematical relationships and insights presented in the provided mathematical modeling paper. Begin by selecting the most appropriate type of chart—such as a line graph, bar chart, scatter plot, heatmap, or 3D surface plot—based on the nature of the data and the specific relationships being analyzed. Clearly define the variables involved, including their units and scales, and incorporate any derived metrics that enhance interpretability. Ensure that the axes are labeled accurately and descriptively, with appropriate units and scales, whether linear or logarithmic, to best represent the data distribution and relationships. Include a clear and concise legend that distinguishes between different datasets or variables, using distinct colors or patterns that are both aesthetically pleasing and easily distinguishable. Utilize gridlines to aid in the accurate reading of values, and choose a color scheme that enhances readability while maintaining visual appeal.
+
+Emphasize the core purpose of the chart, whether it is to highlight trends over time, compare different values, show distributions, illustrate correlations, validate theoretical models, or support key arguments within the paper. Articulate the intended message of the chart clearly, ensuring that every design choice—from the type of chart to the specific visual elements used—aligns with the objectives of the mathematical modeling paper. Incorporate multiple lines or bars if comparing different datasets, use shading or contouring for density representation, and add error bars to indicate uncertainty where applicable. Include annotations to highlight significant data points, trends, or anomalies that are critical to the analysis, providing context and explanations that guide the viewer’s understanding.
+
+Balance aesthetics with functionality by selecting colors and contrasts that not only make the chart visually compelling but also enhance readability and comprehension. Avoid unnecessary complexity by keeping the design clean and focused, ensuring that the chart remains clear and easy to interpret without sacrificing accuracy or depth of information. If beneficial, incorporate supplementary visual aids such as trend lines, regression curves, or overlays of empirical and theoretical results to strengthen the analysis and provide additional layers of insight. The final chart should serve as a precise and compelling visualization that effectively conveys the mathematical insights, facilitates understanding, and robustly supports the overall narrative and conclusions of the mathematical modeling paper.
+
+{user_prompt}
+
+## Paper Content
+<paper>  
+{paper_content}  
+</paper>  
+
+## Existing Charts
+{existing_charts}  
+
+## Create a New Chart
+
+Please create a chart that aligns closely with the above paper content while avoiding redundancy with existing charts. Follow the markdown format below to describe your chart:  
+
+**Chart Title**  
+[Provide a clear and descriptive title for the chart]  
+
+**Chart Type**  
+[Specify the type of chart]  
+
+**Purpose**  
+[Describe the core purpose of the chart in a paragraph]  
+
+**Data or Variables**  
+[Describe the data or variables used in the chart in a paragraph]  
+
+**Chart Presentation Guidelines**  
+[A comprehensive guide on chart presentation, covering data representation, key layout elements, units, axis labels, legends, gridlines, annotations, and other essential considerations for effective visualization.]
+
+**Intended Message**  
+[Articulate the key message or insight the chart is intended to convey in a paragraph]
+"""
+
+
+
+PROBLEM_EXTRACT_PROMPT = """\
+You are tasked with extracting detailed and complete information from the following mathematical modeling question.  
+
+<MODELING_QUESTION>
+{question}
+</MODELING_QUESTION>
+
+### Extraction Requirements:  
+From the provided `<MODELING_QUESTION>`, extract and organize the following information as accurately and comprehensively as possible. Preserve the original text wherever applicable and do not omit any relevant details.  
+
+1. **"BACKGROUND"**: Extract all background information that provides context for the problem. This includes the problem’s domain, motivation, assumptions, or any other relevant introductory details.  
+2. **"TASK_REQUIREMENTS"**: A String to list all the requirements that need to be solved and satisfied, including specific instructions, constraints, objectives, and expected outputs.  
+3. **"DATA_FILES"**: A List to identify and list all dataset filenames mentioned in the question (if applicable). There may be multiple dataset files.  
+4. **"DATA_DESCRIPTIONS"**: Extract dataset descriptions, including details about the structure, features, variables, or metadata. If dataset descriptions are provided in a separate file, extract and list the filename instead.  
+5. **"ADDENDUM"**: Include any additional information that might be useful for solving the problem. This can include notes, references, clarifications, hints, or supplementary instructions.  
+
+### Expected Response Format:  
+Provide the extracted information in the following structured JSON format:  
+
+```json
+{{
+  "background": "",
+  "task_requirements": "",
+  "data_files": [],
+  "data_descriptions": "",
+  "addendum": ""
+}}
+```
+
+Ensure maximum fidelity to the original text and extract details as comprehensively as possible.
+"""
+
+
+
+TASK_DEPENDENCY_ANALYSIS_PROMPT = """\
+Understanding the dependencies among different tasks in a mathematical modeling process is crucial for ensuring a coherent, logically structured, and efficient solution. Given a mathematical modeling problem and its solution decomposition into {tasknum} subtasks, analyze the interdependencies among these subtasks.  
+
+## Input Information:
+- **Mathematical Modeling Problem:** {modeling_problem}
+- **Problem Analysis:** {problem_analysis}
+- **Modeling Solution:** {modeling_solution}
+- **Decomposed Tasks:** {task_descriptions}
+
+## Task Dependency Analysis Instructions:
+1. **Identify Task Dependencies:** For each task, determine which preceding tasks provide necessary input, data, or conditions for its execution. Clearly outline how earlier tasks influence or constrain later ones.
+2. **Describe Dependency Types:** Specify the nature of the dependencies between tasks. This includes:
+   - *Data Dependency:* When one task produces outputs that are required as inputs for another task.
+   - *Methodological Dependency:* When a later task builds upon a theoretical framework, assumptions, or models established by an earlier task.
+   - *Computational Dependency:* When a task requires prior computations or optimizations to be completed before proceeding.
+   - *Structural Dependency:* When a task is logically required to be completed before another due to hierarchical or sequential constraints.
+3. **Ensure Completeness:** Verify that all tasks in the decomposition are accounted for in the dependency analysis and that no essential dependencies are missing.
+
+## Output Format:  
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text, without any Markdown formatting or syntax. Written as {tasknum} cohesive paragraphs, each paragraph is a dependency analysis of a task.
+
+The response should be comprehensive and written in a clear, well-structured format without bullet points, ensuring a logical flow of dependency relationships and their implications.
+"""
+
+
+TASK_DEPENDENCY_ANALYSIS_WITH_CODE_PROMPT = """\
+Understanding the dependencies among different tasks in a mathematical modeling process is crucial for ensuring a coherent, logically structured, and efficient solution. Given a mathematical modeling problem and its solution decomposition into {tasknum} subtasks, analyze the interdependencies among these subtasks.  
+
+## Input Information:
+- **Mathematical Modeling Problem:** {modeling_problem}
+- **Problem Analysis:** {problem_analysis}
+- **Modeling Solution:** {modeling_solution}
+- **Decomposed Tasks:** {task_descriptions}
+
+## Task Dependency Analysis Instructions:
+1. **Identify Task Dependencies:** For each task, determine which preceding tasks provide necessary input, data, or conditions for its execution. Clearly outline how earlier tasks influence or constrain later ones.
+2. **Describe Dependency Types:** Specify the nature of the dependencies between tasks. This includes:
+   - *Data Dependency:* When one task produces outputs that are required as inputs for another task.
+   - *Methodological Dependency:* When a later task builds upon a theoretical framework, assumptions, or models established by an earlier task.
+   - *Computational Dependency:* When a task requires prior computations or optimizations to be completed before proceeding.
+   - *Structural Dependency:* When a task is logically required to be completed before another due to hierarchical or sequential constraints.
+   - *Code Dependency:* When one task relies on code structures, functions, or modules that are defined or executed in a preceding task. This includes shared variables, functions, or libraries that must be defined before their use in later tasks.
+3. **Ensure Completeness:** Verify that all tasks in the decomposition are accounted for in the dependency analysis and that no essential dependencies are missing.
+
+## Output Format:  
+Respond as comprehensively and in as much detail as possible. Do not format your response in Markdown. Using plain text, without any Markdown formatting or syntax. Written as {tasknum} cohesive paragraphs, each paragraph is a dependency analysis of a task.
+
+The response should be comprehensive and written in a clear, well-structured format without bullet points, ensuring a logical flow of dependency relationships and their implications.
+"""
+
+
+DAG_CONSTRUCTION_PROMPT = """\
+A well-structured Directed Acyclic Graph (DAG) is essential for visualizing and optimizing the dependencies between different tasks in a mathematical modeling process. Given a problem and its solution decomposition into {tasknum} subtasks, construct a DAG that accurately represents the dependency relationships among these tasks. The DAG should capture all necessary dependencies while ensuring that no cycles exist in the structure.  
+
+## Input Information:
+- **Mathematical Modeling Problem:** {modeling_problem}
+- **Problem Analysis:** {problem_analysis}
+- **Modeling Solution:** {modeling_solution}
+- **Decomposed Tasks:** {task_descriptions}
+- **Dependency Analysis:** {task_dependency_analysis}
+
+## Output Format (STRICT REQUIREMENT):
+You **MUST** return a valid JSON-formatted adjacency list **without** any additional text, explanations, or comments. **Only** output the JSON object.
+
+### JSON Format (Strictly Follow This Format):
+```json
+{{
+  "task_ID": [dependent_IDs],
+  ...
+}}
+
+## Example Output: 
+```json
+{{
+"1": []
+"2": ['1']
+"3": ['1']
+"4": ['2', '3']
+}}
+```
+"""
+
+# TASK_ANALYSIS_APPEND_PROMPT = """\
+# When analyzing the current task, please pay careful attention to its dependencies on other tasks. Ensure that you consider how the outputs or results from preceding tasks influence the execution and outcomes of this task. Identify any tasks that provide necessary inputs, data, or models, and explain how these dependencies shape the approach, methods, and overall execution of the task at hand. This analysis should be informed by the task dependency relationships, which will help clarify how the current task fits into the broader project or workflow. Keep in mind that the successful completion of this task may depend on the timely and correct completion of other tasks, and any delays or issues in the dependent tasks could impact the current task’s progress and outcomes.
+# """
+#             
+# TASK_FORMULAS_APPEND_PROMPT = """\
+# When formulating the mathematical model for the current task, it is essential to consider how this task depends on other tasks in the overall process. Be sure to analyze how the results, data, or models produced by preceding tasks influence the formulation of the current task. Identify any critical inputs or assumptions that come from earlier tasks and explain how these shape the approach, variables, or constraints in the mathematical formulation. In particular, pay attention to how the completion of dependent tasks impacts the accuracy, feasibility, or computational aspects of the model. This dependency analysis will help ensure that the model reflects the correct sequence of steps, and that any limitations or challenges arising from earlier tasks are properly accounted for. Ensure that the interdependencies between tasks are fully integrated into the mathematical formulation to maintain consistency and validity across the entire modeling process.
+# """
+# 
+# TASK_MODELING_APPEND_PROMPT = """\
+# Please continue the modeling process by considering the dependencies between the current task and the preceding tasks. Begin by analyzing how the outputs or models from earlier tasks influence the formulation and execution of the current task. Describe the interdependencies in detail, explaining how the results from previous tasks provide necessary data, constraints, or assumptions that affect the current task's modeling approach. Identify any key variables, parameters, or methods that are directly linked to earlier tasks and discuss how their incorporation into the current task ensures consistency and accuracy across the entire modeling framework. Additionally, consider any potential challenges or limitations introduced by the dependencies, such as delays or uncertainty in the results from prior tasks, and explain how these factors might be addressed in the modeling process. Ensure that these dependencies are clearly integrated into the continued modeling effort, providing a cohesive and comprehensive understanding of how the tasks interconnect and contribute to the overall solution.
+# """
+
+TASK_ANALYSIS_APPEND_PROMPT = """\
+When analyzing the current task, please pay careful attention to its dependencies on other tasks.
+"""
+            
+TASK_FORMULAS_APPEND_PROMPT = """\
+When formulating the mathematical model for the current task, it is essential to consider how this task depends on other tasks in the overall process.
+"""
+
+TASK_MODELING_APPEND_PROMPT = """\
+Please consider the dependencies between the current task and the preceding tasks.
+"""
+
+CODE_STRUCTURE_PROMPT = """\
+You are a programming expert. Please extract the structure from the following code and output it in the following JSON format, please return an empty list if the corresponding item is not available.:
+The code is:
+```python
+{code}
+```
+The output format is:
+```json
+{{
+    "script_path": {save_path}
+    "class": [
+    {{
+      "name": class name,
+      "description": description of class,
+      "class_functions": [
+        {{
+          "name": function name,
+          "description": description of class function,
+          "parameters": [
+            {{
+              "name": param name,
+              "type": param type,
+              "description": description of param,
+            }},
+            ...
+          ],
+          "returns": {{
+            "description": "return of the function."
+          }},
+        }}
+      ]
+    }}
+  ],
+  "function": [
+    {{
+      "name": function name,
+      "description": description of class function,
+      "parameters": [
+        {{
+          "name": param name,
+          "type": param type,
+          "description": description of param,
+        }},
+        ...
+      ],
+      "returns": {{
+        "description": "return of the function."
+      }},
+    }}
+  ],
+  "file_outputs": [
+    {{
+      "path": "file_path",
+      "file_description": "description of the file",
+      "column_name": ["column_name_if_csv_else_None"]
+    }},
+    ...
+  ]
+}}
+```
+"""
+
+
+PAPER_CHAPTER_PROMPT = """\
+You are tasked with creating a publication-quality LaTeX chapter for a mathematical modeling research paper. Carefully transform the provided structured draft into a coherent, rigorous, and concise narrative chapter that aligns logically and seamlessly with the previously written content.
+
+## Target Chapter:
+{chapter_path}
+
+## Structured Draft:
+<structured_draft>
+{json_context}
+</structured_draft>
+
+## Preceding Chapters (for seamless narrative integration and avoiding repetition):
+<preceding_content>
+{previous_chapters}
+</preceding_content>
+
+
+## Requirements:
+- Write exclusively in accurate, idiomatic LaTeX; avoid Markdown syntax and symbols entirely.
+- Clearly indicate the chapter content corresponds precisely to the target chapter `{chapter_path}`; do not repeat or reference explicitly the content of other chapters.
+- Integrate any mathematical formulas properly using correct LaTeX environments (`\\begin{{align}}`). Truncate and wrap long formulas and symbols.
+- Present the chapter as a continuous, fluent narrative without section headings, subsections, bullet points, or numbered lists, Response only chapter content, do not include headlines and anything else.
+- Critically evaluate the structured draft, selecting only most high-quality important and relevant content. Remove all redundancy, eliminate low-value statements, and distill essential information clearly and succinctly.
+- Maintain rigorous academic style, logical coherence, and clarity throughout, ensuring that the chapter integrates naturally with preceding chapters.
+
+## Output Format:
+```latex
+CHAPTER_CONTENT_TEXT
+```
+
+"""
+
+PAPER_CHAPTER_WITH_PRECEDING_PROMPT = """\
+You are tasked with generating a publication-quality LaTeX chapter for a mathematical modeling paper. Write a cohesive, academically rigorous chapter that integrates seamlessly with the preceding content of the paper.
+
+## Chapter to write: 
+{chapter_path}
+
+## Preceding Content: 
+<preceding_content>
+{previous_chapters}
+</preceding_content>
+
+## Writing Requirements:
+- Use accurate and proper LaTeX syntax throughout, avoid all Markdown syntax or symbols.
+- Present the content as a continuous, coherent narrative without using sections, subsections, or bullet points. Response only chapter content, do not include headlines and anything else.
+- Make it clear that the section you need to write is `{chapter_path}`. Do not involve the content of other chapters.
+"""
+
+PAPER_NOTATION_PROMPT = """
+You are an AI assistant trained to extract and typeset the Notations table from a mathematical modeling paper in LaTeX format. Your task is to take the input paper and output a properly formatted LaTeX table displaying the notations used in the paper. 
+
+1. Well-structured and easy to read.
+2. Properly typeset for LaTeX documents.
+3. Adaptive in size and position to fit neatly into any document.
+4. Truncate and wrap long formulas, symbols and text in the table for better readability.
+
+<paper>
+{previous_chapters}
+</paper>
+
+Exmple of Table Format:
+```latex
+\\begin{{table}}[H]
+    \\centering
+    \\renewcommand{{\\arraystretch}}{{1.3}}
+    \\begin{{tabular}}{{>{{\\raggedright\\arraybackslash}}p{{3cm}}>{{\\raggedright\\arraybackslash}}p{{11cm}}}}
+        \\toprule
+        \\textbf{{Notation}} & \\textbf{{Description}} \\\\
+        \\midrule
+        \\( f(x) \\) & description... \\\\
+        \\bottomrule
+    \\end{{tabular}}
+    \\caption{{Table of Notations}}
+    \\label{{tab:notations}}
+\\end{{table}}
+```
+
+Response only latex table content, do not include headlines and anything else.
+"""
+
+
+PAPER_INFO_PROMPT = """\
+You are an expert academic writer tasked with analyzing paper chapters and generating key metadata for a mathematical modeling paper.
+
+# Input Chapters
+{paper_chapters}
+
+Based on the content of these chapters, please generate:
+1. A concise, descriptive title that reflects the paper's main focus
+2. A comprehensive and detailed summary highlighting key findings and methodology
+3. 4-6 relevant keywords that capture the paper's main themes
+
+Returns the Legal JSON Format:
+```Json
+{{
+    "title": "A clear, concise title",
+    "summary": "A well-structured summary covering the following information: \n- Restatement and Clarification of the Problem: Describe the problem to be solved in your own words.\n- Explanation of Assumptions and Their Rationality: Highlight the assumptions made in the modeling process and clearly list all the variables required for the model.\n- Model Design and Rationality Argumentation: Specify the type of model used or describe the construction of a new model, explain how it was established and the rationale behind its design.\n- Description of Model Testing and Sensitivity Analysis: Include error analysis and other testing items.",
+    "keywords": "keyword1; keyword2; keyword3; keyword4..."
+}}
+```
+
+Requirements:
+- Title should be specific and academic in tone
+- Summary should follow standard academic abstract structure and be approximately 400 words
+- Keywords should be ordered from general to specific
+- must return a strictly legal JSON
+"""

core/run_batch.py

@@ -0,0 +1,221 @@
+from llm.llm import LLM
+from prompt.constants import modeling_methods
+from input.problem import problem_input
+# from input.test_middle_result import problem_str, problem_analysis, selected_models, modeling_solution, modeling_solution, task_descriptions
+from agent.problem_analysis import ProblemAnalysis
+from agent.method_ranking import MethodRanking
+from agent.problem_modeling import ProblemModeling
+from agent.task_decompse import TaskDecompose
+from agent.task import Task
+from agent.create_charts import Chart
+from agent.coordinator import Coordinator
+from utils.utils import read_json_file, write_json_file, write_text_file, json_to_markdown
+from prompt.template import TASK_ANALYSIS_APPEND_PROMPT, TASK_FORMULAS_APPEND_PROMPT, TASK_MODELING_APPEND_PROMPT
+# from utils.convert_format import markdown_to_latex
+import os
+from datetime import datetime
+import shutil
+import time
+
+
+def run_batch(problem_path, config, name, dataset_path, output_path):
+    # Initialize LLM
+    llm = LLM(config['model_name'])
+    
+    # Get problem input
+    problem_str, problem = problem_input(problem_path, llm)
+    problem_type = os.path.splitext(os.path.basename(problem_path))[0].split('_')[-1]
+    
+    # Initialize paper dictionary
+    paper = {'tasks': []}
+    paper['problem_background'] = problem['background']
+    paper['problem_requirement'] = problem['problem_requirement']
+
+    # Problem analysis
+    pa = ProblemAnalysis(llm)
+    problem_analysis = pa.analysis(problem_str, round=config['problem_analysis_round'])
+    paper['problem_analysis'] = problem_analysis
+    
+
+
+    modeling_methods = ""
+    # High level probelm understanding modeling
+    pm = ProblemModeling(llm)
+    modeling_solution = pm.modeling(problem_str, problem_analysis, modeling_methods, round=config['problem_modeling_round'])
+
+    # Task decomposition
+    td = TaskDecompose(llm)
+    task_descriptions = td.decompose_and_refine(problem_str, problem_analysis, modeling_solution, problem_type, config['tasknum'])
+
+    # Analyze dependency
+    with_code = len(problem['dataset_path']) > 0
+    coordinator = Coordinator(llm)
+    order = coordinator.analyze_dependencies(problem_str, problem_analysis, modeling_solution, task_descriptions, with_code)
+    order = [int(i) for i in order]
+
+    if with_code:
+        shutil.copytree(dataset_path, os.path.join(output_path,'code'), dirs_exist_ok=True)
+
+    # Process tasks
+    task = Task(llm)
+    mr = MethodRanking(llm)
+    chart = Chart(llm)
+    for id in order:
+        task_dependency = [int(i) for i in coordinator.DAG[str(id)]]
+        dependent_file_prompt = ""
+        if len(task_dependency) > 0:
+            dependency_prompt = f"""\
+This task is Task {id}, which depends on the following tasks: {task_dependency}. The dependencies for this task are analyzed as follows: {coordinator.task_dependency_analysis[id - 1]}
+"""
+            for task_id in task_dependency:
+                dependency_prompt += f"""\
+---
+# The Description of Task {task_id}:
+{coordinator.memory[str(task_id)]['task_description']}
+# The modeling method for Task {task_id}:
+{coordinator.memory[str(task_id)]['mathematical_modeling_process']}
+"""
+                if with_code:
+                    dependency_prompt += f"""\
+# The structure of code for Task {task_id}:
+{coordinator.code_memory[str(task_id)]}
+# The result for Task {task_id}:
+{coordinator.memory[str(task_id)]['solution_interpretation']}
+---
+"""
+                    dependent_file_prompt += f"""\
+# The files generated by code for Task {task_id}:
+{coordinator.code_memory[str(task_id)]}
+"""
+                    coordinator.code_memory[str(task_id)]['file_outputs']
+                else:
+                    dependency_prompt += f"""\
+# The result for Task {task_id}:
+{coordinator.memory[str(task_id)]['solution_interpretation']}
+---
+"""
+                
+            task_analysis_prompt = dependency_prompt + TASK_ANALYSIS_APPEND_PROMPT
+            task_formulas_prompt = dependency_prompt + TASK_FORMULAS_APPEND_PROMPT
+            task_modeling_prompt = dependency_prompt + TASK_MODELING_APPEND_PROMPT
+        else:
+            task_analysis_prompt = ""
+            task_formulas_prompt = ""
+            task_modeling_prompt = ""
+
+        code_template = open(os.path.join('data/actor_data/input/code_template','main{}.py'.format(id))).read()
+        save_path = os.path.join(output_path,'code/main{}.py'.format(id))
+        work_dir = os.path.join(output_path,'code')
+        script_name = 'main{}.py'.format(id)
+
+        task_description = task_descriptions[id - 1]
+        task_analysis = task.analysis(task_analysis_prompt, task_description)
+        description_and_analysis = f'## Task Description\n{task_description}\n\n## Task Analysis\n{task_analysis}'
+        top_modeling_methods = mr.top_methods(description_and_analysis, top_k=config['top_method_num'])
+
+        task_formulas = task.formulas(task_formulas_prompt, problem['data_description'], task_description, task_analysis, top_modeling_methods, round=config['task_formulas_round'])
+        task_modeling = task.modeling(task_modeling_prompt, problem['data_description'], task_description, task_analysis, task_formulas)
+        if with_code:
+            task_code, is_pass, execution_result = task.coding(problem['dataset_path'], problem['data_description'], problem['variable_description'], task_description, task_analysis, task_formulas, task_modeling, dependent_file_prompt, code_template, script_name, work_dir)
+            code_structure = task.extract_code_structure(id, task_code, save_path)
+            task_result = task.result(task_description, task_analysis, task_formulas, task_modeling, execution_result)
+            task_answer = task.answer(task_description, task_analysis, task_formulas, task_modeling, task_result)
+            task_dict = {
+                'task_description': task_description,
+                'task_analysis': task_analysis,
+                'preliminary_formulas': task_formulas,
+                'mathematical_modeling_process': task_modeling,
+                'task_code': task_code,
+                'is_pass': is_pass,
+                'execution_result': execution_result,
+                'solution_interpretation': task_result,
+                'subtask_outcome_analysis': task_answer
+            }
+            coordinator.code_memory[str(id)] = code_structure
+        else:
+            task_result = task.result(task_description, task_analysis, task_formulas, task_modeling)
+            task_answer = task.answer(task_description, task_analysis, task_formulas, task_modeling, task_result)
+            task_dict = {
+                'task_description': task_description,
+                'task_analysis': task_analysis,
+                'preliminary_formulas': task_formulas,
+                'mathematical_modeling_process': task_modeling,
+                'solution_interpretation': task_result,
+                'subtask_outcome_analysis': task_answer
+            }
+        coordinator.memory[str(id)] = task_dict
+        charts = chart.create_charts(str(task_dict), config['chart_num'])
+        task_dict['charts'] = charts
+        paper['tasks'].append(task_dict)
+        save_paper(paper, name, output_path)
+
+    print(paper)
+    print('Usage:', llm.get_total_usage())
+    write_json_file(f'{output_path}/usage/{name}.json', llm.get_total_usage())
+    return paper
+
+
+def save_paper(paper, name, path):
+    write_json_file(f'{path}/json/{name}.json', paper)
+    markdown_str = json_to_markdown(paper)
+    write_text_file(f'{path}/markdown/{name}.md', markdown_str)
+    # write_text_file(f'data/actor_data/output/latex/{name}.tex', markdown_to_latex(markdown_str))
+
+def mkdir(path):
+    os.mkdir(path)
+    os.mkdir(path + '/json')
+    os.mkdir(path + '/markdown')
+    os.mkdir(path + '/latex')
+    os.mkdir(path + '/code')
+    os.mkdir(path + '/usage')
+
+if __name__ == "__main__":
+    import glob
+    file_name_list = []
+    for year in range(2025, 2026):
+        if year == 2025:
+            letters = "CDEF"
+        else:
+            letters = "ABCDEF"
+ 
+        for letter in letters:
+            file_name_list.append(f'data/actor_data/input/problem/{year}_{letter}*')
+
+    files = []
+    for pattern in file_name_list:
+        files.extend(glob.glob(pattern))
+
+    config_list = [{
+        'top_method_num': 6,
+        'problem_analysis_round': 1,
+        'problem_modeling_round': 1,
+        'task_formulas_round': 1,
+        'tasknum': 4,
+        'chart_num': 3,
+        'model_name': 'gpt-4o',
+         "method_name": "MM-Agent-gpt-4o-v3-probelm-modleing"
+        # 'model_name': 'chatgpt-4o-latest'
+    }]
+
+    for i, config in enumerate(config_list, start=1):
+        for file in files:
+            try:
+                name = file.split('/')[-1].split('.')[0]
+                dataset_path = os.path.join('data/actor_data/input/dataset', file.split('/')[-1].split('.')[0])
+                output_dir = 'data/actor_data/exps/{}'.format(config["method_name"])
+                if not os.path.exists(output_dir):
+                    os.makedirs(output_dir)
+                output_path = os.path.join(output_dir, name + '_{}'.format(datetime.now().strftime('%Y%m%d-%H%M%S')))
+                if not os.path.exists(output_path):
+                    mkdir(output_path)
+                print(f'Processing {file}..., config: {config}')
+                start = time.time()
+                paper = run_batch(problem_path=file, config=config, name=name, dataset_path=dataset_path, output_path=output_path)
+                end = time.time()
+                with open(output_path + '/usage/runtime.txt', 'w') as f:
+                    f.write("{:.2f}s".format(end - start))
+                # save_paper(paper, name)
+            except Exception as e:
+                raise
+                print(f'Error: {e}')
+                continue

core/run_batch_wo_coo.py

@@ -0,0 +1,176 @@
+from llm.llm import LLM
+from prompt.constants import modeling_methods
+from input.problem import problem_input
+# from input.test_middle_result import problem_str, problem_analysis, selected_models, modeling_solution, modeling_solution, task_descriptions
+from agent.problem_analysis import ProblemAnalysis
+from agent.method_ranking import MethodRanking
+from agent.problem_modeling import ProblemModeling
+from agent.task_decompse import TaskDecompose
+from agent.task import Task
+from agent.create_charts import Chart
+from agent.coordinator import Coordinator
+from utils.utils import read_json_file, write_json_file, write_text_file, json_to_markdown
+from prompt.template import TASK_ANALYSIS_APPEND_PROMPT, TASK_FORMULAS_APPEND_PROMPT, TASK_MODELING_APPEND_PROMPT
+# from utils.convert_format import markdown_to_latex
+import os
+from datetime import datetime
+import shutil
+
+
+def run_batch(problem_path, config, name, dataset_path, output_path):
+    # Initialize LLM
+    llm = LLM(config['model_name'])
+    
+    # Get problem input
+    problem_str, problem = problem_input(problem_path, llm)
+    problem_type = ""
+    
+    # Initialize paper dictionary
+    paper = {'tasks': []}
+    paper['problem_background'] = problem['background']
+    paper['problem_requirement'] = problem['problem_requirement']
+
+    # Problem analysis
+    problem_analysis = ""
+    paper['problem_analysis'] = problem_analysis
+
+    # Problem modeling
+    modeling_solution = ""
+
+    # Task decomposition
+    td = TaskDecompose(llm, coo = False)
+    task_descriptions = td.decompose_and_refine(problem_str, problem_analysis, modeling_solution, problem_type, config['tasknum'])
+
+    # Analyze dependency
+    with_code = len(problem['dataset_path']) > 0
+
+    if with_code:
+        shutil.copytree(dataset_path, os.path.join(output_path,'code'), dirs_exist_ok=True)
+
+    # Process tasks
+    task = Task(llm, coo = False)
+    mr = MethodRanking(llm)
+    chart = Chart(llm)
+    for id in range(1, len(task_descriptions)+1):
+        code_template = open(os.path.join('data/actor_data/input/code_template','main{}.py'.format(id))).read()
+        work_dir = os.path.join(output_path,'code')
+        script_name = 'main{}.py'.format(id)
+
+        task_description = task_descriptions[id - 1]
+        task_analysis = task.analysis("", task_description)
+        description_and_analysis = f'## Task Description\n{task_description}\n\n## Task Analysis\n{task_analysis}'
+        top_modeling_methods = mr.top_methods(description_and_analysis, top_k=config['top_method_num'])
+
+        task_formulas = task.formulas("", problem['data_description'], task_description, task_analysis, top_modeling_methods, round=config['task_formulas_round'])
+        task_modeling = task.modeling("", problem['data_description'], task_description, task_analysis, task_formulas)
+        if with_code:
+            task_code, is_pass, execution_result = task.coding(problem['dataset_path'], problem['data_description'], problem['variable_description'], task_description, task_analysis, task_formulas, task_modeling, "", code_template, script_name, work_dir)
+            task_result = task.result(task_description, task_analysis, task_formulas, task_modeling, execution_result)
+            task_answer = task.answer(task_description, task_analysis, task_formulas, task_modeling, task_result)
+            task_dict = {
+                'task_description': task_description,
+                'task_analysis': task_analysis,
+                'preliminary_formulas': task_formulas,
+                'mathematical_modeling_process': task_modeling,
+                'task_code': task_code,
+                'is_pass': is_pass,
+                'execution_result': execution_result,
+                'solution_interpretation': task_result,
+                'subtask_outcome_analysis': task_answer
+            }
+        else:
+            task_result = task.result(task_description, task_analysis, task_formulas, task_modeling)
+            task_answer = task.answer(task_description, task_analysis, task_formulas, task_modeling, task_result)
+            task_dict = {
+                'task_description': task_description,
+                'task_analysis': task_analysis,
+                'preliminary_formulas': task_formulas,
+                'mathematical_modeling_process': task_modeling,
+                'solution_interpretation': task_result,
+                'subtask_outcome_analysis': task_answer
+            }
+        charts = chart.create_charts(str(task_dict), config['chart_num'])
+        task_dict['charts'] = charts
+        paper['tasks'].append(task_dict)
+        save_paper(paper, name, output_path)
+
+    print(paper)
+    print('Usage:', llm.get_total_usage())
+    write_json_file(f'{output_path}/usage/{name}.json', llm.get_total_usage())
+    return paper
+
+
+def save_paper(paper, name, path):
+    write_json_file(f'{path}/json/{name}.json', paper)
+    markdown_str = json_to_markdown(paper)
+    write_text_file(f'{path}/markdown/{name}.md', markdown_str)
+    # write_text_file(f'data/actor_data/output/latex/{name}.tex', markdown_to_latex(markdown_str))
+
+def mkdir(path):
+    os.mkdir(path)
+    os.mkdir(path + '/json')
+    os.mkdir(path + '/markdown')
+    os.mkdir(path + '/latex')
+    os.mkdir(path + '/code')
+    os.mkdir(path + '/usage')
+
+if __name__ == "__main__":
+    import glob
+    # files = glob.glob('data/actor_data/input/problem/2024*')
+    files = glob.glob('data/actor_data/input/problem/2024_C*')
+
+    # config_list = [{
+    #     'top_method_num': 6,
+    #     'problem_analysis_round': 1,
+    #     'problem_modeling_round': 1,
+    #     'task_formulas_round': 1,
+    #     'tasknum': 4,
+    #     'chart_num': 3,
+    #     'model_name': 'gpt-4'
+    #     # 'model_name': 'chatgpt-4o-latest'
+    # }, {
+    #     'top_method_num': 6,
+    #     'problem_analysis_round': 1,
+    #     'problem_modeling_round': 1,
+    #     'task_formulas_round': 1,
+    #     'tasknum': 4,
+    #     'chart_num': 3,
+    #     'model_name': 'deepseek-reasoner'
+    # }, {
+    #     'top_method_num': 6,
+    #     'problem_analysis_round': 1,
+    #     'problem_modeling_round': 1,
+    #     'task_formulas_round': 1,
+    #     'tasknum': 4,
+    #     'chart_num': 3,
+    #     'model_name': 'DeepSeek-R1-671B'
+    # }][0:]
+    config_list = [{
+        'top_method_num': 6,
+        'problem_analysis_round': 1,
+        'problem_modeling_round': 1,
+        'task_formulas_round': 1,
+        'tasknum': 4,
+        'chart_num': 3,
+        'model_name': 'gpt-4'
+    }][0:]
+
+
+    for i, config in enumerate(config_list, start=1):
+        for file in files:
+            try:
+                name = file.split('/')[-1].split('.')[0] + '_wo_coo'
+                dataset_path = os.path.join('data/actor_data/input/dataset', file.split('/')[-1].split('.')[0])
+                output_dir = 'data/actor_data/output'
+                if not os.path.exists(output_dir):
+                    os.makedirs(output_dir)
+                output_path = os.path.join(output_dir, name + '_{}'.format(datetime.now().strftime('%Y%m%d-%H%M%S')))
+                if not os.path.exists(output_path):
+                    mkdir(output_path)
+                print(f'Processing {file}..., config: {config}')
+                paper = run_batch(problem_path=file, config=config, name=name, dataset_path=dataset_path, output_path=output_path)
+                # save_paper(paper, name)
+            except Exception as e:
+                raise
+                print(f'Error: {e}')
+                continue

core/run_batch_wo_rag.py

@@ -0,0 +1,225 @@
+from llm.llm import LLM
+from prompt.constants import modeling_methods
+from input.problem import problem_input
+# from input.test_middle_result import problem_str, problem_analysis, selected_models, modeling_solution, modeling_solution, task_descriptions
+from agent.problem_analysis import ProblemAnalysis
+from agent.method_ranking import MethodRanking
+from agent.problem_modeling import ProblemModeling
+from agent.task_decompse import TaskDecompose
+from agent.task import Task
+from agent.create_charts import Chart
+from agent.coordinator import Coordinator
+from utils.utils import read_json_file, write_json_file, write_text_file, json_to_markdown
+from prompt.template import TASK_ANALYSIS_APPEND_PROMPT, TASK_FORMULAS_APPEND_PROMPT, TASK_MODELING_APPEND_PROMPT
+# from utils.convert_format import markdown_to_latex
+import os
+from datetime import datetime
+import shutil
+
+
+def run_batch(problem_path, config, name, dataset_path, output_path):
+    # Initialize LLM
+    llm = LLM(config['model_name'])
+    
+    # Get problem input
+    problem_str, problem = problem_input(problem_path, llm)
+    problem_type = os.path.splitext(os.path.basename(problem_path))[0].split('_')[-1]
+    
+    # Initialize paper dictionary
+    paper = {'tasks': []}
+    paper['problem_background'] = problem['background']
+    paper['problem_requirement'] = problem['problem_requirement']
+
+    # Problem analysis
+    pa = ProblemAnalysis(llm)
+    problem_analysis = pa.analysis(problem_str, round=config['problem_analysis_round'])
+    paper['problem_analysis'] = problem_analysis
+
+    # Problem modeling
+    pm = ProblemModeling(llm)
+    modeling_solution = pm.modeling(problem_str, problem_analysis, modeling_methods, round=config['problem_modeling_round'])
+
+    # Task decomposition
+    td = TaskDecompose(llm)
+    task_descriptions = td.decompose_and_refine(problem_str, problem_analysis, modeling_solution, problem_type, config['tasknum'])
+
+    # Analyze dependency
+    with_code = len(problem['dataset_path']) > 0
+    coordinator = Coordinator(llm)
+    order = coordinator.analyze_dependencies(problem_str, problem_analysis, modeling_solution, task_descriptions, with_code)
+    order = [int(i) for i in order]
+
+    if with_code:
+        shutil.copytree(dataset_path, os.path.join(output_path,'code'), dirs_exist_ok=True)
+
+    # Process tasks
+    task = Task(llm, rag=False)
+    chart = Chart(llm)
+    for id in order:
+        task_dependency = [int(i) for i in coordinator.DAG[str(id)]]
+        dependent_file_prompt = ""
+        if len(task_dependency) > 0:
+            dependency_prompt = f"""\
+This task is Task {id}, which depends on the following tasks: {task_dependency}. The dependencies for this task are analyzed as follows: {coordinator.task_dependency_analysis[id - 1]}
+"""
+            for task_id in task_dependency:
+                dependency_prompt += f"""\
+---
+# The Description of Task {task_id}:
+{coordinator.memory[str(task_id)]['task_description']}
+# The modeling method for Task {task_id}:
+{coordinator.memory[str(task_id)]['mathematical_modeling_process']}
+"""
+                if with_code:
+                    dependency_prompt += f"""\
+# The structure of code for Task {task_id}:
+{coordinator.code_memory[str(task_id)]}
+# The result for Task {task_id}:
+{coordinator.memory[str(task_id)]['solution_interpretation']}
+---
+"""
+                    dependent_file_prompt += f"""\
+# The files generated by code for Task {task_id}:
+{coordinator.code_memory[str(task_id)]}
+"""
+                    coordinator.code_memory[str(task_id)]['file_outputs']
+                else:
+                    dependency_prompt += f"""\
+# The result for Task {task_id}:
+{coordinator.memory[str(task_id)]['solution_interpretation']}
+---
+"""
+                
+            task_analysis_prompt = dependency_prompt + TASK_ANALYSIS_APPEND_PROMPT
+            task_formulas_prompt = dependency_prompt + TASK_FORMULAS_APPEND_PROMPT
+            task_modeling_prompt = dependency_prompt + TASK_MODELING_APPEND_PROMPT
+        else:
+            task_analysis_prompt = ""
+            task_formulas_prompt = ""
+            task_modeling_prompt = ""
+
+        code_template = open(os.path.join('data/actor_data/input/code_template','main{}.py'.format(id))).read()
+        save_path = os.path.join(output_path,'code/main{}.py'.format(id))
+        work_dir = os.path.join(output_path,'code')
+        script_name = 'main{}.py'.format(id)
+
+        task_description = task_descriptions[id - 1]
+        task_analysis = task.analysis(task_analysis_prompt, task_description)
+        top_modeling_methods = ""
+
+        task_formulas = task.formulas(task_formulas_prompt, problem['data_description'], task_description, task_analysis, top_modeling_methods, round=config['task_formulas_round'])
+        task_modeling = task.modeling(task_modeling_prompt, problem['data_description'], task_description, task_analysis, task_formulas)
+        if with_code:
+            task_code, is_pass, execution_result = task.coding(problem['dataset_path'], problem['data_description'], problem['variable_description'], task_description, task_analysis, task_formulas, task_modeling, dependent_file_prompt, code_template, script_name, work_dir)
+            code_structure = task.extract_code_structure(id, task_code, save_path)
+            task_result = task.result(task_description, task_analysis, task_formulas, task_modeling, execution_result)
+            task_answer = task.answer(task_description, task_analysis, task_formulas, task_modeling, task_result)
+            task_dict = {
+                'task_description': task_description,
+                'task_analysis': task_analysis,
+                'preliminary_formulas': task_formulas,
+                'mathematical_modeling_process': task_modeling,
+                'task_code': task_code,
+                'is_pass': is_pass,
+                'execution_result': execution_result,
+                'solution_interpretation': task_result,
+                'subtask_outcome_analysis': task_answer
+            }
+            coordinator.code_memory[str(id)] = code_structure
+        else:
+            task_result = task.result(task_description, task_analysis, task_formulas, task_modeling)
+            task_answer = task.answer(task_description, task_analysis, task_formulas, task_modeling, task_result)
+            task_dict = {
+                'task_description': task_description,
+                'task_analysis': task_analysis,
+                'preliminary_formulas': task_formulas,
+                'mathematical_modeling_process': task_modeling,
+                'solution_interpretation': task_result,
+                'subtask_outcome_analysis': task_answer
+            }
+        coordinator.memory[str(id)] = task_dict
+        charts = chart.create_charts(str(task_dict), config['chart_num'])
+        task_dict['charts'] = charts
+        paper['tasks'].append(task_dict)
+        save_paper(paper, name, output_path)
+
+    print(paper)
+    print('Usage:', llm.get_total_usage())
+    write_json_file(f'{output_path}/usage/{name}.json', llm.get_total_usage())
+    return paper
+
+
+def save_paper(paper, name, path):
+    write_json_file(f'{path}/json/{name}.json', paper)
+    markdown_str = json_to_markdown(paper)
+    write_text_file(f'{path}/markdown/{name}.md', markdown_str)
+    # write_text_file(f'data/actor_data/output/latex/{name}.tex', markdown_to_latex(markdown_str))
+
+def mkdir(path):
+    os.mkdir(path)
+    os.mkdir(path + '/json')
+    os.mkdir(path + '/markdown')
+    os.mkdir(path + '/latex')
+    os.mkdir(path + '/code')
+    os.mkdir(path + '/usage')
+
+if __name__ == "__main__":
+    import glob
+    # files = glob.glob('data/actor_data/input/problem/2024*')
+    files = glob.glob('data/actor_data/input/problem/2024_C*')
+
+    # config_list = [{
+    #     'top_method_num': 6,
+    #     'problem_analysis_round': 1,
+    #     'problem_modeling_round': 1,
+    #     'task_formulas_round': 1,
+    #     'tasknum': 4,
+    #     'chart_num': 3,
+    #     'model_name': 'gpt-4'
+    #     # 'model_name': 'chatgpt-4o-latest'
+    # }, {
+    #     'top_method_num': 6,
+    #     'problem_analysis_round': 1,
+    #     'problem_modeling_round': 1,
+    #     'task_formulas_round': 1,
+    #     'tasknum': 4,
+    #     'chart_num': 3,
+    #     'model_name': 'deepseek-reasoner'
+    # }, {
+    #     'top_method_num': 6,
+    #     'problem_analysis_round': 1,
+    #     'problem_modeling_round': 1,
+    #     'task_formulas_round': 1,
+    #     'tasknum': 4,
+    #     'chart_num': 3,
+    #     'model_name': 'DeepSeek-R1-671B'
+    # }][0:]
+    config_list = [{
+        'top_method_num': 6,
+        'problem_analysis_round': 1,
+        'problem_modeling_round': 1,
+        'task_formulas_round': 1,
+        'tasknum': 4,
+        'chart_num': 3,
+        'model_name': 'gpt-4'
+    }][0:]
+
+
+    for i, config in enumerate(config_list, start=1):
+        for file in files:
+            try:
+                name = file.split('/')[-1].split('.')[0] + '_wo_rag'
+                dataset_path = os.path.join('data/actor_data/input/dataset', file.split('/')[-1].split('.')[0])
+                output_dir = 'data/actor_data/output'
+                if not os.path.exists(output_dir):
+                    os.makedirs(output_dir)
+                output_path = os.path.join(output_dir, name + '_{}'.format(datetime.now().strftime('%Y%m%d-%H%M%S')))
+                if not os.path.exists(output_path):
+                    mkdir(output_path)
+                print(f'Processing {file}..., config: {config}')
+                paper = run_batch(problem_path=file, config=config, name=name, dataset_path=dataset_path, output_path=output_path)
+                # save_paper(paper, name)
+            except Exception as e:
+                raise
+                print(f'Error: {e}')
+                continue

core/test.py

@@ -0,0 +1,56 @@
+from llm.llm import LLM
+from input.problem import problem_input
+from input.test_middle_result import problem_str, selected_models, modeling_solution, task_descriptions
+from agent.model_selection import ModelSelection
+from agent.modeling import Modeling
+from agent.task_decompse import TaskDecompose
+from agent.task import Task
+from utils.utils import write_json_file, write_markdown_file, json_to_markdown
+
+
+if __name__ == "__main__":
+    llm = LLM('deepseek-chat')
+    paper = {'tasks': []}
+    
+    problem_path = 'data/actor_data/input/problem/2024_C.json'
+    problem_str, problem = problem_input(problem_path, llm)
+    # print(problem_str)
+    # print('---')
+    paper['problem_background'] = problem['background']
+    paper['problem_requirement'] = problem['problem_requirement']
+
+    ms = ModelSelection(llm)
+    selected_models = ms.select_models(problem_str)
+    print(selected_models)
+    print('---')
+
+    mm = Modeling(llm)
+    modeling_solution = mm.modeling(problem_str, selected_models)
+    print(modeling_solution)
+    print('---')
+
+    td = TaskDecompose(llm)
+    task_descriptions = td.decompose(problem_str, modeling_solution)
+    print(task_descriptions)
+    print('---')
+
+    task = Task(llm)
+    for task_description in task_descriptions[:]:
+        task_analysis = task.analysis(task_description)
+        task_modeling = task.modeling(task_description, task_analysis, problem['data_summary'])
+        task_result = task.result(task_description, task_analysis, task_modeling)
+        task_answer = task.answer(task_description, task_analysis, task_modeling, task_result)
+        paper['tasks'].append({
+            'task_description': task_description,
+            'task_analysis': task_analysis,
+            'mathematical_modeling_process': task_modeling,
+            'result': task_result,
+            'answer': task_answer
+        })
+    print(paper)
+
+    print(llm.get_total_usage())
+
+    write_json_file('data/actor_data/output/paper4.json', paper)
+    write_markdown_file('data/actor_data/output/paper4.md', json_to_markdown(paper))
+

core/test2.py

@@ -0,0 +1,59 @@
+from llm.llm import LLM
+from input.problem import problem_input
+from input.test_middle_result import problem_str, problem_analysis, selected_models, modeling_solution, modeling_solution, task_descriptions
+from agent.problem_analysis import ProblemAnalysis
+from agent.problem_modeling import ProblemModeling
+from agent.task_decompse import TaskDecompose
+from agent.task import Task
+from utils.utils import read_json_file, write_json_file, write_markdown_file, json_to_markdown
+
+
+if __name__ == "__main__":
+    # llm = LLM('deepseek-chat')
+    llm = LLM('deepseek-reasoner')
+    # llm = LLM('gpt-4o')
+    paper = {'tasks': []}
+    
+    problem_path = 'data/actor_data/input/problem/2024_C.json'
+    problem_str, problem = problem_input(problem_path, llm)
+    problem_type = problem_path.split('/')[-1].split('_')[-1].split('.')[0] # 'C'
+    tasknum = 4
+
+    print(problem_str)
+    print('---')
+    paper['problem_background'] = problem['background']
+    paper['problem_requirement'] = problem['problem_requirement']
+
+    # pa = ProblemAnalysis(llm)
+    # problem_analysis = pa.analysis(problem_str, round=1)
+    # print(problem_analysis)
+    # print('---')
+
+    # pm = ProblemModeling(llm)
+    # modeling_solution = pm.modeling(problem_str, problem_analysis, round=1)
+    # print(modeling_solution)
+    # print('---')
+
+    # td = TaskDecompose(llm)
+    # task_descriptions = td.decompose_and_refine(problem_str, problem_analysis, modeling_solution, problem_type, tasknum)
+    # print(task_descriptions)
+    # print('---')
+
+    task = Task(llm)
+    for task_description in task_descriptions[:1]:
+        task_analysis = task.analysis(task_description)
+        task_formulas = task.formulas(problem['data_description'], task_description, task_analysis)
+        task_modeling = task.modeling(problem['data_description'], task_description, task_analysis, task_formulas)
+        task_result = task.result(task_description, task_analysis, task_formulas, task_modeling)
+        task_answer = task.answer(task_description, task_analysis, task_formulas, task_modeling, task_result)
+        paper['tasks'].append({
+            'task_description': task_description,
+            'task_analysis': task_analysis,
+            'mathematical_formulas': task_formulas,
+            'mathematical_modeling_process': task_modeling,
+            'result': task_result,
+            'answer': task_answer
+        })
+    print(paper['tasks'])
+
+    print(llm.get_total_usage())

core/utils/convert_format.py

@@ -0,0 +1,104 @@
+import json
+import re
+import pypandoc
+
+# A sample Markdown string
+markdown_text = """
+# My Document
+
+Some **bold** text here, and some *italic* text there.
+
+- Bullet point 1
+- Bullet point 2
+"""
+
+
+def markdown_to_latex(markdown_text):
+    # Convert Markdown string to LaTeX
+    latex_text = pypandoc.convert_text(markdown_text, to='latex', format='md')
+    return latex_text
+
+
+def markdown_to_json_method(markdown_text):
+    # 初始化根节点和层级堆栈，初始层级设为 0，以便支持一级标题
+    root = {"method_class": "root", "children": []}
+    stack = [{"node": root, "level": 0}]  # 用堆栈跟踪层级关系
+    
+    lines = markdown_text.strip().split('\n')
+    i = 0
+    
+    while i < len(lines):
+        line = lines[i].strip()
+        i += 1
+        
+        if not line:
+            continue
+        
+        # 匹配标题
+        if line.startswith('#'):
+            match = re.match(r'^(#+)\s*(.*?)$', line)
+            if not match:
+                continue
+            hashes, method_class = match.groups()
+            current_level = len(hashes)
+            
+            # 创建新节点
+            new_node = {"method_class": method_class, "children": [], "description": ""}
+            
+            # 寻找合适的父节点
+            while stack and stack[-1]["level"] >= current_level:
+                stack.pop()
+            
+            # 如果没有找到合适的父节点，则将 new_node 加入到 root 下
+            if stack:
+                parent = stack[-1]["node"]
+            else:
+                parent = root
+            parent["children"].append(new_node)
+            
+            # 更新堆栈
+            stack.append({"node": new_node, "level": current_level})
+            
+            # 查找紧随标题后的描述文本
+            description_lines = []
+            while i < len(lines) and lines[i].strip() and not lines[i].strip().startswith('#') and not lines[i].strip().startswith('-'):
+                description_lines.append(lines[i].strip())
+                i += 1
+            
+            if description_lines:
+                new_node["description"] = " ".join(description_lines)
+            
+            # 回退一行，因为下一行可能是列表项或新标题
+            if i < len(lines):
+                i -= 1
+        
+        # 匹配列表项
+        elif line.startswith('-'):
+            item = {}
+            if ': ' in line:
+                method, description = line[1:].strip().split(': ', 1)
+                description = description
+                item = {"method": method.strip(), "description": description.strip()}
+            else:
+                item = {"method": line[1:].strip(), "description": ""}
+            
+            # 添加到当前层级的子节点；若无标题节点，则直接添加到 root
+            if stack:
+                current_node = stack[-1]["node"]
+                current_node.setdefault("children", []).append(item)
+            else:
+                root.setdefault("children", []).append(item)
+    
+    # 返回所有解析到的顶级标题节点
+    return root["children"]
+
+
+if __name__ == "__main__":
+    with open("../data/actor_data/docs/method_en_v1.md", "r", encoding="utf-8") as f:
+        markdown_text = f.read()
+
+    result = markdown_to_json_method(markdown_text)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+    # AIzaSyCfcnYh7jBDnjP7kex7HEj4rpUpHRxvM_0

core/utils/decompose_analysis.py

@@ -0,0 +1,93 @@
+import random
+from llm.llm import LLM
+from collections import Counter, defaultdict
+from prompt.template import DECOMPOSE_PRINCIPLE_PROMPT
+
+from utils.utils import read_json_file, write_json_file
+
+
+def read_problem_papers(problem_name):
+    paper_dict = read_json_file('../data/paper_info_dataset.json')['data']
+    papers = []
+    for paper in paper_dict:
+        if paper['paper'].startswith(problem_name):
+            papers.append(paper['info'])
+    return papers
+
+
+def generate_decompose_prompt(data):
+    # llm = LLM('deepseek-reasoner')
+    llm = LLM('chatgpt-4o-latest')
+    # Step 1: Filter papers from 2015 and later
+    filtered_papers = [paper for paper in data if paper['paper'].split('/')[0] >= '2014']
+
+    # Step 2: Group by type (A, B, C, D, E, F)
+    problem_papers = defaultdict(list)
+
+    # Loop through the filtered papers and organize by problem type
+    for paper in filtered_papers:
+        problem = paper['paper'].split('/')[0]
+        problem_papers[problem].append(paper['info'])
+    
+    # keep 2 papers for each problem:
+    for problem, papers in problem_papers.items():
+        if len(papers) > 3:
+            problem_papers[problem] = random.sample(papers, 3)
+        else:
+            problem_papers[problem] = papers
+
+    # Step 3: Group papers by problem type (second part of the problem identifier)
+    problem_type_papers = defaultdict(list)
+    for problem, papers in problem_papers.items():
+        problem_type = problem.split('_')[1]
+        problem_type_papers[problem_type] += papers
+    
+    # Step 4: Group by tasknum (problem_type, len(tasks))
+    tasknum_papers = defaultdict(list)
+    for problem_type, papers in problem_type_papers.items():
+        for paper in papers:
+            tasknum_papers[(problem_type, len(paper['tasks']))].append(paper)
+    
+    filtered_tasknum_papers = tasknum_papers
+
+    # # Step 5: Calculate the top 2 frequent tasknum for each problem_type
+    # filtered_tasknum_papers = defaultdict(list)
+    # for problem_type, papers in problem_type_papers.items():
+    #     # Count the frequencies of tasknum within this problem_type
+    #     tasknum_counts = Counter(len(paper['tasks']) for paper in papers)
+    #     # Get the two most frequent tasknums
+    #     most_common_tasknums = [tasknum for tasknum, _ in tasknum_counts.most_common(3)]
+    #     print(problem_type, most_common_tasknums)
+    #     # Keep only the papers with the top 2 frequent tasknums
+    #     for paper in papers:
+    #         if len(paper['tasks']) in most_common_tasknums:
+    #             filtered_tasknum_papers[(problem_type, len(paper['tasks']))].append(paper)
+
+    result = defaultdict(dict)
+    for (problem_type, tasknum), papers in filtered_tasknum_papers.items():
+        if tasknum not in [3, 4, 5] or problem_type not in ['A', 'B', 'C', 'D', 'E', 'F']:
+            continue
+        # if tasknum not in [4] or problem_type not in ['C']:
+        #     continue
+        print(f"Problem Type: {problem_type}, Task Number: {tasknum}, size: {len(papers)}")
+        selected_papers = random.sample(papers, min(len(papers), 6))
+        examples = '---'.join(([task_decompose(paper) for paper in selected_papers]))
+        prompt = DECOMPOSE_PRINCIPLE_PROMPT.format(examples=examples, tasknum=tasknum)
+        answer = llm.generate(prompt)
+        result[problem_type][int(tasknum)] = answer
+
+    return result
+
+
+def task_decompose(paper):
+    return '\n'.join([f"- Subtask {i}: {task['task_description'][:]}" for i, task in enumerate(paper['tasks'], start=1)])
+
+
+if __name__ == "__main__":
+    data = read_json_file('../data/actor_data/input/paper_info_dataset.json')
+    result = generate_decompose_prompt(data['data'])
+    write_json_file('../data/actor_data/input/decompose_prompt.json', result)
+
+
+
+

core/utils/embedding.py

@@ -0,0 +1,77 @@
+from typing import List
+import numpy as np
+import torch
+import torch.nn.functional as F
+from transformers import AutoModel, AutoTokenizer
+
+class EmbeddingScorer:
+    """
+    A class for performing semantic search using embeddings.
+    Uses the gte-multilingual-base model from Alibaba-NLP.
+    """
+    
+    def __init__(self, model_name='Alibaba-NLP/gte-multilingual-base'):
+        """
+        Initialize the EmbeddingScorer with the specified model.
+        
+        Args:
+            model_name (str): Name of the model to use.
+        """
+        # Load the tokenizer and model
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name, trust_remote_code=True)
+        self.dimension = 768  # The output dimension of the embedding
+    
+    def score_method(self, query: str, methods: List[dict]) -> List[dict]:
+        """
+        Calculate similarity between a query and a list of methods.
+        
+        Args:
+            query (str): The query sentence.
+            methods (list): List of method dictionaries to compare against the query.
+            
+        Returns:
+            list: List of similarity scores between the query and each method.
+        """
+        # Prepare sentences
+        sentences = [f"{method['method']}: {method.get('description', '')}" for method in methods]
+        texts = [query] + sentences
+        
+        # Tokenize the input texts
+        batch_dict = self.tokenizer(texts, max_length=8192, padding=True, truncation=True, return_tensors='pt')
+        
+        # Get embeddings
+        with torch.no_grad():
+            outputs = self.model(**batch_dict)
+            
+        # Get embeddings from the last hidden state
+        embeddings = outputs.last_hidden_state[:, 0][:self.dimension]
+        
+        # Normalize embeddings
+        embeddings = F.normalize(embeddings, p=2, dim=1)
+        
+        # Calculate similarities
+        query_embedding = embeddings[0].unsqueeze(0)  # Shape: [1, dimension]
+        method_embeddings = embeddings[1:]  # Shape: [num_methods, dimension]
+        
+        # Calculate cosine similarities (scaled by 100 as in the example)
+        similarities = (query_embedding @ method_embeddings.T) * 100
+        similarities = similarities.squeeze().tolist()
+        
+        # If only one method, similarities will be a scalar
+        if not isinstance(similarities, list):
+            similarities = [similarities]
+        
+        # Format results
+        result = []
+        for i, similarity in enumerate(similarities, start=1):
+            result.append({
+                "method_index": i,
+                "score": float(similarity)
+            })
+        
+        return result
+
+if __name__ == "__main__":
+    es = EmbeddingScorer()
+    print(es.score_method("How to solve the problem of the user", [{"method": "Method 1", "description": "Description 1"}, {"method": "Method 2", "description": "Description 2"}]))

core/utils/generate_paper.py

@@ -0,0 +1,736 @@
+"""
+Academic Paper Generator
+
+Generates academic papers in LaTeX format from structured JSON data using
+language models to create content for each section.
+"""
+
+import json
+import subprocess
+import os
+import re
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass
+
+# Import statements would be here in a real application
+from prompt.template import PAPER_CHAPTER_PROMPT, PAPER_CHAPTER_WITH_PRECEDING_PROMPT, PAPER_INFO_PROMPT, PAPER_NOTATION_PROMPT
+from llm.llm import LLM
+from utils.utils import parse_llm_output_to_json
+
+# --------------------------------
+# Data Models
+# --------------------------------
+
+@dataclass
+class Chapter:
+    """Represents a chapter in the paper with its hierarchical structure and content."""
+    path: List[str]  # Hierarchical path (e.g., ["Problem Analysis", "Task 1 Analysis"])
+    content: str = ""
+    title: str = ""
+    is_generated: bool = False
+    needs_content: bool = False
+    
+    @property
+    def path_string(self) -> str:
+        """Returns the full path as a string (e.g., 'Problem Analysis > Task 1 Analysis')"""
+        return " > ".join(self.path)
+    
+    @property
+    def depth(self) -> int:
+        """Returns the heading level (depth in hierarchy)"""
+        return len(self.path)
+    
+    @property
+    def display_title(self) -> str:
+        """Returns the chapter title to display (custom title or last path element)"""
+        return self.title if self.title else self.path[-1]
+
+# --------------------------------
+# Language Model Interface
+# --------------------------------
+
+def escape_underscores_in_quotes(text):
+    pattern = r'(".*?")|(\'.*?\')'
+    def replace_underscores(match):
+        content = match.group(0)[1:-1]
+        escaped_content = content.replace('_', r'\_')
+        return f'"{escaped_content}"' if match.group(0).startswith('"') else f"'{escaped_content}'"
+    
+    result = re.sub(pattern, replace_underscores, text, flags=re.DOTALL)
+    return result
+
+
+class ContentGenerator:
+    """Interface for generating content using language models"""
+    
+    def __init__(self, llm):
+        self.llm = llm
+    
+    def generate_chapter_content(self, prompt: str) -> Dict[str, str]:
+        """Generate chapter content using the language model"""
+        response = self.llm.generate(prompt)
+        response = escape_underscores_in_quotes(response)
+        response = response.replace("```latex", "").replace("```", "")
+        # return self._parse_latex_response(response)
+        return response
+    
+    def _parse_latex_response(self, latex_string: str) -> Dict[str, str]:
+        """Parse LLM response from LaTeX format"""
+        pattern = r"```latex\s*\\chapter{\s*(.*?)\s*}\s*(.*)```"
+        match = re.match(pattern, latex_string.strip(), re.DOTALL)
+        
+        if match:
+            return {
+                "title": match.group(1).strip(),
+                "content": match.group(2).strip()
+            }
+        
+        # Fallback if format doesn't match
+        return {
+            "title": "",
+            "content": latex_string
+        }
+
+# --------------------------------
+# Paper Structure
+# --------------------------------
+
+class OutlineGenerator:
+    """Creates the hierarchical structure of the paper"""
+    
+    def create_outline(self, task_count: int) -> List[Chapter]:
+        """Create a complete chapter structure based on number of tasks"""
+        print(f"Creating paper outline for {task_count} tasks")
+        
+        # Define the structure template
+        outline = self._create_base_outline(task_count)
+        
+        # Create chapter objects
+        chapters = []
+        for path in outline:
+            # A chapter needs content if it's a leaf node (has no children)
+            needs_content = not any(other[:len(path)] == path and len(other) > len(path) 
+                                   for other in outline)
+            chapters.append(Chapter(path=path, needs_content=needs_content))
+        
+        content_chapters = sum(1 for c in chapters if c.needs_content)
+        print(f"Created {len(chapters)} sections, {content_chapters} require content generation")
+        for chapter in chapters:
+            print(chapter.path_string)
+        return chapters
+    
+    def _create_base_outline(self, task_count: int) -> List[List[str]]:
+        """Define the hierarchical structure of the paper"""
+        # Define the template structure
+        outline = [
+            ["Problem Restatement", "Problem Background"],
+            ["Problem Restatement", "Problem Statement"],
+            ["Model Assumptions"],
+            ["Explanation of Assumptions"],
+            ["Problem Analysis"]
+        ]
+        
+        # Add task-specific analysis chapters
+        for i in range(1, task_count + 1):
+            outline.append(["Problem Analysis", f"Task {i} Analysis"])
+        
+        outline.append(["Solution to the Problem"])
+        
+        # Add task-specific solution chapters
+        for i in range(1, task_count + 1):
+            outline.append(["Solution to the Problem", f"Task {i} Solution", "Model Setup: Assumptions and Chain Models"])
+            outline.append(["Solution to the Problem", f"Task {i} Solution", "Model Calculation"])
+        
+        # Add conclusion and reference sections
+        outline.extend([
+            ["Model Conclusion", "Model Advantages"],
+            ["Model Conclusion", "Model Limitations"],
+            ["Notation and Explanations"]  
+        ])
+        
+        return outline
+
+    def generate_chapter_relevance_map(self, task_count: int) -> Dict[str, List[str]]:
+        """
+        Dynamically generate chapter relevance mapping based on the number of tasks.
+        
+        Args:
+            task_count: Number of tasks in the paper
+            
+        Returns:
+            Dictionary mapping chapter paths to lists of related chapter paths
+        """
+        relevance_map = {}
+
+        for i in range(1, task_count + 1):
+            setup_path = f"Solution to the Problem > Task {i} Solution > Model Setup: Assumptions and Chain Models"
+            relevance_map[setup_path] = [f"Problem Analysis > Task {i} Analysis"]
+
+        for i in range(1, task_count + 1):
+            calculation_path = f"Solution to the Problem > Task {i} Solution > Model Calculation"
+            relevance_map[calculation_path] = [
+                f"Problem Analysis > Task {i} Analysis",
+                f"Solution to the Problem > Task {i} Solution > Model Setup: Assumptions and Chain Models",
+            ]
+        
+        # Model conclusion chapters should include all task solutions
+        task_solutions = []
+        for i in range(1, task_count + 1):
+            task_solutions += [
+                f"Solution to the Problem > Task {i} Solution > Model Calculation",
+                f"Solution to the Problem > Task {i} Solution > Model Setup: Assumptions and Chain Models"
+            ]
+        
+        relevance_map["Model Conclusion > Model Advantages"] = task_solutions.copy()
+        relevance_map["Model Conclusion > Model Limitations"] = task_solutions.copy()
+        relevance_map["Notation and Explanations"] = task_solutions.copy()
+        
+        return relevance_map
+
+
+# --------------------------------
+# Context Extraction
+# --------------------------------
+
+class ContextExtractor:
+    """Extracts relevant data from JSON for each chapter"""
+    
+    def get_context_for_chapter(self, chapter: Chapter, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Extract relevant JSON data for a specific chapter"""
+        path = chapter.path
+        
+        # Handle different chapter types
+        if path == ["Problem Restatement", "Problem Background"]:
+            return {"problem_background": data.get("problem_background", "")}
+            
+        elif path == ["Problem Restatement", "Problem Statement"]:
+            return {"problem_requirement": data.get("problem_requirement", "")}
+            
+        elif path == ["Model Assumptions"]:
+            return self._get_assumptions_context(data)
+    
+        elif path == ["Explanation of Assumptions"]:
+            return {}
+            
+        elif self._is_task_analysis(path):
+            return self._get_task_analysis_context(path, data)
+            
+        elif self._is_model_setup(path):
+            return self._get_model_setup_context(path, data)
+            
+        elif self._is_model_calculation(path):
+            return self._get_model_calculation_context(path, data)
+            
+        # Default empty context for other sections
+        return {}
+    
+    def _get_assumptions_context(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Get context for assumptions sections"""
+        context = {"problem_analysis": data.get("problem_analysis", "")}
+        
+        # Extract task modeling information
+        keys = ['task_description', 'task_analysis', 'mathematical_modeling_process']
+        context["tasks"] = [
+            {k: v for k, v in task.items() if k in keys}
+            for task in data['tasks']
+        ]
+        
+        return context
+    
+    def _get_task_analysis_context(self, path: List[str], data: Dict[str, Any]) -> Dict[str, Any]:
+        """Get context for task analysis sections"""
+        task_num = self._extract_task_number(path[1])
+        if not self._is_valid_task_index(task_num, data):
+            return {}
+            
+        task_data = data["tasks"][task_num]
+        keys = ['task_analysis', 'task_description']
+        return {
+            f'task_{task_num+1}': {
+                k: v for k, v in task_data.items() if k in keys
+            }
+        }
+    
+    def _get_model_setup_context(self, path: List[str], data: Dict[str, Any]) -> Dict[str, Any]:
+        """Get context for model setup sections"""
+        task_num = self._extract_task_number(path[1])
+        if not self._is_valid_task_index(task_num, data):
+            return {}
+            
+        task_data = data["tasks"][task_num]
+        keys = ['preliminary_formulas', 'mathematical_modeling_process']
+        return {
+            f'task_{task_num+1}': {
+                k: task_data.get(k, "") for k in keys
+            }
+        }
+    
+    def _get_model_calculation_context(self, path: List[str], data: Dict[str, Any]) -> Dict[str, Any]:
+        """Get context for model calculation sections"""
+        task_num = self._extract_task_number(path[1])
+        if not self._is_valid_task_index(task_num, data):
+            return {}
+            
+        task_data = data["tasks"][task_num]
+        keys = ['mathematical_modeling_process', 'execution_result', 'solution_interpretation', 'subtask_outcome_analysis']
+        return {
+            f'task_{task_num+1}': {
+                k: task_data.get(k, "") for k in keys
+            }
+        }
+    
+    def _is_task_analysis(self, path: List[str]) -> bool:
+        """Check if path is a task analysis section"""
+        return (len(path) == 2 and 
+                path[0] == "Problem Analysis" and 
+                path[1].startswith("Task "))
+    
+    def _is_model_setup(self, path: List[str]) -> bool:
+        """Check if path is a model setup section"""
+        return (len(path) == 3 and 
+                path[0] == "Solution to the Problem" and 
+                path[1].startswith("Task ") and 
+                path[2] == "Model Setup: Assumptions and Chain Models")
+    
+    def _is_model_calculation(self, path: List[str]) -> bool:
+        """Check if path is a model calculation section"""
+        return (len(path) == 3 and 
+                path[0] == "Solution to the Problem" and 
+                path[1].startswith("Task ") and 
+                path[2] == "Model Calculation")
+    
+    def _extract_task_number(self, task_string: str) -> int:
+        """Extract task number from strings like 'Task 1 Analysis'"""
+        try:
+            return int(task_string.split()[1]) - 1  # Convert to 0-indexed
+        except (IndexError, ValueError):
+            return -1
+    
+    def _is_valid_task_index(self, index: int, data: Dict[str, Any]) -> bool:
+        """Check if the task index is valid"""
+        return 0 <= index < len(data.get("tasks", []))
+
+# --------------------------------
+# Prompt Creation
+# --------------------------------
+
+class PromptCreator:
+    """Creates prompts for the language model"""
+    
+    def __init__(self):
+        pass
+    
+    def create_prompt(self, 
+                     chapter: Chapter, 
+                     context: Dict[str, Any], 
+                     previous_chapters: List[Chapter]) -> str:
+        """Create a prompt for generating chapter content"""
+        # Format JSON context
+        json_str = json.dumps(context, indent=2)
+        
+        # Format previous chapters
+        previous_text = self._format_previous_chapters(previous_chapters)
+        
+        if chapter.path == ["Notation and Explanations"]:
+            return PAPER_NOTATION_PROMPT.format(
+                previous_chapters=previous_text,
+            )
+        else:
+            if json_str == '{}':
+                return PAPER_CHAPTER_WITH_PRECEDING_PROMPT.format(
+                    chapter_path=chapter.path_string,
+                    previous_chapters=previous_text
+                )
+            else:
+                # Build the prompt using the template
+                return PAPER_CHAPTER_PROMPT.format(
+                    chapter_path=chapter.path_string,
+                    json_context=json_str,
+                    previous_chapters=previous_text
+                )
+    
+    def _format_previous_chapters(self, previous_chapters: List[Chapter]) -> str:
+        """Format previously completed chapters for context"""
+        if not previous_chapters:
+            return ""
+            
+        text = ""
+        for chapter in previous_chapters:
+            text += f"Chapter: {chapter.path_string}\n"
+            # text += f"Title: {chapter.display_title}\n"
+            text += f"{chapter.content}\n\n"
+        return text
+
+
+# --------------------------------
+# Document Assembly
+# --------------------------------
+
+class LatexDocumentAssembler:
+    """Assembles the final LaTeX document from generated chapters"""
+    
+    def create_document(self, chapters: List[Chapter], metadata: Dict[str, Any]) -> str:
+        """Create a complete LaTeX document"""
+        # Reorder chapters (move Notation chapter after Explanation of Assumptions)
+        ordered_chapters = self._reorder_chapters(chapters)
+        
+        # Build document parts
+        document_parts = [
+            self._create_preamble(metadata),
+            self._create_abstract(metadata),
+            "\\maketitle",
+            "\\renewcommand\\cfttoctitlefont{\\hfil\\Large\\bfseries}",
+            "\\tableofcontents",
+            "\\newpage",
+            self._create_body(ordered_chapters, metadata),
+            "\\end{document}"
+        ]
+        
+        return "\n\n".join(document_parts)
+    
+    def _reorder_chapters(self, chapters: List[Chapter]) -> List[Chapter]:
+        """Reorder chapters for better document structure"""
+        reordered = []
+        notation_chapter = next((ch for ch in chapters if ch.path == ["Notation and Explanations"]), None)
+        
+        for chapter in chapters:
+            if chapter.path != ["Notation and Explanations"]:
+                reordered.append(chapter)
+                # Insert notation chapter after Explanation of Assumptions
+                if notation_chapter and chapter.path == ["Explanation of Assumptions"]:
+                    reordered.append(notation_chapter)
+                    
+        return reordered
+    
+    def _add_figure(self, figures: List[str]) -> str:
+        """Add a figure to the content"""
+        figure_str = []
+        for i, figure_path in enumerate(figures):
+            name = figure_path.split('/')[-1].split('.')[0].replace('_', '\\_')
+            figure_str.append(f"""
+\\begin{{figure}}[H]
+\\centering
+\\includegraphics[width=0.5\\textwidth]{{{figure_path}}}
+\\caption{{{name}}}
+\\end{{figure}}
+""")
+        return figure_str
+
+
+    def _add_code(self, codes: List[str]) -> str:
+        """
+\subsection*{Python Code}
+\subsubsection*{main1.py}
+
+\begin{lstlisting}[language=Python, frame=single, basicstyle=\ttfamily\small]
+def main1():
+    pass
+\end{lstlisting}
+        """
+        code_str = [
+            "\\clearpage",
+            "\\section{Appendix}",
+        ]
+        for i, code_path in enumerate(codes):
+            with open(code_path, 'r') as f:
+                code = f.read()
+            name = code_path.split('/')[-1].replace('_', '\\_')
+            code_str.append(f"""
+\\subsubsection*{{{name}}}
+
+\\begin{{lstlisting}}[language=Python, frame=single, basicstyle=\\ttfamily\\small]
+{code}
+\\end{{lstlisting}}
+""")
+        return code_str
+
+    def _create_preamble(self, metadata: Dict[str, Any]) -> str:
+        """Create LaTeX preamble with document setup"""
+        title = metadata.get("title", "paper_title")
+        team = metadata.get("team", "team")
+        year = metadata.get("year", "2024")
+        problem_type = metadata.get("problem_type", "problem_type")
+        
+        return f"""\\documentclass{{mcmthesis}}
+\\mcmsetup{{CTeX = false,
+        tcn = {team}, problem = {problem_type},
+        year = {year},
+        sheet = true, titleinsheet = true, keywordsinsheet = true,
+        titlepage = false, abstract = true}}
+
+\\usepackage{{palatino}}
+\\usepackage{{algorithm}}
+\\usepackage{{algpseudocode}}
+\\usepackage{{tocloft}}
+\\usepackage{{amsmath}}
+
+\\usepackage{{lastpage}}
+\\renewcommand{{\\cftdot}}{{.}}
+\\renewcommand{{\\cftsecleader}}{{\\cftdotfill{{\\cftdotsep}}}}
+\\renewcommand{{\\cftsubsecleader}}{{\\cftdotfill{{\\cftdotsep}}}}
+\\renewcommand{{\\cftsubsubsecleader}}{{\\cftdotfill{{\\cftdotsep}}}}
+\\renewcommand{{\\headset}}{{{year}\\\\MCM/ICM\\\\Summary Sheet}}
+\\title{{{title}}}
+
+\\begin{{document}}"""
+    
+    def _create_abstract(self, metadata: Dict[str, str]) -> str:
+        """Create the abstract section"""
+        return f"""\\begin{{abstract}}
+{metadata.get('summary', '')}
+
+\\begin{{keywords}}
+{metadata.get('keywords', '')}
+\\end{{keywords}}
+\\end{{abstract}}"""
+    
+    def _create_body(self, chapters: List[Chapter], metadata: Dict[str, Any]) -> str:
+        """Create the main body of the document from chapters"""
+        body_parts = []
+        current_path = []
+        
+        for chapter in chapters:
+            # Add section headings
+            if chapter.path == ["Model Conclusion", "Model Advantages"] and metadata.get('figures', []):
+                body_parts += self._add_figure(metadata['figures'])
+
+            for i, section in enumerate(chapter.path):
+                # If this path level is new or different
+                if i >= len(current_path) or section != current_path[i]:
+                    # Update current path
+                    if len(current_path) <= i:
+                        current_path.append(section)
+                    else:
+                        current_path[i] = section
+                        current_path = current_path[:i+1]  # Truncate the path
+                
+                    # Use custom title if available for the last level
+                    title = chapter.display_title if i == chapter.depth - 1 else section
+                    
+                    # Add section heading at appropriate level
+                    if i == 0:
+                        body_parts.append(f"\\section{{{title}}}")
+                    elif i == 1:
+                        body_parts.append(f"\\subsection{{{title}}}")
+                    elif i == 2:
+                        body_parts.append(f"\\subsubsection{{{title}}}")
+            
+            # Add chapter content if generated
+            if chapter.is_generated and chapter.content:
+                body_parts.append(chapter.content)
+
+        body_parts.append("\\section{References}")
+        body_parts += self._add_code(metadata['codes'])
+        return "\n\n".join(body_parts)
+
+# --------------------------------
+# File Operations
+# --------------------------------
+
+class FileManager:
+    """Handles file operations for saving papers and generating PDFs"""
+    
+    @staticmethod
+    def save_to_file(content: str, filepath: str) -> None:
+        """Save content to a file"""
+        os.makedirs(os.path.dirname(filepath), exist_ok=True)
+        with open(filepath, 'w') as f:
+            f.write(content)
+        print(f"Document saved to {filepath}")
+    
+    @staticmethod
+    def generate_pdf(latex_path: str) -> None:
+        """Generate a PDF from a LaTeX file"""
+        print(f"Generating PDF from {latex_path}...")
+        
+        # Run pdflatex twice to ensure references and TOC are correct
+        latex_dir = os.path.dirname(latex_path)
+        subprocess.run(["pdflatex", f"-output-directory={latex_dir}", "-interaction=nonstopmode", latex_path])
+        subprocess.run(["pdflatex", f"-output-directory={latex_dir}", "-interaction=nonstopmode", latex_path])
+        
+        # Clean up auxiliary files
+        FileManager._clean_temp_files(latex_path)
+        
+        pdf_path = latex_path.replace('.tex', '.pdf')
+        print(f"PDF generated at {pdf_path}")
+    
+    @staticmethod
+    def _clean_temp_files(latex_path: str) -> None:
+        """Clean up temporary files created during PDF generation"""
+        for ext in ["aux", "log", "toc", "out"]:
+            aux_file = latex_path.replace('.tex', f'.{ext}')
+            if os.path.exists(aux_file):
+                os.remove(aux_file)
+
+# --------------------------------
+# Main Paper Generator
+# --------------------------------
+
+class PaperGenerator:
+    """Main class that orchestrates the paper generation process"""
+    
+    def __init__(self, llm):
+        self.content_generator = ContentGenerator(llm)
+        self.outline_generator = OutlineGenerator()
+        self.context_extractor = ContextExtractor()
+        self.prompt_creator = PromptCreator()
+        self.document_assembler = LatexDocumentAssembler()
+        self.file_manager = FileManager()
+        self.llm = llm
+        
+    def generate_paper(self, 
+                    json_data: Dict[str, Any], 
+                    metadata: Dict[str, Any],
+                    output_dir: str,
+                    filename: str) -> None:
+        """Generate a complete academic paper from JSON data"""
+        # 1. Create chapter structure
+        task_count = len(json_data.get("tasks", []))
+        print(f"Starting paper generation with {task_count} tasks")
+        chapters = self.outline_generator.create_outline(task_count)
+        
+        # Generate chapter relevance map if not provided
+        chapter_relevance_map = self.outline_generator.generate_chapter_relevance_map(task_count)
+        
+        # 2. Generate content for each chapter that needs it
+        completed_chapters = []
+        for chapter in chapters:
+            if chapter.needs_content:
+                self._generate_chapter_content(chapter, json_data, completed_chapters, chapter_relevance_map)
+                completed_chapters.append(chapter)
+        
+        # 3. Complete metadata if needed
+        complete_metadata = self._complete_metadata(chapters, metadata)
+        
+        # 4. Assemble the final document
+        document = self.document_assembler.create_document(chapters, complete_metadata)
+        
+        # 5. Save and convert to PDF
+        latex_path = f"{output_dir}/{filename}.tex"
+        self.file_manager.save_to_file(document, latex_path)
+        self.file_manager.generate_pdf(latex_path)
+        
+    def _generate_chapter_content(self, 
+                            chapter: Chapter, 
+                            json_data: Dict[str, Any],
+                            completed_chapters: List[Chapter],
+                            chapter_relevance_map: Dict[str, List[str]]) -> None:
+        """Generate content for a single chapter"""
+        print(f"Generating content for: {chapter.path_string}")
+        
+        # Get relevant context data for this chapter
+        context = self.context_extractor.get_context_for_chapter(chapter, json_data)
+        
+        # Get only the relevant completed chapters for context
+        relevant_chapters = self._get_relevant_chapters(chapter, completed_chapters, chapter_relevance_map)
+        
+        # Create prompt and generate content
+        prompt = self.prompt_creator.create_prompt(
+            chapter, context, relevant_chapters
+        )
+        # Generate content
+        response = self.content_generator.generate_chapter_content(prompt)
+        
+        # Update chapter with generated content
+        # chapter.content = response['content']
+        # chapter.title = self._format_title(chapter, response['title'])
+        chapter.content = response
+        chapter.title = ''
+        chapter.is_generated = True
+    
+    def _get_relevant_chapters(self, 
+                         chapter: Chapter, 
+                         completed_chapters: List[Chapter],
+                         chapter_relevance_map: Dict[str, List[str]]) -> List[Chapter]:
+        """Filter completed chapters to only include those relevant to the current chapter"""
+        # Get the path string for the current chapter
+        current_path = chapter.path_string
+        
+        # If this chapter has specific relevant chapters defined in the map
+        if current_path in chapter_relevance_map:
+            relevant_paths = chapter_relevance_map[current_path]
+            # Filter completed chapters to only include those in the relevant paths
+            return [ch for ch in completed_chapters 
+                    if ch.path_string in relevant_paths]
+        
+        # Default: return all completed chapters if no specific relevance is defined
+        return completed_chapters
+
+    def _format_title(self, chapter: Chapter, generated_title: str) -> str:
+        """Format title based on chapter type"""
+        # Only use custom titles for certain chapter types
+        if (chapter.path[0] == "Problem Analysis" or 
+            chapter.path[0] == "Solution to the Problem"):
+            return generated_title
+        return ''
+    
+    def _complete_metadata(self, 
+                        chapters: List[Chapter], 
+                        provided_metadata: Dict[str, Any]) -> Dict[str, Any]:
+        """Complete paper metadata, generating missing fields if needed"""
+        # If we need to generate metadata
+        if not all(key in provided_metadata for key in 
+                ["title", "summary", "keywords"]):
+            print("Generating missing paper metadata...")
+            
+            # Prepare prompt with chapter contents
+            chapters_text = "\n\n".join(
+                f"Chapter: {ch.path_string}\n{ch.content}" 
+                for ch in chapters if ch.is_generated
+            )
+            
+            prompt = PAPER_INFO_PROMPT.format(paper_chapters=chapters_text)
+            
+            # Retry up to 3 times to get valid metadata
+            max_retries = 3
+            generated_metadata = {}
+            
+            for attempt in range(max_retries):
+                try:
+                    metadata_response = self.llm.generate(prompt)
+                    generated_metadata = parse_llm_output_to_json(metadata_response)
+                    if not generated_metadata:
+                        raise Exception("No metadata generated")
+                    break
+                except Exception as e:
+                    print(f"Attempt {attempt+1} failed: {str(e)}")
+                    if attempt == max_retries - 1:  # If this was the last attempt
+                        print("All attempts to generate metadata failed")
+            # Merge with provided metadata (provided takes precedence)
+            return {**generated_metadata, **provided_metadata}
+        
+        return provided_metadata
+
+# --------------------------------
+# Main Function
+# --------------------------------
+
+def generate_paper_from_json(llm, json_data: dict, info: dict, output_dir: str, output_name: str) -> None:
+    """Generate a paper from JSON data"""
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    generator = PaperGenerator(llm)
+    generator.generate_paper(json_data, info, output_dir, output_name)
+
+
+
+if __name__ == "__main__":
+    # Example usage
+    metadata = {
+        "team": "Agent",
+        "year": "2024",
+        "problem_type": "C"
+    }
+    project_dir = "/Users/ann/Downloads/2024_C_2_20250307-144537"
+    json_file_path = f"{project_dir}/json/2024_C_2.json"
+    code_dir = f'{project_dir}/code'
+    metadata['figures'] = [os.path.join(code_dir, f) for f in os.listdir(code_dir) if f.lower().split('.')[-1] in ['png', 'jpg', 'jpeg']]
+    metadata['codes'] = sorted([os.path.join(code_dir, f) for f in os.listdir(code_dir) if f.lower().split('.')[-1] in ['py']])
+    with open(json_file_path, 'r') as f:
+        json_data = json.loads(f.read())
+    json_data['tasks'] = json_data['tasks'][:]
+    # Initialize language model
+    llm = LLM(model_name='gpt-4o')
+    # Generate paper with chapter relevance mapping
+    generate_paper_from_json(llm, json_data, metadata, f"{project_dir}/latex", 'solution')
+

core/utils/generate_problem.py

@@ -0,0 +1,45 @@
+from llm.llm import LLM
+from input.problem import problem_input
+# from input.test_middle_result import problem_str, problem_analysis, selected_models, modeling_solution, modeling_solution, task_descriptions
+from agent.problem_analysis import ProblemAnalysis
+from agent.problem_modeling import ProblemModeling
+from agent.task_decompse import TaskDecompose
+from agent.task import Task
+from agent.create_charts import Chart
+from utils.utils import read_json_file, write_json_file, write_text_file, json_to_markdown
+# from utils.convert_format import markdown_to_latex
+import os
+from prompt.template import PROBLEM_EXTRACT_PROMPT
+
+
+config = {
+    'problem_analysis_round': 1,
+    'problem_modeling_round': 1,
+    'task_formulas_round': 1,
+    'tasknum': 4,
+    'chart_num': 3,
+    'model_name': 'chatgpt-4o-latest'
+}
+
+def run_batch(problem_path, config):
+    # Initialize LLM
+    llm = LLM(config['model_name'])
+    
+    # Get problem input
+    problem_str, problem = problem_input(problem_path, llm)
+    problem_name = os.path.splitext(os.path.basename(problem_path))[0]
+    problem_type = os.path.splitext(os.path.basename(problem_path))[0].split('_')[-1]
+    
+    return {problem_name: problem}
+
+
+if __name__ == "__main__":
+    import glob
+    # files = glob.glob('/Users/ann/Downloads/methmatical_paper_extraction/parse/2025_*/content/*.md')
+    files = glob.glob('../data/actor_data/input/problem/2025_*')
+    problems = read_json_file('../data/actor_data/output/problem_24.json')
+    for file in files:
+        problems.update(run_batch(file, config))
+
+    write_json_file('../data/actor_data/output/problem_25.json', problems)
+    print(problems.keys())

core/utils/problem2.py

@@ -0,0 +1,23 @@
+from llm.llm import LLM
+from utils.utils import read_json_file, write_json_file, write_text_file, json_to_markdown, read_text_file, parse_llm_output_to_json
+from agent.create_charts import Chart
+# from utils.convert_format import markdown_to_latex
+import os
+from prompt.template import PROBLEM_EXTRACT_PROMPT
+
+
+
+if __name__ == "__main__":
+    import glob
+    files = glob.glob('/Users/ann/Downloads/methmatical_paper_extraction/parse/2025_*/content/*.md')
+    llm = LLM('chatgpt-4o-latest')
+    data = {}
+    for file in files:
+        year, _, _, problem_type = file.split('/')[-1].split('.')[0].split('_')
+        problem_name = f'{year}_{problem_type}'
+        problem_str = read_text_file(file)    
+        problem = llm.generate(PROBLEM_EXTRACT_PROMPT.format(question=problem_str), problem_str)
+        problem = parse_llm_output_to_json(problem)
+        # data[problem_name] = problem
+        print(problem)
+        write_json_file(f'/Users/ann/Documents/projects/math_modeling/data/actor_data/input/problem/{problem_name}.json', problem)

core/utils/utils.py

@@ -0,0 +1,161 @@
+import json
+from typing import Dict
+
+
+def read_text_file(file_path: str) -> str:
+    with open(file_path, 'r', encoding='utf-8') as file:
+        return file.read()
+
+
+def read_json_file(file_path: str) -> Dict:
+    with open(file_path, 'r', encoding='utf-8') as file:
+        return json.load(file)
+
+
+def write_text_file(file_path: str, content: str):
+    with open(file_path, 'w', encoding='utf-8') as file:
+        file.write(content)
+
+
+def write_json_file(file_path: str, data:dict) -> Dict:
+    with open(file_path, "w", encoding="utf-8") as json_file:
+        json_file.write(json.dumps(data, indent=4, ensure_ascii=False))
+
+
+def parse_llm_output_to_json(output_text: str) -> dict:
+    """
+    Safely parse LLM output text into a Python dictionary.
+    """
+    start = output_text.find("{")
+    end = output_text.rfind("}") + 1
+    json_str = output_text[start:end]
+    try:
+        data = json.loads(json_str)
+    except:
+        raise
+        data = {}
+    return data
+
+def json_to_markdown(paper):
+    """
+    Converts a paper dictionary to a Markdown string with multi-level headlines.
+
+    Args:
+        paper (dict): The paper dictionary containing problem details and tasks.
+
+    Returns:
+        str: A Markdown-formatted string representing the paper.
+    """
+    markdown_lines = []
+
+    # Problem Background
+    markdown_lines.append("## Problem Background")
+    markdown_lines.append(paper.get('problem_background', 'No background provided.') + "\n")
+
+    # Problem Requirement
+    markdown_lines.append("## Problem Requirement")
+    markdown_lines.append(paper.get('problem_requirement', 'No requirements provided.') + "\n")
+
+    # Problem Analysis
+    markdown_lines.append("## Problem Analysis")
+    markdown_lines.append(paper.get('problem_analysis', 'No analysis provided.') + "\n")
+
+    # Problem Modeling
+    if 'problem_modeling' in paper:
+        markdown_lines.append("## Problem Modeling")
+        markdown_lines.append(paper.get('problem_modeling', 'No modeling provided.') + "\n")
+
+    # Tasks
+    tasks = paper.get('tasks', [])
+    if tasks:
+        markdown_lines.append("## Tasks\n")
+        for idx, task in enumerate(tasks, start=1):
+
+            markdown_lines.append(f"### Task {idx}")
+
+            task_description = task.get('task_description', 'No description provided.')
+            markdown_lines.append("#### Task Description")
+            markdown_lines.append(task_description + "\n")
+
+            # Task Analysis
+            task_analysis = task.get('task_analysis', 'No analysis provided.')
+            markdown_lines.append("#### Task Analysis")
+            markdown_lines.append(task_analysis + "\n")
+
+            # Mathematical Formulas
+            task_formulas = task.get('mathematical_formulas', 'No formulas provided.')
+            markdown_lines.append("#### Mathematical Formulas")
+            if isinstance(task_formulas, list):
+                for formula in task_formulas:
+                    markdown_lines.append(f"$${formula}$$")
+            else:
+                markdown_lines.append(f"$${task_formulas}$$")
+            markdown_lines.append("")  # Add an empty line
+
+            # Mathematical Modeling Process
+            task_modeling = task.get('mathematical_modeling_process', 'No modeling process provided.')
+            markdown_lines.append("#### Mathematical Modeling Process")
+            markdown_lines.append(task_modeling + "\n")
+
+            # Result
+            task_result = task.get('result', 'No result provided.')
+            markdown_lines.append("#### Result")
+            markdown_lines.append(task_result + "\n")
+
+            # Answer
+            task_answer = task.get('answer', 'No answer provided.')
+            markdown_lines.append("#### Answer")
+            markdown_lines.append(task_answer + "\n")
+
+            # Charts
+            charts = task.get('charts', [])
+            if charts:
+                markdown_lines.append("#### Charts")
+                for i, chart in enumerate(charts, start=1):
+                    markdown_lines.append(f"##### Chart {i}")
+                    markdown_lines.append(chart + "\n")
+
+    # # Usage Information
+    # if 'usage' in paper:
+    #     markdown_lines.append("## Usage Information")
+    #     markdown_lines.append(paper.get('usage', 'No usage information provided.') + "\n")
+
+    # Combine all lines into a single string
+    markdown_str = "\n".join(markdown_lines)
+    return markdown_str
+
+
+def json_to_markdown_general(json_data):
+    """
+    Convert a JSON object to a markdown format.
+
+    Args:
+    - json_data (str or dict): The JSON data to convert. It can be a JSON string or a dictionary.
+
+    Returns:
+    - str: The markdown formatted string.
+    """
+    
+    if isinstance(json_data, str):
+        json_data = json.loads(json_data)  # If input is a JSON string, parse it.
+
+    def recursive_markdown(data, indent=0):
+        markdown_str = ""
+        indent_space = "  " * indent
+        
+        if isinstance(data, dict):
+            for key, value in data.items():
+                markdown_str += f"### {key}\n"
+                markdown_str += recursive_markdown(value, indent + 1)
+        elif isinstance(data, list):
+            for index, item in enumerate(data):
+                markdown_str += f"- **Item {index + 1}**\n"
+                markdown_str += recursive_markdown(item, indent + 1)
+        else:
+            markdown_str += f"- {data}\n"
+        
+        return markdown_str
+    
+    markdown = recursive_markdown(json_data)
+    return markdown
+

core/workflow/solution.py

@@ -0,0 +1,14 @@
+from prompt.constants import TASK_PROMPT
+
+class Workflow:
+    def __init__(self):
+        self.agents = []
+
+    def add_agent(self, agent):
+        self.agents.append(agent)
+
+    def execute_workflow(self, task_description: str):
+        prompt = TASK_PROMPT.format(task_description=task_description)
+        for agent in self.agents:
+            agent.receive_prompt(prompt)
+            agent.execute()

data/.DS_Store

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d65165279105ca6773180500688df4bdc69a2c7b771752f0a46ef120b7fd8ec3
+size 6148

data/actor_data/.DS_Store

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:764ed4022bd48062ec065bad80e512ade8e7a482312e989ee5ac1c44e574ffe3
+size 6148

data/actor_data/docs/.DS_Store

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d65165279105ca6773180500688df4bdc69a2c7b771752f0a46ef120b7fd8ec3
+size 6148

data/actor_data/input/.DS_Store

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4f7d6d02b7c5d6f5e1e5a573881562319b1534e80d5b3067879b59981e466d8
+size 6148

data/actor_data/input/code_template/main.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ba7c8e238db048d21199cdadf96ccc7571bebdff130227f471d34ebbcf74836
+size 350

data/actor_data/input/code_template/main1.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3b8cb138acaa95ec917c075dfbec0d3d642ef65349a544ef20b52ea9a01dfcf
+size 353

data/actor_data/input/code_template/main10.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5765acb721477a6b4323a8415d8fb0dd444122b0fde503e3c0637e3209990c85
+size 356

data/actor_data/input/code_template/main2.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:488e549cc0d86c9fc43101ba10dbd4792f633bdc21f6af6cab6ec39cd6aef262
+size 353

data/actor_data/input/code_template/main3.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78ae56587f5dab567981b7143b1388580b889e19b0b3f9a992b72455ec8eed0d
+size 353

data/actor_data/input/code_template/main4.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d60b7ad7cfda732c6143e50f283a344812f32a1df6dfbc4ba0da4917c5e120fa
+size 353

data/actor_data/input/code_template/main5.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a846a2f4fb918b853c277020997109dc36ea41328b225bfaf11caac96b378a5
+size 353