"""
Pattern 203: Deductive Reasoning Pattern

Applies general rules to specific cases to draw logical conclusions.
If premises are true, conclusion must be true (valid deduction).
"""

from typing import Dict, Any, List
from dataclasses import dataclass
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI


@dataclass
class Premise:
    """A premise in deductive reasoning."""
    statement: str
    premise_type: str = "general"  # general, specific, conditional


@dataclass
class DeductiveArgument:
    """A deductive argument."""
    premises: List[Premise]
    conclusion: str
    is_valid: bool = False
    explanation: str = ""


class DeductiveReasoningPattern:
    """
    Deductive Reasoning Pattern - Logical inference from premises.
    
    Applies formal logic: given premises, deduce valid conclusions.
    Checks validity of arguments.
    """
    
    def __init__(self, model_name: str = "gpt-4"):
        self.llm = ChatOpenAI(model=model_name, temperature=0.3)
        self.arguments: List[DeductiveArgument] = []
    
    def apply_modus_ponens(self, conditional: str, antecedent: str) -> str:
        """Apply modus ponens: If P then Q, P is true, therefore Q."""
        prompt = ChatPromptTemplate.from_messages([
            ("system", "Apply modus ponens deduction: If P then Q, and P is true, then Q must be true."),
            ("human", """Conditional: {conditional}
Antecedent: {antecedent}

What can we deduce? Provide the conclusion:""")
        ])
        
        chain = prompt | self.llm
        response = chain.invoke({"conditional": conditional, "antecedent": antecedent})
        return response.content
    
    def validate_argument(self, premises: List[str], conclusion: str) -> DeductiveArgument:
        """Validate a deductive argument."""
        print(f"\n=== Validating Deductive Argument ===")
        print(f"Premises: {len(premises)}")
        
        prompt = ChatPromptTemplate.from_messages([
            ("system", "Analyze if the conclusion logically follows from the premises. "
                      "Check for validity using formal logic rules."),
            ("human", """Premises:
{premises}

Proposed Conclusion: {conclusion}

Is this argument valid? Respond: VALID or INVALID|explanation""")
        ])
        
        chain = prompt | self.llm
        response = chain.invoke({
            "premises": "\n".join([f"{i+1}. {p}" for i, p in enumerate(premises)]),
            "conclusion": conclusion
        })
        
        # Parse validity
        content = response.content.strip()
        is_valid = content.startswith("VALID")
        
        parts = content.split('|')
        explanation = parts[1].strip() if len(parts) > 1 else content
        
        argument = DeductiveArgument(
            premises=[Premise(p) for p in premises],
            conclusion=conclusion,
            is_valid=is_valid,
            explanation=explanation
        )
        
        self.arguments.append(argument)
        
        print(f"Validity: {'VALID' if is_valid else 'INVALID'}")
        return argument
    
    def run(self, premises: List[str], conclusion: str) -> Dict[str, Any]:
        """Perform deductive reasoning."""
        print(f"\n=== Deductive Reasoning Pattern ===")
        
        argument = self.validate_argument(premises, conclusion)
        
        return {
            "pattern": "DeductiveReasoning",
            "premises": premises,
            "conclusion": conclusion,
            "is_valid": argument.is_valid,
            "explanation": argument.explanation
        }


# Example usage
if __name__ == "__main__":
    print("=== Deductive Reasoning Pattern Demo ===\n")
    
    pattern = DeductiveReasoningPattern()
    
    # Classic syllogism
    print("Example 1: Classic Syllogism")
    result1 = pattern.run(
        premises=[
            "All humans are mortal",
            "Socrates is a human"
        ],
        conclusion="Socrates is mortal"
    )
    print(f"Valid: {result1['is_valid']}")
    print(f"Explanation: {result1['explanation']}")
    
    # Modus ponens
    print("\n" + "="*60)
    print("Example 2: Modus Ponens")
    result2 = pattern.run(
        premises=[
            "If it rains, the ground gets wet",
            "It is raining"
        ],
        conclusion="The ground is wet"
    )
    print(f"Valid: {result2['is_valid']}")
    
    # Invalid argument
    print("\n" + "="*60)
    print("Example 3: Invalid Argument (Affirming the consequent)")
    result3 = pattern.run(
        premises=[
            "If it rains, the ground gets wet",
            "The ground is wet"
        ],
        conclusion="It rained"
    )
    print(f"Valid: {result3['is_valid']}")
    print(f"Explanation: {result3['explanation']}")
    
    print("\n✓ Deductive reasoning completed!")

    

