"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-06 05:05:12.133581
"""

```python
class ReasoningEngine:
    """
    A simple reasoning engine designed to handle basic logical deductions.
    
    This class provides methods for evaluating conditions based on a set of rules,
    where each rule is represented as a function that returns a boolean value.

    Parameters:
        - rules (list[Callable[..., bool]]): List of functions representing the rules.
        - facts (dict[str, Any]): Dictionary mapping fact names to their values.

    Methods:
        - evaluate_all_rules(): Evaluates all provided rules and returns True if
                                every rule returns True; otherwise, returns False.
        - add_rule(rule: Callable[..., bool], fact_name: str, value: Any): Adds a new rule 
            based on the given fact name and value. The rule function should take no arguments
            and return a boolean.
    """

    def __init__(self, rules=None, facts=None):
        self.rules = rules if rules is not None else []
        self.facts = facts if facts is not None else {}

    def evaluate_all_rules(self) -> bool:
        """
        Evaluates all provided rules based on the current set of facts.

        Returns:
            - bool: True if every rule evaluates to True; otherwise, False.
        """
        for rule in self.rules:
            if not rule():
                return False
        return True

    def add_rule(self, rule: Callable[..., bool], fact_name: str, value: Any):
        """
        Adds a new rule based on the given fact name and value.

        Parameters:
            - rule (Callable[..., bool]): The rule function to be added.
            - fact_name (str): The name of the fact being checked in the rule.
            - value (Any): The value that the fact is expected to have for the rule to evaluate to True.
        
        Raises:
            ValueError: If the fact does not exist in self.facts.
        """
        if fact_name not in self.facts:
            raise ValueError(f"Fact '{fact_name}' does not exist.")
        self.rules.append(lambda: rule(self.facts[fact_name] == value))

# Example usage
def is_even(number: int) -> bool:
    """Check if the number is even."""
    return number % 2 == 0

if __name__ == "__main__":
    engine = ReasoningEngine()
    
    # Define facts
    engine.facts["number"] = 4
    
    # Add rules
    engine.add_rule(is_even, "number", 4)
    
    # Evaluate all rules
    print(engine.evaluate_all_rules())  # Should output: True

```

This code creates a basic reasoning engine capable of evaluating logical conditions based on predefined rules and facts. The example usage demonstrates adding a rule to check if a number is even and evaluating it.