Datasets:

Antislab
/

LLM4PH

from typing import Dict, List, Any
import re

def _extract_section(text: str, start_marker: str, end_marker: str) -> str:
    """Extract content between two markers"""
    start = text.find(start_marker)
    if start == -1:
        return ""
    start += len(start_marker)
    end = text.find(end_marker, start)
    if end == -1:
        return ""
    return text[start:end].strip()

class AnswerExtractor:
    def __init__(self, task_name):
        """Initialize answer extractor"""
        self.task_name = task_name
    
    def extract_answers(self, response):
        """Extract answers based on task type"""
        try:
            task_extractors = {
                "S_0D": self.extract_S_0D,
                "S_1D": self.extract_S_1D,
                "S_Modification": self.extract_S_Modification,
                "M_Birth": self.extract_M_Birth,
                "M_Merge": self.extract_M_Merge,
                "M_Filtration": self.extract_M_Filtration,
                "H_Selection": self.extract_H_Selection,
                "H_Generation": self.extract_H_Generation,
                "R_Selection": self.extract_R_Selection,
                "R_Generation": self.extract_R_Generation,
                "R_Directly": self.extract_R_Directly
            }
            
            answer = task_extractors.get(self.task_name)(response) if self.task_name in task_extractors else None
            
            return answer
        except Exception as e:
            print(f"Error extracting answer: {str(e)}")
            return None
    
    
    def extract_S_0D(self, answer: str) -> Dict[str, Any]:
        """Extract information from 0-dimensional topology structure identification answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value with more flexible pattern matching
            value_match = re.search(r'connected components:\s*(\d+)', answer_section)
            if not value_match:
                return {"error": "connected components not found"}
            
            # Parse the value
            try:
                value = int(value_match.group(1).strip())
                return {
                    "connected_components": value
                }
            except ValueError as e:
                return {"error": f"Error parsing value: {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
        
    def extract_S_1D(self, answer: str) -> Dict[str, Any]:
        """Extract information from 1-dimensional topology structure identification answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value with more flexible pattern matching
            value_match = re.search(r'cycle holes:\s*(\d+)', answer_section)
            if not value_match:
                return {"error": "cycle holes not found"}
            
            # Parse the value
            try:
                value = int(value_match.group(1).strip())
                return {
                    "cycle_holes": value
                }
            except ValueError as e:
                return {"error": f"Error parsing value: {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}


    def extract_S_Modification(self, answer: str) -> Dict[str, Any]:
        """Extract information from graph structure modification answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Try multiple matching patterns
            patterns = [
                r'Edge to add:\s*\[(.*?)\]',  # Match "Edge to add: [0, 7]" format
                r'Edge to add:\s*\((\d+)\s*,\s*(\d+)\)',  # Match "Edge to add: (0, 7)" format
                r'Edge to add:\s*(\d+)\s*-\s*(\d+)',  # Match "Edge to add: 0-7" format
                r'Edge to add:\s*(\d+)\s*,\s*(\d+)'  # Match "Edge to add: 0, 7" format
            ]
            
            for pattern in patterns:
                value_match = re.search(pattern, answer_section)
                if value_match:
                    try:
                        if pattern == r'Edge to add:\s*\[(.*?)\]':
                            # Handle [0, 7] format
                            values_str = value_match.group(1).strip()
                            values = [int(x.strip()) for x in values_str.split(',')]
                        else:
                            # Handle other formats
                            values = [int(value_match.group(1)), int(value_match.group(2))]
                        
                        return {
                            "edge_to_add": values
                        }
                    except (ValueError, IndexError):
                        continue
            
            return {"error": "Edge to add not found or invalid format"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
        
        
    def extract_M_Birth(self, answer: str) -> Dict[str, Any]:
        """Extract birth time calculation task answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value
            value_match = re.search(r'birth time:\s*\[(.*?)\]', answer_section)
            if not value_match:
                return {"error": "birth_time not found"}
            
            # Parse the values
            try:
                values = [self._parse_number(x) for x in value_match.group(1).split(',')]
                return {
                    "birth_time": values
                }
            except ValueError as e:
                return {"error": f"Error parsing : {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}

    def extract_M_Merge(self, answer: str) -> Dict[str, Any]:
        """Extract information from 0-dimensional persistent homology calculation task answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value
            value_match = re.search(r'death time:\s*\[(.*?)\]', answer_section)
            if not value_match:
                return {"error": "death_time not found"}
            
            # Parse the values
            try:
                values = [self._parse_number(x) for x in value_match.group(1).split(',')]
                return {
                    "death_time": values
                }
            except ValueError as e:
                return {"error": f"Error parsing : {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
        
    def extract_M_Filtration(self,answer:str) -> Dict[str, Any]:
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value
            value_match = re.search(r'connected components:\s*\[(.*?)\]', answer_section)
            if not value_match:
                return {"error": "connected components not found"}
            
            # Parse the values
            try:
                values = [self._parse_number(x) for x in value_match.group(1).split(',')]
                return {
                    "connected_components": values
                }
            except ValueError as e:
                return {"error": f"Error parsing : {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}

    def extract_H_Selection(self, answer: str) -> Dict[str, Any]:
        """Extract selected filtration method from the response"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            # Try multiple matching patterns
            patterns = [
                r'Method:\s*([\w-]+)',  # Match "Method: k-shell" format
                r'Method:\s*\[([\w-]+)\]',  # Match "Method: [k-shell]" format
                r'selected_method:\s*([\w-]+)',  # Match "selected_method: k-shell" format
                r'Selected Method:\s*([\w-]+)'  # Match "Selected Method: k-shell" format
            ]

            for pattern in patterns:
                value_match = re.search(pattern, answer_section, re.IGNORECASE)
                if value_match:
                    method = value_match.group(1).strip().lower()
                    # Validate method name
                    valid_methods = ['degree', 'betweenness', 'k-shell', 'closeness', 'weight', 'eigenvector']
                    if method in valid_methods:
                        return {
                            "selected_method": method
                        }

            return {"error": "Method not found or invalid"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}


    def extract_H_Generation(self, answer: str) -> Dict[str, Any]:
        """Extract information from filteration value selection task answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value
            value_match = re.search(r'filtration value:\s*\[(.*?)\]', answer_section)
            if not value_match:
                return {"error": "Filtration value not found"}
            
            # Parse the values
            try:
                values = [int(x.strip()) for x in value_match.group(1).split(',')]
                return {
                    "selected_filtration_values": values
                }
            except ValueError as e:
                return {"error": f"Error parsing filtration values: {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
        
    def extract_filtration_edge_construction(self, answer: str) -> Dict[str, Any]:
        """Extract information from filtration edge construction task answer"""
        result = {
            "filtration": {}
        }
        
        try:
            # Extract filtration process
            filtration_section = _extract_section(answer, "===FILTRATION_START===", "===FILTRATION_END===")
            result["filtration"] = self._parse_filtration_edges(filtration_section)
            
            # Validate results
            if not result["filtration"]:
                print("Warning: Failed to extract filtration process")
                print("Filtration process:", result["filtration"])
            
        except Exception as e:
            import traceback
            print(f"Error during extraction: {str(e)}")
            print("Error details:")
            print(traceback.format_exc())
            return result  # Return partially parsed results instead of None
        
        return result
    
    def extract_simplicial_complex_construction(self, answer: str) -> Dict[str, Any]:
        """
        Extract answer for simplicial_complex_construction task
        
        Parameters:
            answer: Model generated answer text
        
        Returns:
            dict: Contains extracted simplicial complex information
        """
        try:
            # Extract simplicial complex section
            simplex_text = self._extract_section(answer, "===SIMPLICIAL_COMPLEX_START===", "===SIMPLICIAL_COMPLEX_END===")
            if not simplex_text:
                return {"error": "Simplicial complex section not found"}
            
            # Parse simplicial complex
            simplices = {}
            
            for line in simplex_text.split('\n'):
                line = line.strip()
                if not line:
                    continue
                    
                # Check if it's a simplex
                if line.startswith('[') and line.endswith(']'):
                    try:
                        # Parse node list and filtration value
                        content = line[1:-1]  # Remove outer brackets
                        nodes_part, value_part = content.split('),')
                        nodes = [int(x.strip()) for x in nodes_part[1:].split(',')]  # Remove inner brackets
                        value = float(value_part.strip())
                        
                        if len(nodes) == 3:  # Only process 2-dimensional simplices (triangles)
                            if value not in simplices:
                                simplices[value] = []
                            simplices[value].append(nodes)
                    except (ValueError, IndexError) as e:
                        print(f"Error parsing simplex: {line}, error: {str(e)}")
                        continue
            
            return {
                "simplicial_complexes": simplices
            }
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
    
    def _parse_number(self, value_str: str) -> float:
        """Parse number intelligently, try integer first, then float"""
        value_str = value_str.strip()
        try:
            # Try parsing as integer first
            return int(value_str)
        except ValueError:
            try:
                # If integer parsing fails, try parsing as float
                value = float(value_str)
                # If it's an integer (no decimal part), return integer
                if value.is_integer():
                    return int(value)
                return value
            except ValueError:
                raise ValueError(f"Cannot parse number: {value_str}")

    def extract_R_Selection(self, answer: str) -> Dict[str, Any]:
        """Extract selected filtration method from the response"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()

            # Try multiple matching patterns
            patterns = [
                r'Method:\s*(\w+)',  # Match "Method: weight" format
                r'Method:\s*\[(.*?)\]',  # Match "Method: [weight]" format
                r'selected_method:\s*(\w+)',  # Match "selected_method: weight" format
                r'Selected Method:\s*(\w+)'  # Match "Selected Method: weight" format
            ]

            for pattern in patterns:
                value_match = re.search(pattern, answer_section, re.IGNORECASE)
                if value_match:
                    method = value_match.group(1).strip().lower()
                    # 验证方法名称是否有效
                    valid_methods = ['degree', 'betweenness', 'k-shell', 'closeness', 'weight','eigenvector']
                    if method in valid_methods:
                        return {
                            "selected_method": method
                        }

            return {"error": "Method not found or invalid"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
        

    def extract_R_Generation(self, answer: str) -> Dict[str, Any]:
        """Extract filtration values from the response"""
        try:
            # Extract content after "Answer:" if present
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()

            # Match pattern like Filtration value: [0.1,0.4,0.5,...]
            pattern = r'Filtration\s*value[s]?:\s*\[([^\]]+)\]'
            match = re.search(pattern, answer_section, re.IGNORECASE)
            if not match:
                return {"error": "Filtration values not found"}

            # Extract numbers inside brackets, split by comma and convert to float
            nums_str = match.group(1)
            values: List[float] = []
            for part in nums_str.split(','):
                part = part.strip()
                if part:
                    try:
                        values.append(float(part))
                    except ValueError:
                        return {"error": f"Cannot convert '{part}' to float"}
            
            return {"filtration_values": values}

        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
    
    def extract_R_Directly(self, answer: str) -> Dict[str, Any]:
        """Extract category classification from the response"""
        # Get content after "Answer:" if present
        if "Answer:" in answer:
            answer_section = answer.split("Answer:")[-1].strip()
        else:
            answer_section = answer
        pattern = r'Category:\s*[\[\(]\s*([\d\.\s,]+)[\]\)]\s*,\s*[\[\(]\s*([\d\.\s,]+)[\]\)]'
        match = re.search(pattern, answer_section, re.IGNORECASE | re.DOTALL)
        if not match:
            return {"error": "Category format not found or incorrect"}

        def parse_group(group_str: str) -> List[int]:
            return [int(float(x.strip())) for x in group_str.split(',') if x.strip()]

        category1 = parse_group(match.group(1))
        category2 = parse_group(match.group(2))

        all_indices = sorted(category1 + category2)
        if all_indices != [1, 2, 3, 4]:
            return {"error": f"Graph indices must be [1, 2, 3, 4], got: {all_indices}"}

        return {
            "categories": [category1, category2]
        }

    # def _parse_filtration_edges(self, section: str) -> Dict[float, List[Tuple[int, int]]]:
    #     """Parse filtration process, specific to the format of filtration edge construction task"""
    #     filtration = {}
    #     current_value = None
    #     for line in section.split('\n'):
    #         line = line.strip()
    #         if line.startswith('**Value='):
    #             value_part = line.replace('**', '').replace('Value=', '').strip()
    #             current_value = float(value_part)
    #             filtration[current_value] = []
    #         elif line.startswith('(') and line.endswith(')'):
    #             try:
    #                 u, v = map(int, line[1:-1].split(','))
    #                 filtration[current_value].append((u, v))
    #             except:
    #                 print(f"Cannot parse edge: {line}")
    #     return filtration
    
    
    # def extract_structure_identification(self, answer: str) -> Dict[str, Any]:
    #     """Extract information from topology structure identification answer"""
    #     result = {
    #         "cavities": [],
    #         "temporal_evolution": {}
    #     }
        
    #     # Extract cavity information
    #     if "2-DIMENSIONAL CAVITIES:" in answer:
    #         cavities_section = self._extract_section(
    #             answer, "2-DIMENSIONAL CAVITIES:", "TEMPORAL EVOLUTION:"
    #         )
    #         result["cavities"] = self._extract_cavities(cavities_section)
        
    #     # Extract temporal evolution
    #     if "TEMPORAL EVOLUTION:" in answer:
    #         evolution_section = answer.split("TEMPORAL EVOLUTION:")[1]
    #         result["temporal_evolution"] = self._extract_temporal_evolution(evolution_section)
        
    #     return result
    

    # def extract_simplex_structure_identification(self, answer: str) -> Dict[str, Any]:
    #     """Extract information from simplex structure identification answer"""
    #     result = {
    #         "simplex_count": 0
    #     }
        
    #     lines = answer.strip().split('\n')
    #     for line in lines:
    #         line = line.strip()
    #         if line.startswith('2维单纯形数量：'):
    #             count_str = line.split('：')[1].strip()
    #             try:
    #                 result["simplex_count"] = int(count_str)
    #             except ValueError:
    #                 # Keep default value 0 if cannot parse as integer
    #                 pass
        
    #     return result
    
    # def _extract_section(self, text: str, start_marker: str, end_marker: str) -> str:
    #     """Extract text between two markers"""
    #     if start_marker in text and end_marker in text:
    #         start_idx = text.find(start_marker) + len(start_marker)
    #         end_idx = text.find(end_marker)
    #         return text[start_idx:end_idx].strip()
    #     return ""
    
    

    
    # def _extract_list(self, text: str) -> List:
    #     """Extract list from text"""
    #     items = text.split(':')[1].strip()
    #     if items.startswith('[') and items.endswith(']'):
    #         return eval(items)
    #     return []
    
    # def _extract_feature_info(self, line: str) -> Dict[str, Any]:
    #     """Extract feature information from text"""
    #     info = {}
    #     if 'Birth time:' in line:
    #         info['birth'] = float(line.split(':')[1].strip())
    #     elif 'Death time:' in line:
    #         info['death'] = float(line.split(':')[1].strip())
    #     elif 'Persistence:' in line:
    #         info['persistence'] = float(line.split(':')[1].strip())
    #     elif 'Description:' in line:
    #         info['description'] = line.split(':')[1].strip()
    #     return info

    
    # def _extract_cavities(self, text: str) -> List[Dict[str, Any]]:
    #     """Extract cavity information"""
    #     cavities = []
    #     current_cavity = None
        
    #     for line in text.split('\n'):
    #         if line.startswith('Cavity'):
    #             if current_cavity:
    #                 cavities.append(current_cavity)
    #             current_cavity = {}
    #         elif current_cavity is not None and line.startswith('-'):
    #             key = line.split(':')[0].strip('- ').lower()
    #             value = line.split(':')[1].strip()
    #             if key in ['birth threshold', 'death threshold', 'persistence']:
    #                 value = float(value)
    #             elif key in ['nodes', 'edges']:
    #                 value = eval(value)
    #             current_cavity[key] = value
        
    #     if current_cavity:
    #         cavities.append(current_cavity)
        
    #     return cavities
    
    # def _extract_temporal_evolution(self, text: str) -> Dict[float, Dict[str, List[int]]]:
    #     """Extract temporal evolution information"""
    #     evolution = {}
    #     current_threshold = None
        
    #     for line in text.split('\n'):
    #         if line.startswith('Threshold'):
    #             current_threshold = float(line.split()[1])
    #             evolution[current_threshold] = {
    #                 'active': [],
    #                 'new': [],
    #                 'disappeared': []
    #             }
    #         elif current_threshold is not None and line.startswith('-'):
    #             key = line.split(':')[0].strip('- ').lower()
    #             value = eval(line.split(':')[1].strip())
    #             evolution[current_threshold][key] = value
        
    #     return evolution
    
    # def _extract_current_state(self, text: str) -> Dict[str, Any]:
    #     """Extract current state information"""
    #     state = {}
    #     for line in text.split('\n'):
    #         if line.startswith('- Number of cycles:'):
    #             state['cycles'] = int(line.split(':')[1].strip())
    #         elif line.startswith('- Cycle locations:'):
    #             state['locations'] = eval(line.split(':')[1].strip())
    #     return state
    
    # def _extract_proposed_modifications(self, text: str) -> List[Dict[str, Any]]:
    #     """Extract proposed modifications"""
    #     modifications = []
    #     current_mod = None
        
    #     for line in text.split('\n'):
    #         if line.startswith('Modification'):
    #             if current_mod:
    #                 modifications.append(current_mod)
    #             current_mod = {}
    #         elif current_mod is not None and line.startswith('-'):
    #             key = line.split(':')[0].strip('- ').lower()
    #             value = line.split(':')[1].strip()
    #             if key == 'new edge':
    #                 value = tuple(map(int, value.split('-')))
    #             elif key == 'expected new cycles':
    #                 value = eval(value)
    #             current_mod[key] = value
        
    #     if current_mod:
    #         modifications.append(current_mod)
        
    #     return modifications
    
    # def _extract_expected_outcome(self, text: str) -> Dict[str, Any]:
    #     """Extract expected outcome"""
    #     outcome = {}
    #     for line in text.split('\n'):
    #         if line.startswith('- New number of cycles:'):
    #             outcome['new_cycles'] = int(line.split(':')[1].strip())
    #         elif line.startswith('- New cycle locations:'):
    #             outcome['new_locations'] = eval(line.split(':')[1].strip())
    #         elif line.startswith('- Changes in persistence:'):
    #             outcome['persistence_changes'] = line.split(':')[1].strip()
    #     return outcome
    


 


        

	from typing import Dict, List, Any
	import re

	def _extract_section(text: str, start_marker: str, end_marker: str) -> str:
	"""Extract content between two markers"""
	start = text.find(start_marker)
	if start == -1:
	return ""
	start += len(start_marker)
	end = text.find(end_marker, start)
	if end == -1:
	return ""
	return text[start:end].strip()

	class AnswerExtractor:
	def __init__(self, task_name):
	"""Initialize answer extractor"""
	self.task_name = task_name

	def extract_answers(self, response):
	"""Extract answers based on task type"""
	try:
	task_extractors = {
	"S_0D": self.extract_S_0D,
	"S_1D": self.extract_S_1D,
	"S_Modification": self.extract_S_Modification,
	"M_Birth": self.extract_M_Birth,
	"M_Merge": self.extract_M_Merge,
	"M_Filtration": self.extract_M_Filtration,
	"H_Selection": self.extract_H_Selection,
	"H_Generation": self.extract_H_Generation,
	"R_Selection": self.extract_R_Selection,
	"R_Generation": self.extract_R_Generation,
	"R_Directly": self.extract_R_Directly
	}

	answer = task_extractors.get(self.task_name)(response) if self.task_name in task_extractors else None

	return answer
	except Exception as e:
	print(f"Error extracting answer: {str(e)}")
	return None


	def extract_S_0D(self, answer: str) -> Dict[str, Any]:
	"""Extract information from 0-dimensional topology structure identification answer"""
	try:
	# Extract the answer section
	answer_section = answer
	if "Answer:" in answer:
	answer_section = answer.split("Answer:")[-1].strip()

	# Extract the filtration value with more flexible pattern matching
	value_match = re.search(r'connected components:\s*(\d+)', answer_section)
	if not value_match:
	return {"error": "connected components not found"}

	# Parse the value
	try:
	value = int(value_match.group(1).strip())
	return {
	"connected_components": value
	}
	except ValueError as e:
	return {"error": f"Error parsing value: {str(e)}"}

	except Exception as e:
	return {"error": f"Error during extraction: {str(e)}"}

	def extract_S_1D(self, answer: str) -> Dict[str, Any]:
	"""Extract information from 1-dimensional topology structure identification answer"""
	try:
	# Extract the answer section
	answer_section = answer
	if "Answer:" in answer:
	answer_section = answer.split("Answer:")[-1].strip()

	# Extract the filtration value with more flexible pattern matching
	value_match = re.search(r'cycle holes:\s*(\d+)', answer_section)
	if not value_match:
	return {"error": "cycle holes not found"}

	# Parse the value
	try:
	value = int(value_match.group(1).strip())
	return {
	"cycle_holes": value
	}
	except ValueError as e:
	return {"error": f"Error parsing value: {str(e)}"}

	except Exception as e:
	return {"error": f"Error during extraction: {str(e)}"}


	def extract_S_Modification(self, answer: str) -> Dict[str, Any]:
	"""Extract information from graph structure modification answer"""
	try:
	# Extract the answer section
	answer_section = answer
	if "Answer:" in answer:
	answer_section = answer.split("Answer:")[-1].strip()

	# Try multiple matching patterns
	patterns = [
	r'Edge to add:\s\[(.?)\]', # Match "Edge to add: [0, 7]" format
	r'Edge to add:\s\((\d+)\s,\s*(\d+)\)', # Match "Edge to add: (0, 7)" format
	r'Edge to add:\s(\d+)\s-\s*(\d+)', # Match "Edge to add: 0-7" format
	r'Edge to add:\s(\d+)\s,\s*(\d+)' # Match "Edge to add: 0, 7" format
	]

	for pattern in patterns:
	value_match = re.search(pattern, answer_section)
	if value_match:
	try:
	if pattern == r'Edge to add:\s\[(.?)\]':
	# Handle [0, 7] format
	values_str = value_match.group(1).strip()
	values = [int(x.strip()) for x in values_str.split(',')]
	else:
	# Handle other formats
	values = [int(value_match.group(1)), int(value_match.group(2))]

	return {
	"edge_to_add": values
	}
	except (ValueError, IndexError):
	continue

	return {"error": "Edge to add not found or invalid format"}

	except Exception as e:
	return {"error": f"Error during extraction: {str(e)}"}


	def extract_M_Birth(self, answer: str) -> Dict[str, Any]:
	"""Extract birth time calculation task answer"""
	try:
	# Extract the answer section
	answer_section = answer
	if "Answer:" in answer:
	answer_section = answer.split("Answer:")[-1].strip()

	# Extract the filtration value
	value_match = re.search(r'birth time:\s\[(.?)\]', answer_section)
	if not value_match:
	return {"error": "birth_time not found"}

	# Parse the values
	try:
	values = [self._parse_number(x) for x in value_match.group(1).split(',')]
	return {
	"birth_time": values
	}
	except ValueError as e:
	return {"error": f"Error parsing : {str(e)}"}

	except Exception as e:
	return {"error": f"Error during extraction: {str(e)}"}

	def extract_M_Merge(self, answer: str) -> Dict[str, Any]:
	"""Extract information from 0-dimensional persistent homology calculation task answer"""
	try:
	# Extract the answer section
	answer_section = answer
	if "Answer:" in answer:
	answer_section = answer.split("Answer:")[-1].strip()

	# Extract the filtration value
	value_match = re.search(r'death time:\s\[(.?)\]', answer_section)
	if not value_match:
	return {"error": "death_time not found"}

	# Parse the values
	try:
	values = [self._parse_number(x) for x in value_match.group(1).split(',')]
	return {
	"death_time": values
	}
	except ValueError as e:
	return {"error": f"Error parsing : {str(e)}"}

	except Exception as e:
	return {"error": f"Error during extraction: {str(e)}"}

	def extract_M_Filtration(self,answer:str) -> Dict[str, Any]:
	try:
	# Extract the answer section
	answer_section = answer
	if "Answer:" in answer:
	answer_section = answer.split("Answer:")[-1].strip()

	# Extract the filtration value
	value_match = re.search(r'connected components:\s\[(.?)\]', answer_section)
	if not value_match:
	return {"error": "connected components not found"}

	# Parse the values
	try:
	values = [self._parse_number(x) for x in value_match.group(1).split(',')]
	return {
	"connected_components": values
	}
	except ValueError as e:
	return {"error": f"Error parsing : {str(e)}"}

	except Exception as e:
	return {"error": f"Error during extraction: {str(e)}"}

	def extract_H_Selection(self, answer: str) -> Dict[str, Any]:
	"""Extract selected filtration method from the response"""
	try:
	# Extract the answer section
	answer_section = answer
	if "Answer:" in answer:
	answer_section = answer.split("Answer:")[-1].strip()
	# Try multiple matching patterns
	patterns = [
	r'Method:\s*([\w-]+)', # Match "Method: k-shell" format
	r'Method:\s*\[([\w-]+)\]', # Match "Method: [k-shell]" format
	r'selected_method:\s*([\w-]+)', # Match "selected_method: k-shell" format
	r'Selected Method:\s*([\w-]+)' # Match "Selected Method: k-shell" format
	]

	for pattern in patterns:
	value_match = re.search(pattern, answer_section, re.IGNORECASE)
	if value_match:
	method = value_match.group(1).strip().lower()
	# Validate method name
	valid_methods = ['degree', 'betweenness', 'k-shell', 'closeness', 'weight', 'eigenvector']
	if method in valid_methods:
	return {
	"selected_method": method
	}

	return {"error": "Method not found or invalid"}

	except Exception as e:
	return {"error": f"Error during extraction: {str(e)}"}


	def extract_H_Generation(self, answer: str) -> Dict[str, Any]:
	"""Extract information from filteration value selection task answer"""
	try:
	# Extract the answer section
	answer_section = answer
	if "Answer:" in answer:
	answer_section = answer.split("Answer:")[-1].strip()

	# Extract the filtration value
	value_match = re.search(r'filtration value:\s\[(.?)\]', answer_section)
	if not value_match:
	return {"error": "Filtration value not found"}

	# Parse the values
	try:
	values = [int(x.strip()) for x in value_match.group(1).split(',')]
	return {
	"selected_filtration_values": values
	}
	except ValueError as e:
	return {"error": f"Error parsing filtration values: {str(e)}"}

	except Exception as e:
	return {"error": f"Error during extraction: {str(e)}"}

	def extract_filtration_edge_construction(self, answer: str) -> Dict[str, Any]:
	"""Extract information from filtration edge construction task answer"""
	result = {
	"filtration": {}
	}

	try:
	# Extract filtration process
	filtration_section = _extract_section(answer, "===FILTRATION_START===", "===FILTRATION_END===")
	result["filtration"] = self._parse_filtration_edges(filtration_section)

	# Validate results
	if not result["filtration"]:
	print("Warning: Failed to extract filtration process")
	print("Filtration process:", result["filtration"])

	except Exception as e:
	import traceback
	print(f"Error during extraction: {str(e)}")
	print("Error details:")
	print(traceback.format_exc())
	return result # Return partially parsed results instead of None

	return result

	def extract_simplicial_complex_construction(self, answer: str) -> Dict[str, Any]:
	"""
	Extract answer for simplicial_complex_construction task

	Parameters:
	answer: Model generated answer text

	Returns:
	dict: Contains extracted simplicial complex information
	"""
	try:
	# Extract simplicial complex section
	simplex_text = self._extract_section(answer, "===SIMPLICIAL_COMPLEX_START===", "===SIMPLICIAL_COMPLEX_END===")
	if not simplex_text:
	return {"error": "Simplicial complex section not found"}

	# Parse simplicial complex
	simplices = {}

	for line in simplex_text.split('\n'):
	line = line.strip()
	if not line:
	continue

	# Check if it's a simplex
	if line.startswith('[') and line.endswith(']'):
	try:
	# Parse node list and filtration value
	content = line[1:-1] # Remove outer brackets
	nodes_part, value_part = content.split('),')
	nodes = [int(x.strip()) for x in nodes_part[1:].split(',')] # Remove inner brackets
	value = float(value_part.strip())

	if len(nodes) == 3: # Only process 2-dimensional simplices (triangles)
	if value not in simplices:
	simplices[value] = []
	simplices[value].append(nodes)
	except (ValueError, IndexError) as e:
	print(f"Error parsing simplex: {line}, error: {str(e)}")
	continue

	return {
	"simplicial_complexes": simplices
	}

	except Exception as e:
	return {"error": f"Error during extraction: {str(e)}"}

	def _parse_number(self, value_str: str) -> float:
	"""Parse number intelligently, try integer first, then float"""
	value_str = value_str.strip()
	try:
	# Try parsing as integer first
	return int(value_str)
	except ValueError:
	try:
	# If integer parsing fails, try parsing as float
	value = float(value_str)
	# If it's an integer (no decimal part), return integer
	if value.is_integer():
	return int(value)
	return value
	except ValueError:
	raise ValueError(f"Cannot parse number: {value_str}")

	def extract_R_Selection(self, answer: str) -> Dict[str, Any]:
	"""Extract selected filtration method from the response"""
	try:
	# Extract the answer section
	answer_section = answer
	if "Answer:" in answer:
	answer_section = answer.split("Answer:")[-1].strip()

	# Try multiple matching patterns
	patterns = [
	r'Method:\s*(\w+)', # Match "Method: weight" format
	r'Method:\s\[(.?)\]', # Match "Method: [weight]" format
	r'selected_method:\s*(\w+)', # Match "selected_method: weight" format
	r'Selected Method:\s*(\w+)' # Match "Selected Method: weight" format
	]

	for pattern in patterns:
	value_match = re.search(pattern, answer_section, re.IGNORECASE)
	if value_match:
	method = value_match.group(1).strip().lower()
	# 验证方法名称是否有效
	valid_methods = ['degree', 'betweenness', 'k-shell', 'closeness', 'weight','eigenvector']
	if method in valid_methods:
	return {
	"selected_method": method
	}

	return {"error": "Method not found or invalid"}

	except Exception as e:
	return {"error": f"Error during extraction: {str(e)}"}


	def extract_R_Generation(self, answer: str) -> Dict[str, Any]:
	"""Extract filtration values from the response"""
	try:
	# Extract content after "Answer:" if present
	answer_section = answer
	if "Answer:" in answer:
	answer_section = answer.split("Answer:")[-1].strip()

	# Match pattern like Filtration value: [0.1,0.4,0.5,...]
	pattern = r'Filtration\svalue[s]?:\s\[([^\]]+)\]'
	match = re.search(pattern, answer_section, re.IGNORECASE)
	if not match:
	return {"error": "Filtration values not found"}

	# Extract numbers inside brackets, split by comma and convert to float
	nums_str = match.group(1)
	values: List[float] = []
	for part in nums_str.split(','):
	part = part.strip()
	if part:
	try:
	values.append(float(part))
	except ValueError:
	return {"error": f"Cannot convert '{part}' to float"}

	return {"filtration_values": values}

	except Exception as e:
	return {"error": f"Error during extraction: {str(e)}"}

	def extract_R_Directly(self, answer: str) -> Dict[str, Any]:
	"""Extract category classification from the response"""
	# Get content after "Answer:" if present
	if "Answer:" in answer:
	answer_section = answer.split("Answer:")[-1].strip()
	else:
	answer_section = answer
	pattern = r'Category:\s[\[\(]\s([\d\.\s,]+)[\]\)]\s,\s[\[\(]\s*([\d\.\s,]+)[\]\)]'
	match = re.search(pattern, answer_section, re.IGNORECASE \| re.DOTALL)
	if not match:
	return {"error": "Category format not found or incorrect"}

	def parse_group(group_str: str) -> List[int]:
	return [int(float(x.strip())) for x in group_str.split(',') if x.strip()]

	category1 = parse_group(match.group(1))
	category2 = parse_group(match.group(2))

	all_indices = sorted(category1 + category2)
	if all_indices != [1, 2, 3, 4]:
	return {"error": f"Graph indices must be [1, 2, 3, 4], got: {all_indices}"}

	return {
	"categories": [category1, category2]
	}

	# def _parse_filtration_edges(self, section: str) -> Dict[float, List[Tuple[int, int]]]:
	# """Parse filtration process, specific to the format of filtration edge construction task"""
	# filtration = {}
	# current_value = None
	# for line in section.split('\n'):
	# line = line.strip()
	# if line.startswith('**Value='):
	# value_part = line.replace('**', '').replace('Value=', '').strip()
	# current_value = float(value_part)
	# filtration[current_value] = []
	# elif line.startswith('(') and line.endswith(')'):
	# try:
	# u, v = map(int, line[1:-1].split(','))
	# filtration[current_value].append((u, v))
	# except:
	# print(f"Cannot parse edge: {line}")
	# return filtration


	# def extract_structure_identification(self, answer: str) -> Dict[str, Any]:
	# """Extract information from topology structure identification answer"""
	# result = {
	# "cavities": [],
	# "temporal_evolution": {}
	# }

	# # Extract cavity information
	# if "2-DIMENSIONAL CAVITIES:" in answer:
	# cavities_section = self._extract_section(
	# answer, "2-DIMENSIONAL CAVITIES:", "TEMPORAL EVOLUTION:"
	# )
	# result["cavities"] = self._extract_cavities(cavities_section)

	# # Extract temporal evolution
	# if "TEMPORAL EVOLUTION:" in answer:
	# evolution_section = answer.split("TEMPORAL EVOLUTION:")[1]
	# result["temporal_evolution"] = self._extract_temporal_evolution(evolution_section)

	# return result


	# def extract_simplex_structure_identification(self, answer: str) -> Dict[str, Any]:
	# """Extract information from simplex structure identification answer"""
	# result = {
	# "simplex_count": 0
	# }

	# lines = answer.strip().split('\n')
	# for line in lines:
	# line = line.strip()
	# if line.startswith('2维单纯形数量：'):
	# count_str = line.split('：')[1].strip()
	# try:
	# result["simplex_count"] = int(count_str)
	# except ValueError:
	# # Keep default value 0 if cannot parse as integer
	# pass

	# return result

	# def _extract_section(self, text: str, start_marker: str, end_marker: str) -> str:
	# """Extract text between two markers"""
	# if start_marker in text and end_marker in text:
	# start_idx = text.find(start_marker) + len(start_marker)
	# end_idx = text.find(end_marker)
	# return text[start_idx:end_idx].strip()
	# return ""




	# def _extract_list(self, text: str) -> List:
	# """Extract list from text"""
	# items = text.split(':')[1].strip()
	# if items.startswith('[') and items.endswith(']'):
	# return eval(items)
	# return []

	# def _extract_feature_info(self, line: str) -> Dict[str, Any]:
	# """Extract feature information from text"""
	# info = {}
	# if 'Birth time:' in line:
	# info['birth'] = float(line.split(':')[1].strip())
	# elif 'Death time:' in line:
	# info['death'] = float(line.split(':')[1].strip())
	# elif 'Persistence:' in line:
	# info['persistence'] = float(line.split(':')[1].strip())
	# elif 'Description:' in line:
	# info['description'] = line.split(':')[1].strip()
	# return info


	# def _extract_cavities(self, text: str) -> List[Dict[str, Any]]:
	# """Extract cavity information"""
	# cavities = []
	# current_cavity = None

	# for line in text.split('\n'):
	# if line.startswith('Cavity'):
	# if current_cavity:
	# cavities.append(current_cavity)
	# current_cavity = {}
	# elif current_cavity is not None and line.startswith('-'):
	# key = line.split(':')[0].strip('- ').lower()
	# value = line.split(':')[1].strip()
	# if key in ['birth threshold', 'death threshold', 'persistence']:
	# value = float(value)
	# elif key in ['nodes', 'edges']:
	# value = eval(value)
	# current_cavity[key] = value

	# if current_cavity:
	# cavities.append(current_cavity)

	# return cavities

	# def _extract_temporal_evolution(self, text: str) -> Dict[float, Dict[str, List[int]]]:
	# """Extract temporal evolution information"""
	# evolution = {}
	# current_threshold = None

	# for line in text.split('\n'):
	# if line.startswith('Threshold'):
	# current_threshold = float(line.split()[1])
	# evolution[current_threshold] = {
	# 'active': [],
	# 'new': [],
	# 'disappeared': []
	# }
	# elif current_threshold is not None and line.startswith('-'):
	# key = line.split(':')[0].strip('- ').lower()
	# value = eval(line.split(':')[1].strip())
	# evolution[current_threshold][key] = value

	# return evolution

	# def _extract_current_state(self, text: str) -> Dict[str, Any]:
	# """Extract current state information"""
	# state = {}
	# for line in text.split('\n'):
	# if line.startswith('- Number of cycles:'):
	# state['cycles'] = int(line.split(':')[1].strip())
	# elif line.startswith('- Cycle locations:'):
	# state['locations'] = eval(line.split(':')[1].strip())
	# return state

	# def _extract_proposed_modifications(self, text: str) -> List[Dict[str, Any]]:
	# """Extract proposed modifications"""
	# modifications = []
	# current_mod = None

	# for line in text.split('\n'):
	# if line.startswith('Modification'):
	# if current_mod:
	# modifications.append(current_mod)
	# current_mod = {}
	# elif current_mod is not None and line.startswith('-'):
	# key = line.split(':')[0].strip('- ').lower()
	# value = line.split(':')[1].strip()
	# if key == 'new edge':
	# value = tuple(map(int, value.split('-')))
	# elif key == 'expected new cycles':
	# value = eval(value)
	# current_mod[key] = value

	# if current_mod:
	# modifications.append(current_mod)

	# return modifications

	# def _extract_expected_outcome(self, text: str) -> Dict[str, Any]:
	# """Extract expected outcome"""
	# outcome = {}
	# for line in text.split('\n'):
	# if line.startswith('- New number of cycles:'):
	# outcome['new_cycles'] = int(line.split(':')[1].strip())
	# elif line.startswith('- New cycle locations:'):
	# outcome['new_locations'] = eval(line.split(':')[1].strip())
	# elif line.startswith('- Changes in persistence:'):
	# outcome['persistence_changes'] = line.split(':')[1].strip()
	# return outcome