Agentic Architecture Pattern: Deductive Reasoning

Pattern 203: 203 Deductive Reasoning Pattern – Line-by-Line Explanation

Overview

Pattern 203: Deductive Reasoning Pattern

Applies general rules to specific cases to draw logical conclusions. If premises are true, conclusion must be true (valid deduction).

Code Structure Analysis

File Information

• Pattern Number: 203
• Pattern Name: 203 Deductive Reasoning Pattern
• File Path: patterns\advanced_reasoning\203_deductive_reasoning_pattern.py
• Total Lines: 156

Detailed Code Explanation

Module Docstring

"""
Pattern 203: Deductive Reasoning Pattern

Applies general rules to specific cases to draw logical conclusions.
If premises are true, conclusion must be true (valid deduction).
"""

Explanation: This module docstring describes the purpose and key features of the 203 Deductive Reasoning Pattern pattern.

Imports Section

from typing import Dict, Any, List
from dataclasses import dataclass
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI  # First 20 imports shown

Explanation: The module imports necessary dependencies: – from typing import Dict, Any, List: Type hints for better code documentation – from dataclasses import dataclass: Data class decorators for clean data structures – from langchain_core.prompts import ChatPromptTemplate: LangChain framework integration – from langchain_openai import ChatOpenAI: LangChain framework integration

Classes

Premise (Line 15)

Description: A premise in deductive reasoning.

DeductiveArgument (Line 22)

Description: A deductive argument.

DeductiveReasoningPattern (Line 30)

Description: Deductive Reasoning Pattern – Logical inference from premises.

Applies formal logic: given premises, deduce valid conclusions. Checks validity of arguments.

Methods:

__init__ (Line 38)

def __init__(self, model_name):
    """No method docstring."""

Purpose: No method docstring.

Parameters: – self: Instance reference – model_name: LLM model to use (e.g., “gpt-4”)

apply_modus_ponens (Line 42)

def apply_modus_ponens(self, conditional, antecedent):
    """Apply modus ponens: If P then Q, P is true, therefore Q."""

Purpose: Apply modus ponens: If P then Q, P is true, therefore Q.

Parameters: – self: Instance reference – conditional: Parameter for conditional – antecedent: Parameter for antecedent

validate_argument (Line 56)

def validate_argument(self, premises, conclusion):
    """Validate a deductive argument."""

Purpose: Validate a deductive argument.

Parameters: – self: Instance reference – premises: Parameter for premises – conclusion: Parameter for conclusion

run (Line 97)

def run(self, premises, conclusion):
    """Perform deductive reasoning."""

Purpose: Perform deductive reasoning.

Parameters: – self: Instance reference – premises: Parameter for premises – conclusion: Parameter for conclusion

Design Patterns Used

• Strategy Pattern: Different execution strategies for various scenarios
• State Pattern: Managing different states in the workflow
• Chain of Responsibility: Sequential processing through workflow nodes
• Observer Pattern: Tracking and monitoring pattern execution
• Factory Pattern: Creating instances with proper configuration

Usage Example

# Initialize the pattern
pattern = Premise(name="example", model_name="gpt-4")

# Configure and execute
result = pattern.execute(data={"key": "value"})

# Check results
print(result)

Key Concepts

• LLM Integration: Uses LangChain/OpenAI for intelligent decision-making
• Workflow Orchestration: LangGraph manages execution flow through nodes
• State Management: TypedDict defines workflow state structure
• Error Handling: Comprehensive error handling and fallback mechanisms
• Extensibility: Designed for easy customization and extension

Extension Points

This pattern can be extended by: 1. Adding custom workflow nodes 2. Implementing additional validation logic 3. Integrating with external services 4. Customizing LLM prompts and responses 5. Adding monitoring and logging capabilities