"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-07 10:52:40.421460
"""

```python
from typing import List, Dict


class ReasoningEngine:
    """
    A simple reasoning engine to solve limited reasoning sophistication problems.
    
    This engine takes a list of rules represented as functions and applies them sequentially
    to a given set of inputs to derive conclusions.
    """

    def __init__(self, rules: List[callable]):
        self.rules = rules

    def apply_rules(self, input_data: Dict[str, int]) -> Dict[str, bool]:
        """
        Apply the defined rules on the input data and return the conclusion.

        :param input_data: A dictionary of inputs with keys as feature names and values as integers.
        :return: A dictionary containing the conclusions based on applied rules.
        """
        conclusions = {}
        for rule in self.rules:
            result = rule(input_data)
            if isinstance(result, bool):
                conclusions[rule.__name__] = result
        return conclusions

    def add_rule(self, new_rule: callable) -> None:
        """
        Add a new rule to the engine.

        :param new_rule: A function that takes input data and returns a boolean conclusion.
        """
        self.rules.append(new_rule)


def is_even(input_data: Dict[str, int]) -> bool:
    """Check if the value associated with 'number' in input_data is even."""
    return input_data.get('number', 0) % 2 == 0


def is_positive(input_data: Dict[str, int]) -> bool:
    """Check if the value associated with 'number' in input_data is positive."""
    return input_data.get('number', 0) > 0


if __name__ == "__main__":
    # Create a reasoning engine with initial rules
    initial_rules = [is_even, is_positive]
    reasoning_engine = ReasoningEngine(initial_rules)

    # Example usage of the reasoning engine
    input_data = {'number': 4}
    conclusions = reasoning_engine.apply_rules(input_data)
    print(conclusions)  # Output: {'is_even': True, 'is_positive': True}

    # Adding a new rule to the engine
    def is_odd(input_data: Dict[str, int]) -> bool:
        """Check if the value associated with 'number' in input_data is odd."""
        return not is_even(input_data)

    reasoning_engine.add_rule(is_odd)
    conclusions = reasoning_engine.apply_rules({'number': 3})
    print(conclusions)  # Output: {'is_even': False, 'is_positive': True, 'is_odd': True}
```