experiments/learnability/exp_pattern_prover/pattern_prover.py

#!/usr/bin/env python3
"""
Pattern-based baseline prover using backward chaining heuristics.
Works with Peano's PyProofState and action system.
"""

import re
import json
import os
from typing import Optional, List
from dataclasses import dataclass

import peano
from proofsearch import ProofSearchResult, TreeSearchNode, HolophrasmNode
from action import ProofAction


@dataclass
class PatternProverConfig:
    """Configuration for pattern-based prover."""
    max_depth: int = 30
    max_iterations: int = 5000
    verbose: bool = False
    log_file: Optional[str] = None  # Path to log file for detailed logging


class PatternProver:
    """
    Pattern-based baseline prover using backward chaining heuristics.
    Works with Peano's PyProofState and action system.
    """
    
    def __init__(self, config: PatternProverConfig = None):
        self.config = config or PatternProverConfig()
        self._iterations = 0
        self._log_entries = []  # Store log entries for this problem
        self._current_problem = None
        self._solution_path = []  # Track solution path (list of (node, action) tuples)
        
    def proof_search(self, problem: str, state: peano.PyProofState):
        """
        Pattern-based proof search.
        
        Args:
            problem: Problem name (unused, for interface compatibility)
            state: Initial Peano proof state
            
        Returns:
            ProofSearchResult compatible with ProofSearchAgent
        """
        self._iterations = 0
        self._log_entries = []
        self._current_problem = problem
        
        # Log initial state
        initial_goal = state.format_goal()
        self._log(f"Starting proof search for problem: {problem}")
        self._log(f"Initial goal: {initial_goal}")
        
        root = TreeSearchNode(HolophrasmNode([state]))
        
        # Try to solve using pattern-based search
        solved = self._pattern_search(root)
        
        # Write log if configured
        if self.config.log_file:
            self._write_log()
        
        # Extract examples (empty for baseline)
        examples = []
        
        return ProofSearchResult(
            problem=problem,
            success=solved,
            root=root,
            examples=examples,
            iterations=self._iterations
        )
    
    def _log(self, message: str, goal: str = None, action: str = None):
        """Log a message with optional goal and action."""
        entry = {
            'iteration': self._iterations,
            'message': message,
        }
        if goal:
            entry['goal'] = goal
        if action:
            entry['action'] = str(action)
        self._log_entries.append(entry)
        
        if self.config.verbose:
            print(f"[{self._iterations}] {message}")
            if goal:
                print(f"  Goal: {goal}")
            if action:
                print(f"  Action: {action}")
    
    def _write_log(self):
        """Write log entries to file."""
        log_data = {
            'problem': self._current_problem,
            'solved': len(self._log_entries) > 0 and 'Solution found' in self._log_entries[-1].get('message', ''),
            'iterations': self._iterations,
            'log_entries': self._log_entries
        }
        
        # Append to log file (one JSON object per line)
        os.makedirs(os.path.dirname(self.config.log_file) if os.path.dirname(self.config.log_file) else '.', exist_ok=True)
        with open(self.config.log_file, 'a') as f:
            f.write(json.dumps(log_data) + '\n')
    
    
    def _pattern_search(self, root: TreeSearchNode) -> bool:
        """Recursive pattern-based search using DFS."""
        return self._pattern_search_recursive(root, depth=0)
    
    def _pattern_search_recursive(self, node: TreeSearchNode, depth: int) -> bool:
        """Recursive DFS with pattern-based action selection."""
        if depth > self.config.max_depth:
            return False
        
        if node.is_solved():
            self._log("Solution found!", goal=node.state_node.goal() if hasattr(node.state_node, 'goal') else None)
            return True
        
        if node.is_dead():
            return False
        
        if self._iterations >= self.config.max_iterations:
            self._log("Max iterations reached")
            return False
        
        self._iterations += 1
        
        # Special handling for conjunctive nodes - all children must be solved
        if node.state_node.is_conjunctive():
            return self._solve_conjunctive_node(node, depth)
        
        # Get current state
        if not hasattr(node.state_node, '_proof_states') or not node.state_node._proof_states:
            return False
        
        state = node.state_node._proof_states[0]
        goal_str = state.format_goal()
        
        # Get available actions
        actions = node.state_node.actions
        if not actions:
            return False
        
        # Pattern-based action selection - get prioritized list
        prioritized_actions = self._prioritize_actions_by_pattern(state, goal_str, actions)
        
        # Initialize children list if needed
        if node._children is None:
            node._children = []
        
        # Try actions in priority order
        for action in prioritized_actions:
            try:
                # Log the action being tried
                self._log(f"Trying action (depth {depth})", goal=goal_str, action=str(action))
                
                # Expand the state node with the action
                expanded_state = node.state_node.expand(action)
                
                # Create child TreeSearchNode and try it
                child_node = TreeSearchNode(expanded_state, parent=(node, action))
                
                # Store child in parent's children list (needed for proof reconstruction)
                node._children.append(child_node)
                
                if self._pattern_search_recursive(child_node, depth + 1):
                    # Mark this node with the solution action
                    node._solution_action = action
                    return True
            except Exception as e:
                self._log(f"Error expanding action: {e}", goal=goal_str, action=str(action))
                continue
        
        return False
    
    def _solve_conjunctive_node(self, node: TreeSearchNode, depth: int) -> bool:
        """Solve a conjunctive node - all children must be solved."""
        # Get available actions (string indices for subgoals)
        actions = node.state_node.actions
        if not actions:
            return False
        
        # Initialize children list
        if node._children is None:
            node._children = []
        
        # Create child nodes for each subgoal if not already created
        while len(node._children) < len(actions):
            idx = len(node._children)
            subgoal_state = node.state_node.expand(str(idx))
            child_node = TreeSearchNode(subgoal_state, parent=(node, str(idx)))
            node._children.append(child_node)
        
        # Try to solve each subgoal in order
        for i, child_node in enumerate(node._children):
            if not child_node.is_solved():
                if not self._pattern_search_recursive(child_node, depth + 1):
                    return False  # This subgoal failed, can't solve conjunctive node
        
        # All subgoals solved - node is now solved
        # Note: For conjunctive nodes, is_solved() checks all children are solved
        # and get_solution_actions() returns [dfs(c) for c in node._children]
        return True
    
    def _prioritize_actions_by_pattern(self, state: peano.PyProofState, 
                                       goal_str: str, actions: List) -> List:
        """
        Prioritize actions based on goal pattern.
        Improved pattern matching including double negation detection.
        
        Returns:
            List of actions in priority order (highest first)
        """
        # If actions are strings (conjunctive node indices), return as-is
        if actions and isinstance(actions[0], str):
            return actions
        
        goal_clean = goal_str.strip()
        prioritized = []
        others = []
        
        # Helper to check for double negation pattern: (not (not ...))
        def is_double_negation(s: str) -> bool:
            # Match (not (not ...))
            return s.startswith('(not (not ') and s.endswith('))')
        
        # Helper to extract inner content from double negation
        def extract_from_double_negation(s: str) -> Optional[str]:
            if is_double_negation(s):
                # Remove outer (not (not ...))
                inner = s[10:-2]  # Remove "(not (not " and "))"
                return inner
            return None
        
        # PATTERN 0: Double negation (not (not A)) - try to prove A
        if is_double_negation(goal_clean):
            inner = extract_from_double_negation(goal_clean)
            # Prefer actions that can work with the inner proposition
            # This is a heuristic - we want to prove the inner, then use double negation elimination
            for a in actions:
                action_str = str(a)
                # Prefer intro actions that might help prove the inner
                if hasattr(a, 'is_intro') and a.is_intro():
                    prioritized.append(a)
                # Also prefer elimination rules that might extract from context
                elif any(name in action_str for name in ['and_el', 'and_er', 'iff_el', 'iff_er']):
                    prioritized.append(a)
                else:
                    others.append(a)
            return prioritized + others
        
        # PATTERN 1: Goal is implication [A -> B]
        if goal_clean.startswith('[') and '->' in goal_clean:
            for a in actions:
                if hasattr(a, 'is_intro') and a.is_intro():
                    prioritized.append(a)
                else:
                    others.append(a)
            return prioritized + others
        
        # PATTERN 2: Goal is conjunction (and A B)
        if goal_clean.startswith('(and '):
            for a in actions:
                action_str = str(a)
                if 'and_i' in action_str:
                    prioritized.append(a)
                else:
                    others.append(a)
            return prioritized + others
        
        # PATTERN 3: Goal is disjunction (or A B)
        if goal_clean.startswith('(or '):
            # Try or_il first, then or_ir
            or_il_actions = []
            or_ir_actions = []
            for a in actions:
                action_str = str(a)
                if 'or_il' in action_str:
                    or_il_actions.append(a)
                elif 'or_ir' in action_str:
                    or_ir_actions.append(a)
                else:
                    others.append(a)
            return or_il_actions + or_ir_actions + others
        
        # PATTERN 4: Goal is negation (not A)
        if goal_clean.startswith('(not ') and not is_double_negation(goal_clean):
            for a in actions:
                action_str = str(a)
                if 'not_i' in action_str:
                    prioritized.append(a)
                else:
                    others.append(a)
            return prioritized + others
        
        # PATTERN 5: Goal is biconditional (iff A B)
        if goal_clean.startswith('(iff '):
            for a in actions:
                action_str = str(a)
                if 'iff_i' in action_str:
                    prioritized.append(a)
                else:
                    others.append(a)
            return prioritized + others
        
        # PATTERN 6: Goal is false
        if goal_clean == 'false' or goal_clean == '(false)':
            # Look for contradiction - prefer not_e, exfalso
            for a in actions:
                action_str = str(a)
                if 'not_e' in action_str or 'exfalso' in action_str:
                    prioritized.append(a)
                else:
                    others.append(a)
            return prioritized + others
        
        # PATTERN 7: Goal is atomic - try forward chaining
        # Prefer elimination rules that can extract from context
        elimination_actions = []
        intro_actions = []
        apply_actions = []
        construct_actions = []
        
        for a in actions:
            action_str = str(a)
            # Prefer elimination rules
            if any(name in action_str for name in ['and_el', 'and_er', 'or_e', 'iff_el', 'iff_er']):
                elimination_actions.append(a)
            elif hasattr(a, 'is_intro') and a.is_intro():
                intro_actions.append(a)
            elif hasattr(a, 'is_apply') and a.is_apply():
                apply_actions.append(a)
            elif hasattr(a, 'is_construct') and a.is_construct():
                construct_actions.append(a)
            else:
                others.append(a)
        
        # Also check if we can use excluded middle for case analysis
        em_actions = []
        for a in actions:
            action_str = str(a)
            if 'em' in action_str:
                em_actions.append(a)
        
        # Order: elimination > excluded middle > apply > construct > intro > others
        return elimination_actions + em_actions + apply_actions + construct_actions + intro_actions + others


def make_pattern_prover(config=None):
    """Factory function to create pattern prover (for compatibility)."""
    if config is None:
        config = PatternProverConfig()
    return PatternProver(config)