qnty 0.0.9__py3-none-any.whl → 0.1.0__py3-none-any.whl

qnty/_backup/problem_original.py

@@ -1,1251 +0,0 @@
-"""
-Core EngineeringProblem class for engineering problem solving.
-
-This module provides the main EngineeringProblem class that coordinates
-all aspects of engineering problem definition, solving, and analysis.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
-
-from qnty.equations import Equation, EquationSystem
-
-if TYPE_CHECKING:
-    from qnty.expressions import BinaryOperation, Constant, VariableReference
-from qnty.utils.logging import get_logger
-from qnty.solving.order import Order
-from qnty.problem.reconstruction import EquationReconstructor
-from qnty.problem.metaclass import ProblemMeta
-from qnty.solving.solvers import SolverManager
-from qnty.quantities import Quantity as Qty
-from qnty.quantities import TypeSafeVariable as Variable
-from qnty.generated.units import DimensionlessUnits
-
-# Constants
-MAX_ITERATIONS_DEFAULT = 100
-TOLERANCE_DEFAULT = 1e-10
-MATHEMATICAL_OPERATORS = ['+', '-', '*', '/', ' / ', ' * ', ' + ', ' - ']
-COMMON_COMPOSITE_VARIABLES = ['P', 'c', 'S', 'E', 'W', 'Y']
-
-
-# Custom Exceptions
-class VariableNotFoundError(KeyError):
-    """Raised when trying to access a variable that doesn't exist."""
-    pass
-
-
-class EquationValidationError(ValueError):
-    """Raised when an equation fails validation."""
-    pass
-
-
-class SolverError(RuntimeError):
-    """Raised when the solving process fails."""
-    pass
-
-
-class Problem(metaclass=ProblemMeta):
-    """
-    Main container class for engineering problems.
-    
-    This class coordinates all aspects of engineering problem definition, solving, and analysis.
-    It supports both programmatic problem construction and class-level inheritance patterns
-    for defining domain-specific engineering problems.
-    
-    Key Features:
-    - Automatic dependency graph construction and topological solving order
-    - Dual solving approach: SymPy symbolic solving with numerical fallback
-    - Sub-problem composition with automatic variable namespacing
-    - Comprehensive validation and error handling
-    - Professional report generation capabilities
-    
-    Usage Patterns:
-    1. Inheritance Pattern (Recommended for domain problems):
-       class MyProblem(EngineeringProblem):
-           x = Variable("x", Qty(5.0, length))
-           y = Variable("y", Qty(0.0, length), is_known=False)
-           eq = y.equals(x * 2)
-    
-    2. Programmatic Pattern (For dynamic problems):
-       problem = EngineeringProblem("Dynamic Problem")
-       problem.add_variables(x, y)
-       problem.add_equation(y.equals(x * 2))
-    
-    3. Composition Pattern (For reusable sub-problems):
-       class ComposedProblem(EngineeringProblem):
-           sub1 = create_sub_problem()
-           sub2 = create_sub_problem()
-           # Equations can reference sub1.variable, sub2.variable
-    
-    Attributes:
-        name (str): Human-readable name for the problem
-        description (str): Detailed description of the problem
-        variables (dict[str, Variable]): All variables in the problem
-        equations (list[Equation]): All equations in the problem
-        is_solved (bool): Whether the problem has been successfully solved
-        solution (dict[str, Variable]): Solved variable values
-        sub_problems (dict[str, EngineeringProblem]): Integrated sub-problems
-    """
-    
-    def __init__(self, name: str | None = None, description: str = ""):
-        # Handle subclass mode (class-level name/description) vs explicit name
-        self.name = name or getattr(self.__class__, 'name', self.__class__.__name__)
-        self.description = description or getattr(self.__class__, 'description', "")
-        
-        # Core storage
-        self.variables: dict[str, Variable] = {}
-        self.equations: list[Equation] = []
-        
-        # Internal systems
-        self.equation_system = EquationSystem()
-        self.dependency_graph = Order()
-        
-        # Solving state
-        self.is_solved = False
-        self.solution: dict[str, Variable] = {}
-        self.solving_history: list[dict[str, Any]] = []
-        
-        # Performance optimization caches
-        self._known_variables_cache: dict[str, Variable] | None = None
-        self._unknown_variables_cache: dict[str, Variable] | None = None
-        self._cache_dirty = True
-        
-        # Validation and warning system
-        self.warnings: list[dict[str, Any]] = []
-        self.validation_checks: list[Callable] = []
-        
-        self.logger = get_logger()
-        self.solver_manager = SolverManager(self.logger)
-        
-        # Sub-problem composition support
-        self.sub_problems: dict[str, Problem] = {}
-        self.variable_aliases: dict[str, str] = {}  # Maps alias -> original variable symbol
-        
-        # Initialize equation reconstructor
-        self.equation_reconstructor = EquationReconstructor(self)
-        
-        # Auto-populate from class-level variables and equations (subclass pattern)
-        self._extract_from_class_variables()
-
-    def _extract_from_class_variables(self):
-        """Extract variables, equations, and sub-problems from class-level definitions."""
-        self._extract_sub_problems()
-        self._extract_direct_variables()
-        self._recreate_validation_checks()
-        self._create_composite_equations()
-        self._extract_equations()
-
-    def _extract_sub_problems(self):
-        """Extract and integrate sub-problems from class-level definitions."""
-        if hasattr(self.__class__, '_original_sub_problems'):
-            original_sub_problems = getattr(self.__class__, '_original_sub_problems', {})
-            for attr_name, sub_problem in original_sub_problems.items():
-                self._integrate_sub_problem(sub_problem, attr_name)
-
-    def _extract_direct_variables(self):
-        """Extract direct variables from class-level definitions."""
-        processed_symbols = set()
-        
-        # Single pass through class attributes to collect variables
-        for attr_name, attr_value in self._get_class_attributes():
-            if isinstance(attr_value, Variable):
-                # Set symbol based on attribute name (T_bar, P, etc.)
-                attr_value.symbol = attr_name
-                
-                # Skip if we've already processed this symbol
-                if attr_value.symbol in processed_symbols:
-                    continue
-                processed_symbols.add(attr_value.symbol)
-                
-                # Clone variable to avoid shared state between instances
-                cloned_var = self._clone_variable(attr_value)
-                self.add_variable(cloned_var)
-                # Set the same cloned variable object as instance attribute
-                # Use super() to bypass our custom __setattr__ during initialization
-                super().__setattr__(attr_name, cloned_var)
-
-    def _extract_equations(self):
-        """Extract and process equations from class-level definitions."""
-        equations_to_process = self._collect_class_equations()
-        
-        for attr_name, equation in equations_to_process:
-            try:
-                if self._process_equation(attr_name, equation):
-                    setattr(self, attr_name, equation)
-            except Exception as e:
-                # Log but continue - some equations might fail during class definition
-                self.logger.warning(f"Failed to process equation {attr_name}: {e}")
-                # Still set the original equation as attribute
-                setattr(self, attr_name, equation)
-
-    def _get_class_attributes(self) -> list[tuple[str, Any]]:
-        """Get all non-private class attributes efficiently."""
-        return [(attr_name, getattr(self.__class__, attr_name))
-                for attr_name in dir(self.__class__)
-                if not attr_name.startswith('_')]
-
-    def _collect_class_equations(self) -> list[tuple[str, Equation]]:
-        """Collect all equation objects from class attributes."""
-        equations_to_process = []
-        for attr_name, attr_value in self._get_class_attributes():
-            if isinstance(attr_value, Equation):
-                equations_to_process.append((attr_name, attr_value))
-        return equations_to_process
-
-    def _process_equation(self, attr_name: str, equation: Equation) -> bool:
-        """Process a single equation and add it to the problem if valid."""
-        return self._process_equation_impl(attr_name, equation)
-    
-    def _process_equation_impl(self, attr_name: str, equation: Equation) -> bool:
-        """
-        Process a single equation and determine if it should be added.
-        Returns True if the equation was successfully processed.
-        """
-        # First, update variable references to use symbols instead of names
-        updated_equation = self._update_equation_variable_references(equation)
-        
-        # Check if this equation contains delayed expressions
-        try:
-            has_delayed = self.equation_reconstructor.contains_delayed_expressions(updated_equation)
-            if has_delayed:
-                return self._handle_delayed_equation(attr_name, updated_equation)
-        except Exception as e:
-            self.logger.debug(f"Error checking delayed expressions for {attr_name}: {e}")
-        
-        # Check if this equation has invalid self-references
-        try:
-            has_self_ref = self._has_invalid_self_references(updated_equation)
-            if has_self_ref:
-                self.logger.debug(f"Skipping invalid self-referencing equation {attr_name}: {updated_equation}")
-                return False
-        except Exception as e:
-            self.logger.debug(f"Error checking self-references for {attr_name}: {e}")
-        
-        # Check if equation references non-existent variables
-        try:
-            has_missing = self._equation_has_missing_variables(updated_equation)
-            if has_missing:
-                return self._handle_equation_with_missing_variables(attr_name, updated_equation)
-        except Exception as e:
-            self.logger.debug(f"Error checking missing variables for {attr_name}: {e}")
-        
-        # Process valid equation
-        self.add_equation(updated_equation)
-        return True
-
-    def _handle_delayed_equation(self, attr_name: str, equation: Equation) -> bool:
-        """Handle equations with delayed expressions."""
-        resolved_equation = self.equation_reconstructor.resolve_delayed_equation(equation)
-        if resolved_equation:
-            self.add_equation(resolved_equation)
-            setattr(self, attr_name, resolved_equation)
-            return True
-        else:
-            self.logger.debug(f"Skipping unresolvable delayed equation {attr_name}: {equation}")
-            return False
-
-    def _handle_equation_with_missing_variables(self, attr_name: str, equation: Equation) -> bool:
-        """Handle equations that reference missing variables."""
-        # Handle conditional equations more carefully
-        if self._is_conditional_equation(equation):
-            return self._handle_conditional_equation(attr_name, equation)
-        
-        # Only attempt reconstruction for simple mathematical expressions from composition
-        if self.equation_reconstructor.should_attempt_reconstruction(equation):
-            return self._attempt_equation_reconstruction(attr_name, equation)
-        else:
-            # Skip other problematic equations
-            self.logger.debug(f"Skipping equation with missing variables {attr_name}: {equation}")
-            return False
-
-    def _handle_conditional_equation(self, attr_name: str, equation: Equation) -> bool:
-        """Handle conditional equations with missing variables."""
-        missing_vars = equation.get_all_variables() - set(self.variables.keys())
-        
-        
-        # Skip conditional equations from sub-problems in composed systems
-        if self.sub_problems and self._is_conditional_equation_from_subproblem(equation, attr_name):
-            self.logger.debug(f"Skipping conditional equation {attr_name} from sub-problem in composed system")
-            return False
-        
-        # Check for composite expressions that might be reconstructable
-        unresolvable_vars = [var for var in missing_vars
-                           if any(op in var for op in MATHEMATICAL_OPERATORS)]
-        
-        if self.sub_problems and unresolvable_vars:
-            # Before skipping, try to reconstruct conditional equations with composite expressions
-            self.logger.debug(f"Attempting to reconstruct conditional equation {attr_name} with composite variables: {unresolvable_vars}")
-            reconstructed_equation = self.equation_reconstructor.reconstruct_composite_expressions_generically(equation)
-            if reconstructed_equation:
-                self.logger.debug(f"Successfully reconstructed conditional equation {attr_name}: {reconstructed_equation}")
-                self.add_equation(reconstructed_equation)
-                setattr(self, attr_name, reconstructed_equation)
-                return True
-            else:
-                self.logger.debug(f"Failed to reconstruct conditional equation {attr_name}, trying simple substitution")
-                # Try simple substitution for basic arithmetic expressions
-                reconstructed_equation = self._try_simple_substitution(equation, missing_vars)
-                if reconstructed_equation:
-                    self.add_equation(reconstructed_equation)
-                    return True
-                else:
-                    self.add_equation(equation)
-                    return True
-        else:
-            # Try to add the conditional equation even with missing simple variables
-            self.add_equation(equation)
-            return True
-
-    def _try_simple_substitution(self, _equation: Equation, _missing_vars: set[str]) -> Equation | None:
-        """
-        Try simple substitution for basic arithmetic expressions in conditional equations.
-        
-        The real issue is that nested expressions in conditionals aren't being handled properly.
-        For now, just return None and let the equation be added as-is.
-        """
-        return None
-
-    def _fix_variable_references(self, equation: Equation) -> Equation:
-        """
-        Fix VariableReferences in equation expressions to point to Variables in problem.variables.
-        
-        This resolves issues where expression trees contain VariableReferences pointing to
-        proxy Variables from class creation time instead of the actual Variables in the problem.
-        """
-        try:
-            # Fix the RHS expression
-            fixed_rhs = self._fix_expression_variables(equation.rhs)
-            
-            # Create new equation with fixed RHS (LHS should already be correct)
-            return Equation(equation.name, equation.lhs, fixed_rhs)
-            
-        except Exception as e:
-            self.logger.debug(f"Error fixing variable references in equation {equation.name}: {e}")
-            return equation  # Return original if fixing fails
-
-    def _fix_expression_variables(self, expr):
-        """
-        Recursively fix VariableReferences in an expression tree to point to correct Variables.
-        """
-        
-        if isinstance(expr, VariableReference):
-            # Check if this VariableReference points to the wrong Variable
-            symbol = getattr(expr, 'symbol', None)
-            if symbol and symbol in self.variables:
-                correct_var = self.variables[symbol]
-                if expr.variable is not correct_var:
-                    # Create new VariableReference pointing to correct Variable
-                    return VariableReference(correct_var)
-            return expr
-            
-        elif isinstance(expr, BinaryOperation):
-            # Recursively fix left and right operands
-            fixed_left = self._fix_expression_variables(expr.left)
-            fixed_right = self._fix_expression_variables(expr.right)
-            return BinaryOperation(expr.operator, fixed_left, fixed_right)
-            
-        elif hasattr(expr, 'operand'):
-            # Recursively fix operand
-            fixed_operand = self._fix_expression_variables(expr.operand)
-            return type(expr)(expr.operator, fixed_operand)
-            
-        elif hasattr(expr, 'function_name'):
-            # Recursively fix left and right operands
-            fixed_left = self._fix_expression_variables(expr.left)
-            fixed_right = self._fix_expression_variables(expr.right)
-            return type(expr)(expr.function_name, fixed_left, fixed_right)
-            
-        elif isinstance(expr, Constant):
-            return expr
-            
-        else:
-            # Unknown expression type, return as-is
-            return expr
-
-    def _attempt_equation_reconstruction(self, attr_name: str, equation: Equation) -> bool:
-        """Attempt to reconstruct equations with composite expressions."""
-        missing_vars = equation.get_all_variables() - set(self.variables.keys())
-        self.logger.debug(f"Attempting to reconstruct equation {attr_name} with missing variables: {missing_vars}")
-        
-        reconstructed_equation = self.equation_reconstructor.reconstruct_composite_expressions_generically(equation)
-        if reconstructed_equation:
-            self.logger.debug(f"Successfully reconstructed {attr_name}: {reconstructed_equation}")
-            self.add_equation(reconstructed_equation)
-            setattr(self, attr_name, reconstructed_equation)
-            return True
-        else:
-            self.logger.debug(f"Failed to reconstruct equation {attr_name}: {equation}")
-            return False
-    
-    def _integrate_sub_problem(self, sub_problem: Problem, namespace: str) -> None:
-        """
-        Integrate a sub-problem by flattening its variables with namespace prefixes.
-        Creates a simple dotted access pattern: self.header.P becomes self.header_P
-        """
-        self.sub_problems[namespace] = sub_problem
-        
-        # Get proxy configurations if available
-        proxy_configs = getattr(self.__class__, '_proxy_configurations', {}).get(namespace, {})
-        
-        # Create a namespace object for dotted access (self.header.P)
-        namespace_obj = type('SubProblemNamespace', (), {})()
-        
-        # Add all sub-problem variables with namespace prefixes
-        for var_symbol, var in sub_problem.variables.items():
-            namespaced_var = self._create_namespaced_variable(var, var_symbol, namespace, proxy_configs)
-            self.add_variable(namespaced_var)
-            
-            # Set both namespaced access (self.header_P) and dotted access (self.header.P)
-            if namespaced_var.symbol is not None:
-                super().__setattr__(namespaced_var.symbol, namespaced_var)
-            setattr(namespace_obj, var_symbol, namespaced_var)
-        
-        # Set the namespace object for dotted access
-        super().__setattr__(namespace, namespace_obj)
-        
-        # Also add all sub-problem equations (they'll be namespaced automatically)
-        for equation in sub_problem.equations:
-            try:
-                # Skip conditional equations for variables that are overridden to known values in composition
-                if self._should_skip_subproblem_equation(equation, namespace):
-                    continue
-                    
-                namespaced_equation = self._namespace_equation(equation, namespace)
-                if namespaced_equation:
-                    self.add_equation(namespaced_equation)
-            except Exception as e:
-                self.logger.debug(f"Failed to namespace equation from {namespace}: {e}")
-
-    def _create_namespaced_variable(self, var: Variable, var_symbol: str, namespace: str, proxy_configs: dict) -> Variable:
-        """Create a namespaced variable with proper configuration."""
-        namespaced_symbol = f"{namespace}_{var_symbol}"
-        namespaced_var = self._clone_variable(var)
-        namespaced_var.symbol = namespaced_symbol
-        namespaced_var.name = f"{var.name} ({namespace.title()})"
-        
-        # Apply proxy configuration if available
-        if var_symbol in proxy_configs:
-            config = proxy_configs[var_symbol]
-            namespaced_var.quantity = config['quantity']
-            namespaced_var.is_known = config['is_known']
-        
-        return namespaced_var
-
-    def _namespace_equation(self, equation: Equation, namespace: str) -> Equation | None:
-        """
-        Create a namespaced version of an equation by prefixing all variable references.
-        """
-        try:
-            # Get all variable symbols in the equation
-            variables_in_eq = equation.get_all_variables()
-            
-            # Create mapping from original symbols to namespaced symbols
-            symbol_mapping = {}
-            for var_symbol in variables_in_eq:
-                namespaced_symbol = f"{namespace}_{var_symbol}"
-                if namespaced_symbol in self.variables:
-                    symbol_mapping[var_symbol] = namespaced_symbol
-            
-            if not symbol_mapping:
-                return None
-            
-            # Create new equation with namespaced references
-            # For LHS, we need a Variable object to call .equals()
-            # For RHS, we need proper expression structure
-            namespaced_lhs = self._namespace_expression_for_lhs(equation.lhs, symbol_mapping)
-            namespaced_rhs = self._namespace_expression(equation.rhs, symbol_mapping)
-            
-            if namespaced_lhs and namespaced_rhs:
-                equals_method = getattr(namespaced_lhs, 'equals', None)
-                if equals_method:
-                    return equals_method(namespaced_rhs)
-            
-            return None
-            
-        except Exception:
-            return None
-
-    def _namespace_expression(self, expr, symbol_mapping):
-        """
-        Create a namespaced version of an expression by replacing variable references.
-        """
-        
-        # Handle variable references
-        if isinstance(expr, VariableReference):
-            return self._namespace_variable_reference(expr, symbol_mapping)
-        elif hasattr(expr, 'symbol') and expr.symbol in symbol_mapping:
-            return self._namespace_variable_object(expr, symbol_mapping)
-        
-        # Handle operations
-        elif isinstance(expr, BinaryOperation):
-            return self._namespace_binary_operation(expr, symbol_mapping)
-        elif hasattr(expr, 'operand'):
-            return self._namespace_unary_operation(expr, symbol_mapping)
-        elif hasattr(expr, 'function_name'):
-            return self._namespace_binary_function(expr, symbol_mapping)
-        elif isinstance(expr, Constant):
-            return expr
-        else:
-            return expr
-
-    def _namespace_variable_reference(self, expr, symbol_mapping):
-        """Namespace a VariableReference object."""
-        if expr.symbol in symbol_mapping:
-            namespaced_symbol = symbol_mapping[expr.symbol]
-            if namespaced_symbol in self.variables:
-                return VariableReference(self.variables[namespaced_symbol])
-        return expr
-
-    def _namespace_variable_object(self, expr, symbol_mapping):
-        """Namespace a Variable object."""
-        namespaced_symbol = symbol_mapping[expr.symbol]
-        if namespaced_symbol in self.variables:
-            # Return VariableReference for use in expressions, not the Variable itself
-            return VariableReference(self.variables[namespaced_symbol])
-        return expr
-
-    def _namespace_binary_operation(self, expr, symbol_mapping):
-        """Namespace a BinaryOperation."""
-        namespaced_left = self._namespace_expression(expr.left, symbol_mapping)
-        namespaced_right = self._namespace_expression(expr.right, symbol_mapping)
-        return BinaryOperation(expr.operator, namespaced_left, namespaced_right)
-
-    def _namespace_unary_operation(self, expr, symbol_mapping):
-        """Namespace a UnaryFunction."""
-        namespaced_operand = self._namespace_expression(expr.operand, symbol_mapping)
-        return type(expr)(expr.operator, namespaced_operand)
-
-    def _namespace_binary_function(self, expr, symbol_mapping):
-        """Namespace a BinaryFunction."""
-        namespaced_left = self._namespace_expression(expr.left, symbol_mapping)
-        namespaced_right = self._namespace_expression(expr.right, symbol_mapping)
-        return type(expr)(expr.function_name, namespaced_left, namespaced_right)
-
-    def _namespace_expression_for_lhs(self, expr, symbol_mapping):
-        """
-        Create a namespaced version of an expression for LHS, returning Variable objects.
-        """
-        
-        if isinstance(expr, VariableReference):
-            symbol = getattr(expr, 'symbol', None)
-            if symbol and symbol in symbol_mapping:
-                namespaced_symbol = symbol_mapping[symbol]
-                if namespaced_symbol in self.variables:
-                    return self.variables[namespaced_symbol]
-            # If we can't find a mapping, return None since VariableReference doesn't have .equals()
-            return None
-        elif hasattr(expr, 'symbol') and expr.symbol in symbol_mapping:
-            # This is a Variable object
-            namespaced_symbol = symbol_mapping[expr.symbol]
-            if namespaced_symbol in self.variables:
-                return self.variables[namespaced_symbol]
-            return expr
-        else:
-            return expr
-
-    def _clone_variable(self, variable: Variable) -> Variable:
-        """Create a copy of a variable to avoid shared state without corrupting global units."""
-        # Create a new Variable with the same properties but avoid deepcopy
-        # which can corrupt global unit objects
-        cloned = Variable(
-            name=variable.name,
-            expected_dimension=variable.expected_dimension,
-            is_known=variable.is_known
-        )
-        # Set attributes that are not part of constructor
-        cloned.symbol = variable.symbol
-        cloned.quantity = variable.quantity  # Keep reference to same quantity - units must not be copied
-        
-        # Ensure the cloned variable has fresh validation checks
-        if hasattr(variable, 'validation_checks'):
-            try:
-                setattr(cloned, 'validation_checks', [])
-            except (AttributeError, TypeError):
-                # validation_checks might be read-only or not settable
-                pass
-        return cloned
-
-    def _recreate_validation_checks(self):
-        """Collect and integrate validation checks from class-level Check objects."""
-        # Clear existing checks
-        self.validation_checks = []
-        
-        # Collect Check objects from metaclass
-        class_checks = getattr(self.__class__, '_class_checks', {})
-        
-        for check in class_checks.values():
-            # Create a validation function from the Check object
-            def make_check_function(check_obj):
-                def check_function(problem_instance):
-                    return check_obj.evaluate(problem_instance.variables)
-                return check_function
-            
-            self.validation_checks.append(make_check_function(check))
-
-    def _create_composite_equations(self):
-        """
-        Create composite equations for common patterns in sub-problems.
-        This handles equations like P = min(header.P, branch.P) automatically.
-        """
-        if not self.sub_problems:
-            return
-        
-        # Common composite patterns to auto-generate
-        for var_name in COMMON_COMPOSITE_VARIABLES:
-            # Check if this variable exists in multiple sub-problems
-            sub_problem_vars = []
-            for namespace in self.sub_problems:
-                namespaced_symbol = f"{namespace}_{var_name}"
-                if namespaced_symbol in self.variables:
-                    sub_problem_vars.append(self.variables[namespaced_symbol])
-            
-            # If we have the variable in multiple sub-problems and no direct variable exists
-            if len(sub_problem_vars) >= 2 and var_name in self.variables:
-                # Check if a composite equation already exists
-                equation_attr_name = f"{var_name}_eqn"
-                if hasattr(self.__class__, equation_attr_name):
-                    # Skip auto-creation since explicit equation exists
-                    continue
-                    
-                # Auto-create composite equation
-                try:
-                    from qnty.expressions import min_expr
-                    composite_var = self.variables[var_name]
-                    if not composite_var.is_known:  # Only for unknown variables
-                        composite_expr = min_expr(*sub_problem_vars)
-                        equals_method = getattr(composite_var, 'equals', None)
-                        if equals_method:
-                            composite_eq = equals_method(composite_expr)
-                            self.add_equation(composite_eq)
-                            setattr(self, f"{var_name}_eqn", composite_eq)
-                except Exception as e:
-                    self.logger.debug(f"Failed to create composite equation for {var_name}: {e}")
-
-    def _get_equation_lhs_symbol(self, equation: Equation) -> str | None:
-        """Safely extract the symbol from equation's left-hand side."""
-        return getattr(equation.lhs, 'symbol', None)
-
-    def _is_conditional_equation(self, equation: Equation) -> bool:
-        """Check if an equation is a conditional equation."""
-        return 'cond(' in str(equation)
-
-    def _equation_has_missing_variables(self, equation: Equation) -> bool:
-        """Check if an equation references variables that don't exist in this problem."""
-        try:
-            all_vars = equation.get_all_variables()
-            missing_vars = [var for var in all_vars if var not in self.variables]
-            return len(missing_vars) > 0
-        except Exception:
-            return False
-
-    def _has_invalid_self_references(self, equation: Equation) -> bool:
-        """
-        Check if an equation has invalid self-references.
-        This catches malformed equations like 'c = max(c, c)' from class definition.
-        """
-        try:
-            # Get LHS variable - check if it has symbol attribute
-            lhs_symbol = self._get_equation_lhs_symbol(equation)
-            if lhs_symbol is None:
-                return False
-            
-            # Get all variables referenced in RHS
-            rhs_vars = equation.rhs.get_variables() if hasattr(equation.rhs, 'get_variables') else set()
-            
-            # Check if the LHS variable appears multiple times in RHS (indicating self-reference)
-            # This is a heuristic - a proper implementation would parse the expression tree
-            equation_str = str(equation)
-            if lhs_symbol in rhs_vars:
-                # For conditional equations, self-references are often valid (as fallback values)
-                if 'cond(' in equation_str:
-                    return False  # Allow self-references in conditional equations
-                
-                # Count occurrences of the variable in the equation string
-                count = equation_str.count(lhs_symbol)
-                if count > 2:  # LHS + multiple RHS occurrences
-                    return True
-            
-            return False
-            
-        except Exception:
-            return False
-
-
-    def _is_conditional_equation_from_subproblem(self, equation: Equation, _equation_name: str) -> bool:
-        """
-        Check if a conditional equation comes from a sub-problem and should be skipped in composed systems.
-        
-        In composed systems, if a sub-problem's conditional variable is already set to a known value,
-        we don't want to include the conditional equation that would override that known value.
-        """
-        try:
-            # Check if this is a conditional equation with a known LHS variable
-            lhs_symbol = self._get_equation_lhs_symbol(equation)
-            if lhs_symbol is not None:
-                
-                # Check if the LHS variable already exists and is known
-                if lhs_symbol in self.variables:
-                    var = self.variables[lhs_symbol]
-                    # If the variable is already known (set explicitly in composition),
-                    # and this conditional equation references missing variables, skip it
-                    missing_vars = equation.get_all_variables() - set(self.variables.keys())
-                    if missing_vars and var.is_known:
-                        # This is a sub-problem's conditional equation for a variable that's already known
-                        # No point including it since the value is already determined
-                        return True
-            
-            return False
-            
-        except Exception:
-            return False
-
-    def _should_skip_subproblem_equation(self, equation: Equation, namespace: str) -> bool:
-        """
-        Check if an equation from a sub-problem should be skipped during integration.
-        
-        Skip conditional equations for variables that are set to known values in the composed problem.
-        """
-        try:
-            # Check if this is a conditional equation
-            if not self._is_conditional_equation(equation):
-                return False
-                
-            # Check if the LHS variable would be set to a known value in composition
-            original_symbol = self._get_equation_lhs_symbol(equation)
-            if original_symbol is not None:
-                namespaced_symbol = f"{namespace}_{original_symbol}"
-                
-                # Check if this namespaced variable exists and is already known
-                if namespaced_symbol in self.variables:
-                    var = self.variables[namespaced_symbol]
-                    if var.is_known:
-                        # The variable is already set to a known value in composition,
-                        # so skip the conditional equation that would override it
-                        self.logger.debug(f"Skipping conditional equation for {namespaced_symbol} (already known: {var.quantity})")
-                        return True
-            
-            return False
-            
-        except Exception:
-            return False
-
-    # =============================================================================
-    # VARIABLE MANAGEMENT METHODS
-    # =============================================================================
-
-    def add_variable(self, variable: Variable) -> None:
-        """
-        Add a variable to the problem.
-        
-        The variable will be available for use in equations and can be accessed
-        via both dictionary notation (problem['symbol']) and attribute notation
-        (problem.symbol).
-        
-        Args:
-            variable: Variable object to add to the problem
-            
-        Note:
-            If a variable with the same symbol already exists, it will be replaced
-            and a warning will be logged.
-        """
-        if variable.symbol in self.variables:
-            self.logger.warning(f"Variable {variable.symbol} already exists. Replacing.")
-        
-        if variable.symbol is not None:
-            self.variables[variable.symbol] = variable
-        # Set parent problem reference for dependency invalidation
-        try:
-            setattr(variable, '_parent_problem', self)
-        except (AttributeError, TypeError):
-            # _parent_problem might not be settable
-            pass
-        # Also set as instance attribute for dot notation access
-        if variable.symbol is not None:
-            setattr(self, variable.symbol, variable)
-        self.is_solved = False
-        self._invalidate_caches()
-
-    def add_variables(self, *variables: Variable) -> None:
-        """Add multiple variables to the problem."""
-        for var in variables:
-            self.add_variable(var)
-
-    def get_variable(self, symbol: str) -> Variable:
-        """Get a variable by its symbol."""
-        if symbol not in self.variables:
-            raise VariableNotFoundError(f"Variable '{symbol}' not found in problem '{self.name}'.")
-        return self.variables[symbol]
-    
-    def get_known_variables(self) -> dict[str, Variable]:
-        """Get all known variables."""
-        if self._cache_dirty or self._known_variables_cache is None:
-            self._update_variable_caches()
-        return self._known_variables_cache.copy() if self._known_variables_cache else {}
-
-    def get_unknown_variables(self) -> dict[str, Variable]:
-        """Get all unknown variables."""
-        if self._cache_dirty or self._unknown_variables_cache is None:
-            self._update_variable_caches()
-        return self._unknown_variables_cache.copy() if self._unknown_variables_cache else {}
-
-    def get_known_symbols(self) -> set[str]:
-        """Get symbols of all known variables."""
-        return {symbol for symbol, var in self.variables.items() if var.is_known}
-
-    def get_unknown_symbols(self) -> set[str]:
-        """Get symbols of all unknown variables."""
-        return {symbol for symbol, var in self.variables.items() if not var.is_known}
-    
-    def get_known_variable_symbols(self) -> set[str]:
-        """Alias for get_known_symbols for compatibility."""
-        return self.get_known_symbols()
-    
-    def get_unknown_variable_symbols(self) -> set[str]:
-        """Alias for get_unknown_symbols for compatibility."""
-        return self.get_unknown_symbols()
-    
-    # Properties for compatibility
-    @property
-    def known_variables(self) -> dict[str, Variable]:
-        """Get all variables marked as known."""
-        return self.get_known_variables()
-    
-    @property
-    def unknown_variables(self) -> dict[str, Variable]:
-        """Get all variables marked as unknown."""
-        return self.get_unknown_variables()
-
-    def mark_unknown(self, *symbols: str) -> Problem:
-        """Mark variables as unknown (to be solved for)."""
-        for symbol in symbols:
-            if symbol in self.variables:
-                self.variables[symbol].mark_unknown()
-            else:
-                raise VariableNotFoundError(f"Variable '{symbol}' not found in problem '{self.name}'")
-        self.is_solved = False
-        self._invalidate_caches()
-        return self
-    
-    def mark_known(self, **symbol_values: Qty) -> Problem:
-        """Mark variables as known and set their values."""
-        for symbol, quantity in symbol_values.items():
-            if symbol in self.variables:
-                self.variables[symbol].mark_known(quantity)
-            else:
-                raise VariableNotFoundError(f"Variable '{symbol}' not found in problem '{self.name}'")
-        self.is_solved = False
-        self._invalidate_caches()
-        return self
-
-    def invalidate_dependents(self, changed_variable_symbol: str) -> None:
-        """
-        Mark all variables that depend on the changed variable as unknown.
-        This ensures they get recalculated when the problem is re-solved.
-        
-        Args:
-            changed_variable_symbol: Symbol of the variable whose value changed
-        """
-        if not hasattr(self, 'dependency_graph') or not self.dependency_graph:
-            # If dependency graph hasn't been built yet, we can't invalidate
-            return
-            
-        # Get all variables that depend on the changed variable
-        dependent_vars = self.dependency_graph.graph.get(changed_variable_symbol, [])
-        
-        # Mark each dependent variable as unknown
-        for dependent_symbol in dependent_vars:
-            if dependent_symbol in self.variables:
-                var = self.variables[dependent_symbol]
-                # Only mark as unknown if it was previously solved (known)
-                if var.is_known:
-                    var.mark_unknown()
-                    # Recursively invalidate variables that depend on this one
-                    self.invalidate_dependents(dependent_symbol)
-        
-        # Mark problem as needing re-solving
-        self.is_solved = False
-        self._invalidate_caches()
-
-    # =============================================================================
-    # EQUATION MANAGEMENT METHODS
-    # =============================================================================
-
-    def add_equation(self, equation: Equation) -> None:
-        """
-        Add an equation to the problem.
-        
-        The equation will be validated to ensure all referenced variables exist.
-        Missing variables that look like simple identifiers will be auto-created
-        as unknown placeholders.
-        
-        Args:
-            equation: Equation object to add to the problem
-            
-        Raises:
-            EquationValidationError: If the equation is invalid or cannot be processed
-            
-        Note:
-            Adding an equation resets the problem to unsolved state.
-        """
-        if equation is None:
-            raise EquationValidationError("Cannot add None equation to problem")
-        
-        # Fix VariableReferences in equation to point to correct Variables
-        equation = self._fix_variable_references(equation)
-        
-        # Validate that all variables in the equation exist
-        try:
-            equation_vars = equation.get_all_variables()
-        except Exception as e:
-            raise EquationValidationError(f"Failed to extract variables from equation: {e}") from e
-        
-        missing_vars = [var for var in equation_vars if var not in self.variables]
-        
-        if missing_vars:
-            self._handle_missing_variables(missing_vars)
-            
-            # Check again for remaining missing variables
-            equation_vars = equation.get_all_variables()
-            remaining_missing = [var for var in equation_vars if var not in self.variables]
-            if remaining_missing:
-                self.logger.warning(f"Equation references missing variables: {remaining_missing}")
-        
-        self.equations.append(equation)
-        self.equation_system.add_equation(equation)
-        self.is_solved = False
-
-    def _handle_missing_variables(self, missing_vars: list[str]) -> None:
-        """Handle missing variables by creating placeholders for simple symbols."""
-        for missing_var in missing_vars:
-            if self._is_simple_variable_symbol(missing_var):
-                self._create_placeholder_variable(missing_var)
-
-    def _is_simple_variable_symbol(self, symbol: str) -> bool:
-        """Check if a symbol looks like a simple variable identifier."""
-        return (symbol.isidentifier() and
-                not any(char in symbol for char in ['(', ')', '+', '-', '*', '/', ' ']))
-
-    def _create_placeholder_variable(self, symbol: str) -> None:
-        """Create a placeholder variable for a missing symbol."""
-        
-        placeholder_var = Variable(
-            name=f"Auto-created: {symbol}",
-            expected_dimension=DimensionlessUnits.dimensionless.dimension,
-            is_known=False
-        )
-        placeholder_var.symbol = symbol
-        placeholder_var.quantity = Qty(0.0, DimensionlessUnits.dimensionless)
-        self.add_variable(placeholder_var)
-        self.logger.debug(f"Auto-created placeholder variable: {symbol}")
-
-    def add_equations(self, *equations: Equation) -> Problem:
-        """Add multiple equations to the problem."""
-        for eq in equations:
-            self.add_equation(eq)
-        return self
-
-    # =============================================================================
-    # PROBLEM SOLVING METHODS
-    # =============================================================================
-
-    def solve(self, max_iterations: int = MAX_ITERATIONS_DEFAULT, tolerance: float = TOLERANCE_DEFAULT) -> dict[str, Variable]:
-        """
-        Solve the engineering problem by finding values for all unknown variables.
-        
-        This method orchestrates the complete solving process:
-        1. Builds dependency graph from equations
-        2. Determines optimal solving order using topological sorting
-        3. Solves equations iteratively using symbolic/numerical methods
-        4. Verifies solution against all equations
-        5. Updates variable states and synchronizes instance attributes
-        
-        Args:
-            max_iterations: Maximum number of solving iterations (default: 100)
-            tolerance: Numerical tolerance for convergence (default: 1e-10)
-            
-        Returns:
-            dict mapping variable symbols to solved Variable objects
-            
-        Raises:
-            SolverError: If solving fails or times out
-            
-        Example:
-            >>> problem = MyEngineeringProblem()
-            >>> solution = problem.solve()
-            >>> print(f"Force = {solution['F'].quantity}")
-        """
-        self.logger.info(f"Solving problem: {self.name}")
-        
-        try:
-            # Clear previous solution
-            self.solution = {}
-            self.is_solved = False
-            self.solving_history = []
-            
-            # Build dependency graph
-            self._build_dependency_graph()
-            
-            # Use solver manager to solve the system
-            solve_result = self.solver_manager.solve(
-                self.equations,
-                self.variables,
-                self.dependency_graph,
-                max_iterations,
-                tolerance
-            )
-            
-            if solve_result.success:
-                # Update variables with the result
-                self.variables = solve_result.variables
-                self.solving_history.extend(solve_result.steps)
-                
-                # Sync solved values back to instance attributes
-                self._sync_variables_to_instance_attributes()
-                
-                # Verify solution
-                self.solution = self.variables
-                verification_passed = self.verify_solution()
-                
-                # Mark as solved based on solver result and verification
-                if verification_passed:
-                    self.is_solved = True
-                    self.logger.info("Solution verified successfully")
-                    return self.solution
-                else:
-                    self.logger.warning("Solution verification failed")
-                    return self.solution
-            else:
-                raise SolverError(f"Solving failed: {solve_result.message}")
-                
-        except SolverError:
-            raise
-        except Exception as e:
-            self.logger.error(f"Solving failed: {e}")
-            raise SolverError(f"Unexpected error during solving: {e}") from e
-
-    def _build_dependency_graph(self):
-        """Build the dependency graph for solving order determination."""
-        # Reset the dependency graph
-        self.dependency_graph = Order()
-        
-        # Get known variables
-        known_vars = self.get_known_symbols()
-        
-        # Add dependencies from equations
-        for equation in self.equations:
-            self.dependency_graph.add_equation(equation, known_vars)
-
-    def _sync_variables_to_instance_attributes(self):
-        """
-        Sync variable objects to instance attributes after solving.
-        This ensures that self.P refers to the same Variable object that's in self.variables.
-        Variables maintain their original dimensional types (e.g., AreaVariable, PressureVariable).
-        """
-        for var_symbol, var in self.variables.items():
-            # Update instance attribute if it exists
-            if hasattr(self, var_symbol):
-                # Variables preserve their dimensional types during solving
-                setattr(self, var_symbol, var)
-        
-        # Also update sub-problem namespace objects
-        for namespace, sub_problem in self.sub_problems.items():
-            if hasattr(self, namespace):
-                namespace_obj = getattr(self, namespace)
-                for var_symbol in sub_problem.variables:
-                    namespaced_symbol = f"{namespace}_{var_symbol}"
-                    if namespaced_symbol in self.variables and hasattr(namespace_obj, var_symbol):
-                        setattr(namespace_obj, var_symbol, self.variables[namespaced_symbol])
-
-    def verify_solution(self, tolerance: float = 1e-10) -> bool:
-        """Verify that all equations are satisfied."""
-        if not self.equations:
-            return True
-        
-        try:
-            for equation in self.equations:
-                if not equation.check_residual(self.variables, tolerance):
-                    self.logger.debug(f"Equation verification failed: {equation}")
-                    return False
-            return True
-        except Exception as e:
-            self.logger.debug(f"Solution verification error: {e}")
-            return False
-
-    # =============================================================================
-    # SYSTEM ANALYSIS METHODS
-    # =============================================================================
-
-    def analyze_system(self) -> dict[str, Any]:
-        """Analyze the equation system for solvability, cycles, etc."""
-        try:
-            self._build_dependency_graph()
-            known_vars = self.get_known_symbols()
-            analysis = self.dependency_graph.analyze_system(known_vars)
-            
-            # Add some additional info
-            analysis['total_equations'] = len(self.equations)
-            analysis['is_determined'] = len(self.get_unknown_variables()) <= len(self.equations)
-            
-            return analysis
-        except Exception as e:
-            self.logger.debug(f"Dependency analysis failed: {e}")
-            # Return basic analysis on failure
-            return {
-                'total_variables': len(self.variables),
-                'known_variables': len(self.get_known_variables()),
-                'unknown_variables': len(self.get_unknown_variables()),
-                'total_equations': len(self.equations),
-                'is_determined': len(self.get_unknown_variables()) <= len(self.equations),
-                'has_cycles': False,
-                'solving_order': [],
-                'can_solve_completely': False,
-                'unsolvable_variables': []
-            }
-
-    def reset_solution(self):
-        """Reset the problem to unsolved state."""
-        self.is_solved = False
-        self.solution = {}
-        self.solving_history = []
-        
-        # Reset unknown variables to unknown state
-        for var in self.variables.values():
-            if not var.is_known:
-                var.is_known = False
-
-    def _invalidate_caches(self) -> None:
-        """Invalidate performance caches when variables change."""
-        self._cache_dirty = True
-
-    def _update_variable_caches(self) -> None:
-        """Update the variable caches for performance."""
-        if not self._cache_dirty:
-            return
-            
-        self._known_variables_cache = {symbol: var for symbol, var in self.variables.items() if var.is_known}
-        self._unknown_variables_cache = {symbol: var for symbol, var in self.variables.items() if not var.is_known}
-        self._cache_dirty = False
-
-    # =============================================================================
-    # VALIDATION AND WARNING SYSTEM
-    # =============================================================================
-
-    def add_validation_check(self, check_function: Callable) -> None:
-        """Add a validation check function."""
-        self.validation_checks.append(check_function)
-
-    def validate(self) -> list[dict[str, Any]]:
-        """Run all validation checks and return any warnings."""
-        validation_warnings = []
-        
-        for check in self.validation_checks:
-            try:
-                result = check(self)
-                if result:
-                    validation_warnings.append(result)
-            except Exception as e:
-                self.logger.debug(f"Validation check failed: {e}")
-        
-        return validation_warnings
-
-    def get_warnings(self) -> list[dict[str, Any]]:
-        """Get all warnings from the problem."""
-        warnings = self.warnings.copy()
-        warnings.extend(self.validate())
-        return warnings
-
-    # =============================================================================
-    # UTILITY METHODS
-    # =============================================================================
-
-    def copy(self) -> Problem:
-        """Create a copy of this problem."""
-        from copy import deepcopy
-        return deepcopy(self)
-
-    def __str__(self) -> str:
-        """String representation of the problem."""
-        status = "SOLVED" if self.is_solved else "UNSOLVED"
-        return f"EngineeringProblem('{self.name}', vars={len(self.variables)}, eqs={len(self.equations)}, {status})"
-
-    def __repr__(self) -> str:
-        """Detailed representation of the problem."""
-        return self.__str__()
-
-    # =============================================================================
-    # SPECIAL METHODS FOR ATTRIBUTE ACCESS
-    # =============================================================================
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        """Custom attribute setting to maintain variable synchronization."""
-        # During initialization, use normal attribute setting
-        if not hasattr(self, 'variables') or name.startswith('_'):
-            super().__setattr__(name, value)
-            return
-        
-        # If setting a variable that exists in our variables dict, update both
-        if isinstance(value, Variable) and name in self.variables:
-            self.variables[name] = value
-        
-        super().__setattr__(name, value)
-
-    def __getitem__(self, key: str) -> Variable:
-        """Allow dict-like access to variables."""
-        return self.get_variable(key)
-
-    def __setitem__(self, key: str, value: Variable) -> None:
-        """Allow dict-like assignment of variables."""
-        # Update the symbol to match the key if they differ
-        if value.symbol != key:
-            value.symbol = key
-        self.add_variable(value)
-    
-    def _update_equation_variable_references(self, equation: Equation) -> Equation:
-        """Update VariableReference objects in equation to use symbols instead of names."""
-        from qnty.expressions import VariableReference
-        
-        # Update LHS if it's a VariableReference
-        updated_lhs = equation.lhs
-        if isinstance(equation.lhs, VariableReference):
-            # Find the variable by name and update to use symbol
-            var_name = equation.lhs.variable.name
-            matching_var = None
-            for var in self.variables.values():
-                if var.name == var_name:
-                    matching_var = var
-                    break
-            if matching_var and matching_var.symbol:
-                updated_lhs = VariableReference(matching_var)
-        
-        # Update RHS by recursively updating expressions
-        updated_rhs = self._update_expression_variable_references(equation.rhs)
-        
-        # Create new equation with updated references
-        return Equation(equation.name, updated_lhs, updated_rhs)
-    
-    def _update_expression_variable_references(self, expr):
-        """Recursively update VariableReference objects in expression tree."""
-        from qnty.expressions import VariableReference, BinaryOperation, Constant
-        
-        if isinstance(expr, VariableReference):
-            # Find the variable by name and update to use symbol
-            var_name = expr.variable.name
-            matching_var = None
-            for var in self.variables.values():
-                if var.name == var_name:
-                    matching_var = var
-                    break
-            if matching_var and matching_var.symbol:
-                return VariableReference(matching_var)
-            return expr
-        elif isinstance(expr, BinaryOperation):
-            updated_left = self._update_expression_variable_references(expr.left)
-            updated_right = self._update_expression_variable_references(expr.right)
-            return BinaryOperation(expr.operator, updated_left, updated_right)
-        elif isinstance(expr, Constant):
-            return expr
-        else:
-            # Return unknown expression types as-is
-            return expr